dasd_eckd.c 185 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
  4. * Horst Hummel <Horst.Hummel@de.ibm.com>
  5. * Carsten Otte <Cotte@de.ibm.com>
  6. * Martin Schwidefsky <schwidefsky@de.ibm.com>
  7. * Bugreports.to..: <Linux390@de.ibm.com>
  8. * Copyright IBM Corp. 1999, 2009
  9. * EMC Symmetrix ioctl Copyright EMC Corporation, 2008
  10. * Author.........: Nigel Hislop <hislop_nigel@emc.com>
  11. */
  12. #define KMSG_COMPONENT "dasd-eckd"
  13. #include <linux/stddef.h>
  14. #include <linux/kernel.h>
  15. #include <linux/slab.h>
  16. #include <linux/hdreg.h> /* HDIO_GETGEO */
  17. #include <linux/bio.h>
  18. #include <linux/module.h>
  19. #include <linux/compat.h>
  20. #include <linux/init.h>
  21. #include <linux/seq_file.h>
  22. #include <asm/css_chars.h>
  23. #include <asm/debug.h>
  24. #include <asm/idals.h>
  25. #include <asm/ebcdic.h>
  26. #include <asm/io.h>
  27. #include <linux/uaccess.h>
  28. #include <asm/cio.h>
  29. #include <asm/ccwdev.h>
  30. #include <asm/itcw.h>
  31. #include <asm/schid.h>
  32. #include <asm/chpid.h>
  33. #include "dasd_int.h"
  34. #include "dasd_eckd.h"
  35. #ifdef PRINTK_HEADER
  36. #undef PRINTK_HEADER
  37. #endif /* PRINTK_HEADER */
  38. #define PRINTK_HEADER "dasd(eckd):"
  39. /*
  40. * raw track access always map to 64k in memory
  41. * so it maps to 16 blocks of 4k per track
  42. */
  43. #define DASD_RAW_BLOCK_PER_TRACK 16
  44. #define DASD_RAW_BLOCKSIZE 4096
  45. /* 64k are 128 x 512 byte sectors */
  46. #define DASD_RAW_SECTORS_PER_TRACK 128
  47. MODULE_LICENSE("GPL");
  48. static struct dasd_discipline dasd_eckd_discipline;
  49. /* The ccw bus type uses this table to find devices that it sends to
  50. * dasd_eckd_probe */
  51. static struct ccw_device_id dasd_eckd_ids[] = {
  52. { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3390, 0), .driver_info = 0x1},
  53. { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3390, 0), .driver_info = 0x2},
  54. { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3380, 0), .driver_info = 0x3},
  55. { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3380, 0), .driver_info = 0x4},
  56. { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3380, 0), .driver_info = 0x5},
  57. { CCW_DEVICE_DEVTYPE (0x9343, 0, 0x9345, 0), .driver_info = 0x6},
  58. { CCW_DEVICE_DEVTYPE (0x2107, 0, 0x3390, 0), .driver_info = 0x7},
  59. { CCW_DEVICE_DEVTYPE (0x2107, 0, 0x3380, 0), .driver_info = 0x8},
  60. { CCW_DEVICE_DEVTYPE (0x1750, 0, 0x3390, 0), .driver_info = 0x9},
  61. { CCW_DEVICE_DEVTYPE (0x1750, 0, 0x3380, 0), .driver_info = 0xa},
  62. { /* end of list */ },
  63. };
  64. MODULE_DEVICE_TABLE(ccw, dasd_eckd_ids);
  65. static struct ccw_driver dasd_eckd_driver; /* see below */
  66. static void *rawpadpage;
  67. #define INIT_CQR_OK 0
  68. #define INIT_CQR_UNFORMATTED 1
  69. #define INIT_CQR_ERROR 2
  70. /* emergency request for reserve/release */
  71. static struct {
  72. struct dasd_ccw_req cqr;
  73. struct ccw1 ccw;
  74. char data[32];
  75. } *dasd_reserve_req;
  76. static DEFINE_MUTEX(dasd_reserve_mutex);
  77. static struct {
  78. struct dasd_ccw_req cqr;
  79. struct ccw1 ccw[2];
  80. char data[40];
  81. } *dasd_vol_info_req;
  82. static DEFINE_MUTEX(dasd_vol_info_mutex);
  83. struct ext_pool_exhaust_work_data {
  84. struct work_struct worker;
  85. struct dasd_device *device;
  86. struct dasd_device *base;
  87. };
  88. /* definitions for the path verification worker */
  89. struct path_verification_work_data {
  90. struct work_struct worker;
  91. struct dasd_device *device;
  92. struct dasd_ccw_req cqr;
  93. struct ccw1 ccw;
  94. __u8 rcd_buffer[DASD_ECKD_RCD_DATA_SIZE];
  95. int isglobal;
  96. __u8 tbvpm;
  97. };
  98. static struct path_verification_work_data *path_verification_worker;
  99. static DEFINE_MUTEX(dasd_path_verification_mutex);
  100. struct check_attention_work_data {
  101. struct work_struct worker;
  102. struct dasd_device *device;
  103. __u8 lpum;
  104. };
  105. static int dasd_eckd_ext_pool_id(struct dasd_device *);
  106. static int prepare_itcw(struct itcw *, unsigned int, unsigned int, int,
  107. struct dasd_device *, struct dasd_device *,
  108. unsigned int, int, unsigned int, unsigned int,
  109. unsigned int, unsigned int);
  110. /* initial attempt at a probe function. this can be simplified once
  111. * the other detection code is gone */
  112. static int
  113. dasd_eckd_probe (struct ccw_device *cdev)
  114. {
  115. int ret;
  116. /* set ECKD specific ccw-device options */
  117. ret = ccw_device_set_options(cdev, CCWDEV_ALLOW_FORCE |
  118. CCWDEV_DO_PATHGROUP | CCWDEV_DO_MULTIPATH);
  119. if (ret) {
  120. DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s",
  121. "dasd_eckd_probe: could not set "
  122. "ccw-device options");
  123. return ret;
  124. }
  125. ret = dasd_generic_probe(cdev, &dasd_eckd_discipline);
  126. return ret;
  127. }
  128. static int
  129. dasd_eckd_set_online(struct ccw_device *cdev)
  130. {
  131. return dasd_generic_set_online(cdev, &dasd_eckd_discipline);
  132. }
  133. static const int sizes_trk0[] = { 28, 148, 84 };
  134. #define LABEL_SIZE 140
  135. /* head and record addresses of count_area read in analysis ccw */
  136. static const int count_area_head[] = { 0, 0, 0, 0, 1 };
  137. static const int count_area_rec[] = { 1, 2, 3, 4, 1 };
  138. static inline unsigned int
  139. ceil_quot(unsigned int d1, unsigned int d2)
  140. {
  141. return (d1 + (d2 - 1)) / d2;
  142. }
  143. static unsigned int
  144. recs_per_track(struct dasd_eckd_characteristics * rdc,
  145. unsigned int kl, unsigned int dl)
  146. {
  147. int dn, kn;
  148. switch (rdc->dev_type) {
  149. case 0x3380:
  150. if (kl)
  151. return 1499 / (15 + 7 + ceil_quot(kl + 12, 32) +
  152. ceil_quot(dl + 12, 32));
  153. else
  154. return 1499 / (15 + ceil_quot(dl + 12, 32));
  155. case 0x3390:
  156. dn = ceil_quot(dl + 6, 232) + 1;
  157. if (kl) {
  158. kn = ceil_quot(kl + 6, 232) + 1;
  159. return 1729 / (10 + 9 + ceil_quot(kl + 6 * kn, 34) +
  160. 9 + ceil_quot(dl + 6 * dn, 34));
  161. } else
  162. return 1729 / (10 + 9 + ceil_quot(dl + 6 * dn, 34));
  163. case 0x9345:
  164. dn = ceil_quot(dl + 6, 232) + 1;
  165. if (kl) {
  166. kn = ceil_quot(kl + 6, 232) + 1;
  167. return 1420 / (18 + 7 + ceil_quot(kl + 6 * kn, 34) +
  168. ceil_quot(dl + 6 * dn, 34));
  169. } else
  170. return 1420 / (18 + 7 + ceil_quot(dl + 6 * dn, 34));
  171. }
  172. return 0;
  173. }
  174. static void set_ch_t(struct ch_t *geo, __u32 cyl, __u8 head)
  175. {
  176. geo->cyl = (__u16) cyl;
  177. geo->head = cyl >> 16;
  178. geo->head <<= 4;
  179. geo->head |= head;
  180. }
  181. /*
  182. * calculate failing track from sense data depending if
  183. * it is an EAV device or not
  184. */
  185. static int dasd_eckd_track_from_irb(struct irb *irb, struct dasd_device *device,
  186. sector_t *track)
  187. {
  188. struct dasd_eckd_private *private = device->private;
  189. u8 *sense = NULL;
  190. u32 cyl;
  191. u8 head;
  192. sense = dasd_get_sense(irb);
  193. if (!sense) {
  194. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  195. "ESE error no sense data\n");
  196. return -EINVAL;
  197. }
  198. if (!(sense[27] & DASD_SENSE_BIT_2)) {
  199. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  200. "ESE error no valid track data\n");
  201. return -EINVAL;
  202. }
  203. if (sense[27] & DASD_SENSE_BIT_3) {
  204. /* enhanced addressing */
  205. cyl = sense[30] << 20;
  206. cyl |= (sense[31] & 0xF0) << 12;
  207. cyl |= sense[28] << 8;
  208. cyl |= sense[29];
  209. } else {
  210. cyl = sense[29] << 8;
  211. cyl |= sense[30];
  212. }
  213. head = sense[31] & 0x0F;
  214. *track = cyl * private->rdc_data.trk_per_cyl + head;
  215. return 0;
  216. }
  217. static int set_timestamp(struct ccw1 *ccw, struct DE_eckd_data *data,
  218. struct dasd_device *device)
  219. {
  220. struct dasd_eckd_private *private = device->private;
  221. int rc;
  222. rc = get_phys_clock(&data->ep_sys_time);
  223. /*
  224. * Ignore return code if XRC is not supported or
  225. * sync clock is switched off
  226. */
  227. if ((rc && !private->rdc_data.facilities.XRC_supported) ||
  228. rc == -EOPNOTSUPP || rc == -EACCES)
  229. return 0;
  230. /* switch on System Time Stamp - needed for XRC Support */
  231. data->ga_extended |= 0x08; /* switch on 'Time Stamp Valid' */
  232. data->ga_extended |= 0x02; /* switch on 'Extended Parameter' */
  233. if (ccw) {
  234. ccw->count = sizeof(struct DE_eckd_data);
  235. ccw->flags |= CCW_FLAG_SLI;
  236. }
  237. return rc;
  238. }
  239. static int
  240. define_extent(struct ccw1 *ccw, struct DE_eckd_data *data, unsigned int trk,
  241. unsigned int totrk, int cmd, struct dasd_device *device,
  242. int blksize)
  243. {
  244. struct dasd_eckd_private *private = device->private;
  245. u16 heads, beghead, endhead;
  246. u32 begcyl, endcyl;
  247. int rc = 0;
  248. if (ccw) {
  249. ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT;
  250. ccw->flags = 0;
  251. ccw->count = 16;
  252. ccw->cda = (__u32)__pa(data);
  253. }
  254. memset(data, 0, sizeof(struct DE_eckd_data));
  255. switch (cmd) {
  256. case DASD_ECKD_CCW_READ_HOME_ADDRESS:
  257. case DASD_ECKD_CCW_READ_RECORD_ZERO:
  258. case DASD_ECKD_CCW_READ:
  259. case DASD_ECKD_CCW_READ_MT:
  260. case DASD_ECKD_CCW_READ_CKD:
  261. case DASD_ECKD_CCW_READ_CKD_MT:
  262. case DASD_ECKD_CCW_READ_KD:
  263. case DASD_ECKD_CCW_READ_KD_MT:
  264. data->mask.perm = 0x1;
  265. data->attributes.operation = private->attrib.operation;
  266. break;
  267. case DASD_ECKD_CCW_READ_COUNT:
  268. data->mask.perm = 0x1;
  269. data->attributes.operation = DASD_BYPASS_CACHE;
  270. break;
  271. case DASD_ECKD_CCW_READ_TRACK:
  272. case DASD_ECKD_CCW_READ_TRACK_DATA:
  273. data->mask.perm = 0x1;
  274. data->attributes.operation = private->attrib.operation;
  275. data->blk_size = 0;
  276. break;
  277. case DASD_ECKD_CCW_WRITE:
  278. case DASD_ECKD_CCW_WRITE_MT:
  279. case DASD_ECKD_CCW_WRITE_KD:
  280. case DASD_ECKD_CCW_WRITE_KD_MT:
  281. data->mask.perm = 0x02;
  282. data->attributes.operation = private->attrib.operation;
  283. rc = set_timestamp(ccw, data, device);
  284. break;
  285. case DASD_ECKD_CCW_WRITE_CKD:
  286. case DASD_ECKD_CCW_WRITE_CKD_MT:
  287. data->attributes.operation = DASD_BYPASS_CACHE;
  288. rc = set_timestamp(ccw, data, device);
  289. break;
  290. case DASD_ECKD_CCW_ERASE:
  291. case DASD_ECKD_CCW_WRITE_HOME_ADDRESS:
  292. case DASD_ECKD_CCW_WRITE_RECORD_ZERO:
  293. data->mask.perm = 0x3;
  294. data->mask.auth = 0x1;
  295. data->attributes.operation = DASD_BYPASS_CACHE;
  296. rc = set_timestamp(ccw, data, device);
  297. break;
  298. case DASD_ECKD_CCW_WRITE_FULL_TRACK:
  299. data->mask.perm = 0x03;
  300. data->attributes.operation = private->attrib.operation;
  301. data->blk_size = 0;
  302. break;
  303. case DASD_ECKD_CCW_WRITE_TRACK_DATA:
  304. data->mask.perm = 0x02;
  305. data->attributes.operation = private->attrib.operation;
  306. data->blk_size = blksize;
  307. rc = set_timestamp(ccw, data, device);
  308. break;
  309. default:
  310. dev_err(&device->cdev->dev,
  311. "0x%x is not a known command\n", cmd);
  312. break;
  313. }
  314. data->attributes.mode = 0x3; /* ECKD */
  315. if ((private->rdc_data.cu_type == 0x2105 ||
  316. private->rdc_data.cu_type == 0x2107 ||
  317. private->rdc_data.cu_type == 0x1750)
  318. && !(private->uses_cdl && trk < 2))
  319. data->ga_extended |= 0x40; /* Regular Data Format Mode */
  320. heads = private->rdc_data.trk_per_cyl;
  321. begcyl = trk / heads;
  322. beghead = trk % heads;
  323. endcyl = totrk / heads;
  324. endhead = totrk % heads;
  325. /* check for sequential prestage - enhance cylinder range */
  326. if (data->attributes.operation == DASD_SEQ_PRESTAGE ||
  327. data->attributes.operation == DASD_SEQ_ACCESS) {
  328. if (endcyl + private->attrib.nr_cyl < private->real_cyl)
  329. endcyl += private->attrib.nr_cyl;
  330. else
  331. endcyl = (private->real_cyl - 1);
  332. }
  333. set_ch_t(&data->beg_ext, begcyl, beghead);
  334. set_ch_t(&data->end_ext, endcyl, endhead);
  335. return rc;
  336. }
  337. static void locate_record_ext(struct ccw1 *ccw, struct LRE_eckd_data *data,
  338. unsigned int trk, unsigned int rec_on_trk,
  339. int count, int cmd, struct dasd_device *device,
  340. unsigned int reclen, unsigned int tlf)
  341. {
  342. struct dasd_eckd_private *private = device->private;
  343. int sector;
  344. int dn, d;
  345. if (ccw) {
  346. ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD_EXT;
  347. ccw->flags = 0;
  348. if (cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK)
  349. ccw->count = 22;
  350. else
  351. ccw->count = 20;
  352. ccw->cda = (__u32)__pa(data);
  353. }
  354. memset(data, 0, sizeof(*data));
  355. sector = 0;
  356. if (rec_on_trk) {
  357. switch (private->rdc_data.dev_type) {
  358. case 0x3390:
  359. dn = ceil_quot(reclen + 6, 232);
  360. d = 9 + ceil_quot(reclen + 6 * (dn + 1), 34);
  361. sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8;
  362. break;
  363. case 0x3380:
  364. d = 7 + ceil_quot(reclen + 12, 32);
  365. sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7;
  366. break;
  367. }
  368. }
  369. data->sector = sector;
  370. /* note: meaning of count depends on the operation
  371. * for record based I/O it's the number of records, but for
  372. * track based I/O it's the number of tracks
  373. */
  374. data->count = count;
  375. switch (cmd) {
  376. case DASD_ECKD_CCW_WRITE_HOME_ADDRESS:
  377. data->operation.orientation = 0x3;
  378. data->operation.operation = 0x03;
  379. break;
  380. case DASD_ECKD_CCW_READ_HOME_ADDRESS:
  381. data->operation.orientation = 0x3;
  382. data->operation.operation = 0x16;
  383. break;
  384. case DASD_ECKD_CCW_WRITE_RECORD_ZERO:
  385. data->operation.orientation = 0x1;
  386. data->operation.operation = 0x03;
  387. data->count++;
  388. break;
  389. case DASD_ECKD_CCW_READ_RECORD_ZERO:
  390. data->operation.orientation = 0x3;
  391. data->operation.operation = 0x16;
  392. data->count++;
  393. break;
  394. case DASD_ECKD_CCW_WRITE:
  395. case DASD_ECKD_CCW_WRITE_MT:
  396. case DASD_ECKD_CCW_WRITE_KD:
  397. case DASD_ECKD_CCW_WRITE_KD_MT:
  398. data->auxiliary.length_valid = 0x1;
  399. data->length = reclen;
  400. data->operation.operation = 0x01;
  401. break;
  402. case DASD_ECKD_CCW_WRITE_CKD:
  403. case DASD_ECKD_CCW_WRITE_CKD_MT:
  404. data->auxiliary.length_valid = 0x1;
  405. data->length = reclen;
  406. data->operation.operation = 0x03;
  407. break;
  408. case DASD_ECKD_CCW_WRITE_FULL_TRACK:
  409. data->operation.orientation = 0x0;
  410. data->operation.operation = 0x3F;
  411. data->extended_operation = 0x11;
  412. data->length = 0;
  413. data->extended_parameter_length = 0x02;
  414. if (data->count > 8) {
  415. data->extended_parameter[0] = 0xFF;
  416. data->extended_parameter[1] = 0xFF;
  417. data->extended_parameter[1] <<= (16 - count);
  418. } else {
  419. data->extended_parameter[0] = 0xFF;
  420. data->extended_parameter[0] <<= (8 - count);
  421. data->extended_parameter[1] = 0x00;
  422. }
  423. data->sector = 0xFF;
  424. break;
  425. case DASD_ECKD_CCW_WRITE_TRACK_DATA:
  426. data->auxiliary.length_valid = 0x1;
  427. data->length = reclen; /* not tlf, as one might think */
  428. data->operation.operation = 0x3F;
  429. data->extended_operation = 0x23;
  430. break;
  431. case DASD_ECKD_CCW_READ:
  432. case DASD_ECKD_CCW_READ_MT:
  433. case DASD_ECKD_CCW_READ_KD:
  434. case DASD_ECKD_CCW_READ_KD_MT:
  435. data->auxiliary.length_valid = 0x1;
  436. data->length = reclen;
  437. data->operation.operation = 0x06;
  438. break;
  439. case DASD_ECKD_CCW_READ_CKD:
  440. case DASD_ECKD_CCW_READ_CKD_MT:
  441. data->auxiliary.length_valid = 0x1;
  442. data->length = reclen;
  443. data->operation.operation = 0x16;
  444. break;
  445. case DASD_ECKD_CCW_READ_COUNT:
  446. data->operation.operation = 0x06;
  447. break;
  448. case DASD_ECKD_CCW_READ_TRACK:
  449. data->operation.orientation = 0x1;
  450. data->operation.operation = 0x0C;
  451. data->extended_parameter_length = 0;
  452. data->sector = 0xFF;
  453. break;
  454. case DASD_ECKD_CCW_READ_TRACK_DATA:
  455. data->auxiliary.length_valid = 0x1;
  456. data->length = tlf;
  457. data->operation.operation = 0x0C;
  458. break;
  459. case DASD_ECKD_CCW_ERASE:
  460. data->length = reclen;
  461. data->auxiliary.length_valid = 0x1;
  462. data->operation.operation = 0x0b;
  463. break;
  464. default:
  465. DBF_DEV_EVENT(DBF_ERR, device,
  466. "fill LRE unknown opcode 0x%x", cmd);
  467. BUG();
  468. }
  469. set_ch_t(&data->seek_addr,
  470. trk / private->rdc_data.trk_per_cyl,
  471. trk % private->rdc_data.trk_per_cyl);
  472. data->search_arg.cyl = data->seek_addr.cyl;
  473. data->search_arg.head = data->seek_addr.head;
  474. data->search_arg.record = rec_on_trk;
  475. }
  476. static int prefix_LRE(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata,
  477. unsigned int trk, unsigned int totrk, int cmd,
  478. struct dasd_device *basedev, struct dasd_device *startdev,
  479. unsigned int format, unsigned int rec_on_trk, int count,
  480. unsigned int blksize, unsigned int tlf)
  481. {
  482. struct dasd_eckd_private *basepriv, *startpriv;
  483. struct LRE_eckd_data *lredata;
  484. struct DE_eckd_data *dedata;
  485. int rc = 0;
  486. basepriv = basedev->private;
  487. startpriv = startdev->private;
  488. dedata = &pfxdata->define_extent;
  489. lredata = &pfxdata->locate_record;
  490. ccw->cmd_code = DASD_ECKD_CCW_PFX;
  491. ccw->flags = 0;
  492. if (cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK) {
  493. ccw->count = sizeof(*pfxdata) + 2;
  494. ccw->cda = (__u32) __pa(pfxdata);
  495. memset(pfxdata, 0, sizeof(*pfxdata) + 2);
  496. } else {
  497. ccw->count = sizeof(*pfxdata);
  498. ccw->cda = (__u32) __pa(pfxdata);
  499. memset(pfxdata, 0, sizeof(*pfxdata));
  500. }
  501. /* prefix data */
  502. if (format > 1) {
  503. DBF_DEV_EVENT(DBF_ERR, basedev,
  504. "PFX LRE unknown format 0x%x", format);
  505. BUG();
  506. return -EINVAL;
  507. }
  508. pfxdata->format = format;
  509. pfxdata->base_address = basepriv->ned->unit_addr;
  510. pfxdata->base_lss = basepriv->ned->ID;
  511. pfxdata->validity.define_extent = 1;
  512. /* private uid is kept up to date, conf_data may be outdated */
  513. if (startpriv->uid.type == UA_BASE_PAV_ALIAS)
  514. pfxdata->validity.verify_base = 1;
  515. if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) {
  516. pfxdata->validity.verify_base = 1;
  517. pfxdata->validity.hyper_pav = 1;
  518. }
  519. rc = define_extent(NULL, dedata, trk, totrk, cmd, basedev, blksize);
  520. /*
  521. * For some commands the System Time Stamp is set in the define extent
  522. * data when XRC is supported. The validity of the time stamp must be
  523. * reflected in the prefix data as well.
  524. */
  525. if (dedata->ga_extended & 0x08 && dedata->ga_extended & 0x02)
  526. pfxdata->validity.time_stamp = 1; /* 'Time Stamp Valid' */
  527. if (format == 1) {
  528. locate_record_ext(NULL, lredata, trk, rec_on_trk, count, cmd,
  529. basedev, blksize, tlf);
  530. }
  531. return rc;
  532. }
  533. static int prefix(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata,
  534. unsigned int trk, unsigned int totrk, int cmd,
  535. struct dasd_device *basedev, struct dasd_device *startdev)
  536. {
  537. return prefix_LRE(ccw, pfxdata, trk, totrk, cmd, basedev, startdev,
  538. 0, 0, 0, 0, 0);
  539. }
  540. static void
  541. locate_record(struct ccw1 *ccw, struct LO_eckd_data *data, unsigned int trk,
  542. unsigned int rec_on_trk, int no_rec, int cmd,
  543. struct dasd_device * device, int reclen)
  544. {
  545. struct dasd_eckd_private *private = device->private;
  546. int sector;
  547. int dn, d;
  548. DBF_DEV_EVENT(DBF_INFO, device,
  549. "Locate: trk %d, rec %d, no_rec %d, cmd %d, reclen %d",
  550. trk, rec_on_trk, no_rec, cmd, reclen);
  551. ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD;
  552. ccw->flags = 0;
  553. ccw->count = 16;
  554. ccw->cda = (__u32) __pa(data);
  555. memset(data, 0, sizeof(struct LO_eckd_data));
  556. sector = 0;
  557. if (rec_on_trk) {
  558. switch (private->rdc_data.dev_type) {
  559. case 0x3390:
  560. dn = ceil_quot(reclen + 6, 232);
  561. d = 9 + ceil_quot(reclen + 6 * (dn + 1), 34);
  562. sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8;
  563. break;
  564. case 0x3380:
  565. d = 7 + ceil_quot(reclen + 12, 32);
  566. sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7;
  567. break;
  568. }
  569. }
  570. data->sector = sector;
  571. data->count = no_rec;
  572. switch (cmd) {
  573. case DASD_ECKD_CCW_WRITE_HOME_ADDRESS:
  574. data->operation.orientation = 0x3;
  575. data->operation.operation = 0x03;
  576. break;
  577. case DASD_ECKD_CCW_READ_HOME_ADDRESS:
  578. data->operation.orientation = 0x3;
  579. data->operation.operation = 0x16;
  580. break;
  581. case DASD_ECKD_CCW_WRITE_RECORD_ZERO:
  582. data->operation.orientation = 0x1;
  583. data->operation.operation = 0x03;
  584. data->count++;
  585. break;
  586. case DASD_ECKD_CCW_READ_RECORD_ZERO:
  587. data->operation.orientation = 0x3;
  588. data->operation.operation = 0x16;
  589. data->count++;
  590. break;
  591. case DASD_ECKD_CCW_WRITE:
  592. case DASD_ECKD_CCW_WRITE_MT:
  593. case DASD_ECKD_CCW_WRITE_KD:
  594. case DASD_ECKD_CCW_WRITE_KD_MT:
  595. data->auxiliary.last_bytes_used = 0x1;
  596. data->length = reclen;
  597. data->operation.operation = 0x01;
  598. break;
  599. case DASD_ECKD_CCW_WRITE_CKD:
  600. case DASD_ECKD_CCW_WRITE_CKD_MT:
  601. data->auxiliary.last_bytes_used = 0x1;
  602. data->length = reclen;
  603. data->operation.operation = 0x03;
  604. break;
  605. case DASD_ECKD_CCW_READ:
  606. case DASD_ECKD_CCW_READ_MT:
  607. case DASD_ECKD_CCW_READ_KD:
  608. case DASD_ECKD_CCW_READ_KD_MT:
  609. data->auxiliary.last_bytes_used = 0x1;
  610. data->length = reclen;
  611. data->operation.operation = 0x06;
  612. break;
  613. case DASD_ECKD_CCW_READ_CKD:
  614. case DASD_ECKD_CCW_READ_CKD_MT:
  615. data->auxiliary.last_bytes_used = 0x1;
  616. data->length = reclen;
  617. data->operation.operation = 0x16;
  618. break;
  619. case DASD_ECKD_CCW_READ_COUNT:
  620. data->operation.operation = 0x06;
  621. break;
  622. case DASD_ECKD_CCW_ERASE:
  623. data->length = reclen;
  624. data->auxiliary.last_bytes_used = 0x1;
  625. data->operation.operation = 0x0b;
  626. break;
  627. default:
  628. DBF_DEV_EVENT(DBF_ERR, device, "unknown locate record "
  629. "opcode 0x%x", cmd);
  630. }
  631. set_ch_t(&data->seek_addr,
  632. trk / private->rdc_data.trk_per_cyl,
  633. trk % private->rdc_data.trk_per_cyl);
  634. data->search_arg.cyl = data->seek_addr.cyl;
  635. data->search_arg.head = data->seek_addr.head;
  636. data->search_arg.record = rec_on_trk;
  637. }
  638. /*
  639. * Returns 1 if the block is one of the special blocks that needs
  640. * to get read/written with the KD variant of the command.
  641. * That is DASD_ECKD_READ_KD_MT instead of DASD_ECKD_READ_MT and
  642. * DASD_ECKD_WRITE_KD_MT instead of DASD_ECKD_WRITE_MT.
  643. * Luckily the KD variants differ only by one bit (0x08) from the
  644. * normal variant. So don't wonder about code like:
  645. * if (dasd_eckd_cdl_special(blk_per_trk, recid))
  646. * ccw->cmd_code |= 0x8;
  647. */
  648. static inline int
  649. dasd_eckd_cdl_special(int blk_per_trk, int recid)
  650. {
  651. if (recid < 3)
  652. return 1;
  653. if (recid < blk_per_trk)
  654. return 0;
  655. if (recid < 2 * blk_per_trk)
  656. return 1;
  657. return 0;
  658. }
  659. /*
  660. * Returns the record size for the special blocks of the cdl format.
  661. * Only returns something useful if dasd_eckd_cdl_special is true
  662. * for the recid.
  663. */
  664. static inline int
  665. dasd_eckd_cdl_reclen(int recid)
  666. {
  667. if (recid < 3)
  668. return sizes_trk0[recid];
  669. return LABEL_SIZE;
  670. }
  671. /* create unique id from private structure. */
  672. static void create_uid(struct dasd_eckd_private *private)
  673. {
  674. int count;
  675. struct dasd_uid *uid;
  676. uid = &private->uid;
  677. memset(uid, 0, sizeof(struct dasd_uid));
  678. memcpy(uid->vendor, private->ned->HDA_manufacturer,
  679. sizeof(uid->vendor) - 1);
  680. EBCASC(uid->vendor, sizeof(uid->vendor) - 1);
  681. memcpy(uid->serial, private->ned->HDA_location,
  682. sizeof(uid->serial) - 1);
  683. EBCASC(uid->serial, sizeof(uid->serial) - 1);
  684. uid->ssid = private->gneq->subsystemID;
  685. uid->real_unit_addr = private->ned->unit_addr;
  686. if (private->sneq) {
  687. uid->type = private->sneq->sua_flags;
  688. if (uid->type == UA_BASE_PAV_ALIAS)
  689. uid->base_unit_addr = private->sneq->base_unit_addr;
  690. } else {
  691. uid->type = UA_BASE_DEVICE;
  692. }
  693. if (private->vdsneq) {
  694. for (count = 0; count < 16; count++) {
  695. sprintf(uid->vduit+2*count, "%02x",
  696. private->vdsneq->uit[count]);
  697. }
  698. }
  699. }
  700. /*
  701. * Generate device unique id that specifies the physical device.
  702. */
  703. static int dasd_eckd_generate_uid(struct dasd_device *device)
  704. {
  705. struct dasd_eckd_private *private = device->private;
  706. unsigned long flags;
  707. if (!private)
  708. return -ENODEV;
  709. if (!private->ned || !private->gneq)
  710. return -ENODEV;
  711. spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
  712. create_uid(private);
  713. spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
  714. return 0;
  715. }
  716. static int dasd_eckd_get_uid(struct dasd_device *device, struct dasd_uid *uid)
  717. {
  718. struct dasd_eckd_private *private = device->private;
  719. unsigned long flags;
  720. if (private) {
  721. spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
  722. *uid = private->uid;
  723. spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
  724. return 0;
  725. }
  726. return -EINVAL;
  727. }
  728. /*
  729. * compare device UID with data of a given dasd_eckd_private structure
  730. * return 0 for match
  731. */
  732. static int dasd_eckd_compare_path_uid(struct dasd_device *device,
  733. struct dasd_eckd_private *private)
  734. {
  735. struct dasd_uid device_uid;
  736. create_uid(private);
  737. dasd_eckd_get_uid(device, &device_uid);
  738. return memcmp(&device_uid, &private->uid, sizeof(struct dasd_uid));
  739. }
  740. static void dasd_eckd_fill_rcd_cqr(struct dasd_device *device,
  741. struct dasd_ccw_req *cqr,
  742. __u8 *rcd_buffer,
  743. __u8 lpm)
  744. {
  745. struct ccw1 *ccw;
  746. /*
  747. * buffer has to start with EBCDIC "V1.0" to show
  748. * support for virtual device SNEQ
  749. */
  750. rcd_buffer[0] = 0xE5;
  751. rcd_buffer[1] = 0xF1;
  752. rcd_buffer[2] = 0x4B;
  753. rcd_buffer[3] = 0xF0;
  754. ccw = cqr->cpaddr;
  755. ccw->cmd_code = DASD_ECKD_CCW_RCD;
  756. ccw->flags = 0;
  757. ccw->cda = (__u32)(addr_t)rcd_buffer;
  758. ccw->count = DASD_ECKD_RCD_DATA_SIZE;
  759. cqr->magic = DASD_ECKD_MAGIC;
  760. cqr->startdev = device;
  761. cqr->memdev = device;
  762. cqr->block = NULL;
  763. cqr->expires = 10*HZ;
  764. cqr->lpm = lpm;
  765. cqr->retries = 256;
  766. cqr->buildclk = get_tod_clock();
  767. cqr->status = DASD_CQR_FILLED;
  768. set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags);
  769. }
  770. /*
  771. * Wakeup helper for read_conf
  772. * if the cqr is not done and needs some error recovery
  773. * the buffer has to be re-initialized with the EBCDIC "V1.0"
  774. * to show support for virtual device SNEQ
  775. */
  776. static void read_conf_cb(struct dasd_ccw_req *cqr, void *data)
  777. {
  778. struct ccw1 *ccw;
  779. __u8 *rcd_buffer;
  780. if (cqr->status != DASD_CQR_DONE) {
  781. ccw = cqr->cpaddr;
  782. rcd_buffer = (__u8 *)((addr_t) ccw->cda);
  783. memset(rcd_buffer, 0, sizeof(*rcd_buffer));
  784. rcd_buffer[0] = 0xE5;
  785. rcd_buffer[1] = 0xF1;
  786. rcd_buffer[2] = 0x4B;
  787. rcd_buffer[3] = 0xF0;
  788. }
  789. dasd_wakeup_cb(cqr, data);
  790. }
  791. static int dasd_eckd_read_conf_immediately(struct dasd_device *device,
  792. struct dasd_ccw_req *cqr,
  793. __u8 *rcd_buffer,
  794. __u8 lpm)
  795. {
  796. struct ciw *ciw;
  797. int rc;
  798. /*
  799. * sanity check: scan for RCD command in extended SenseID data
  800. * some devices do not support RCD
  801. */
  802. ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD);
  803. if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD)
  804. return -EOPNOTSUPP;
  805. dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buffer, lpm);
  806. clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  807. set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags);
  808. cqr->retries = 5;
  809. cqr->callback = read_conf_cb;
  810. rc = dasd_sleep_on_immediatly(cqr);
  811. return rc;
  812. }
  813. static int dasd_eckd_read_conf_lpm(struct dasd_device *device,
  814. void **rcd_buffer,
  815. int *rcd_buffer_size, __u8 lpm)
  816. {
  817. struct ciw *ciw;
  818. char *rcd_buf = NULL;
  819. int ret;
  820. struct dasd_ccw_req *cqr;
  821. /*
  822. * sanity check: scan for RCD command in extended SenseID data
  823. * some devices do not support RCD
  824. */
  825. ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD);
  826. if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD) {
  827. ret = -EOPNOTSUPP;
  828. goto out_error;
  829. }
  830. rcd_buf = kzalloc(DASD_ECKD_RCD_DATA_SIZE, GFP_KERNEL | GFP_DMA);
  831. if (!rcd_buf) {
  832. ret = -ENOMEM;
  833. goto out_error;
  834. }
  835. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* RCD */,
  836. 0, /* use rcd_buf as data ara */
  837. device, NULL);
  838. if (IS_ERR(cqr)) {
  839. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  840. "Could not allocate RCD request");
  841. ret = -ENOMEM;
  842. goto out_error;
  843. }
  844. dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buf, lpm);
  845. cqr->callback = read_conf_cb;
  846. ret = dasd_sleep_on(cqr);
  847. /*
  848. * on success we update the user input parms
  849. */
  850. dasd_sfree_request(cqr, cqr->memdev);
  851. if (ret)
  852. goto out_error;
  853. *rcd_buffer_size = DASD_ECKD_RCD_DATA_SIZE;
  854. *rcd_buffer = rcd_buf;
  855. return 0;
  856. out_error:
  857. kfree(rcd_buf);
  858. *rcd_buffer = NULL;
  859. *rcd_buffer_size = 0;
  860. return ret;
  861. }
  862. static int dasd_eckd_identify_conf_parts(struct dasd_eckd_private *private)
  863. {
  864. struct dasd_sneq *sneq;
  865. int i, count;
  866. private->ned = NULL;
  867. private->sneq = NULL;
  868. private->vdsneq = NULL;
  869. private->gneq = NULL;
  870. count = private->conf_len / sizeof(struct dasd_sneq);
  871. sneq = (struct dasd_sneq *)private->conf_data;
  872. for (i = 0; i < count; ++i) {
  873. if (sneq->flags.identifier == 1 && sneq->format == 1)
  874. private->sneq = sneq;
  875. else if (sneq->flags.identifier == 1 && sneq->format == 4)
  876. private->vdsneq = (struct vd_sneq *)sneq;
  877. else if (sneq->flags.identifier == 2)
  878. private->gneq = (struct dasd_gneq *)sneq;
  879. else if (sneq->flags.identifier == 3 && sneq->res1 == 1)
  880. private->ned = (struct dasd_ned *)sneq;
  881. sneq++;
  882. }
  883. if (!private->ned || !private->gneq) {
  884. private->ned = NULL;
  885. private->sneq = NULL;
  886. private->vdsneq = NULL;
  887. private->gneq = NULL;
  888. return -EINVAL;
  889. }
  890. return 0;
  891. };
  892. static unsigned char dasd_eckd_path_access(void *conf_data, int conf_len)
  893. {
  894. struct dasd_gneq *gneq;
  895. int i, count, found;
  896. count = conf_len / sizeof(*gneq);
  897. gneq = (struct dasd_gneq *)conf_data;
  898. found = 0;
  899. for (i = 0; i < count; ++i) {
  900. if (gneq->flags.identifier == 2) {
  901. found = 1;
  902. break;
  903. }
  904. gneq++;
  905. }
  906. if (found)
  907. return ((char *)gneq)[18] & 0x07;
  908. else
  909. return 0;
  910. }
  911. static void dasd_eckd_clear_conf_data(struct dasd_device *device)
  912. {
  913. struct dasd_eckd_private *private = device->private;
  914. int i;
  915. private->conf_data = NULL;
  916. private->conf_len = 0;
  917. for (i = 0; i < 8; i++) {
  918. kfree(device->path[i].conf_data);
  919. device->path[i].conf_data = NULL;
  920. device->path[i].cssid = 0;
  921. device->path[i].ssid = 0;
  922. device->path[i].chpid = 0;
  923. }
  924. }
  925. static int dasd_eckd_read_conf(struct dasd_device *device)
  926. {
  927. void *conf_data;
  928. int conf_len, conf_data_saved;
  929. int rc, path_err, pos;
  930. __u8 lpm, opm;
  931. struct dasd_eckd_private *private, path_private;
  932. struct dasd_uid *uid;
  933. char print_path_uid[60], print_device_uid[60];
  934. struct channel_path_desc_fmt0 *chp_desc;
  935. struct subchannel_id sch_id;
  936. private = device->private;
  937. opm = ccw_device_get_path_mask(device->cdev);
  938. ccw_device_get_schid(device->cdev, &sch_id);
  939. conf_data_saved = 0;
  940. path_err = 0;
  941. /* get configuration data per operational path */
  942. for (lpm = 0x80; lpm; lpm>>= 1) {
  943. if (!(lpm & opm))
  944. continue;
  945. rc = dasd_eckd_read_conf_lpm(device, &conf_data,
  946. &conf_len, lpm);
  947. if (rc && rc != -EOPNOTSUPP) { /* -EOPNOTSUPP is ok */
  948. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  949. "Read configuration data returned "
  950. "error %d", rc);
  951. return rc;
  952. }
  953. if (conf_data == NULL) {
  954. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  955. "No configuration data "
  956. "retrieved");
  957. /* no further analysis possible */
  958. dasd_path_add_opm(device, opm);
  959. continue; /* no error */
  960. }
  961. /* save first valid configuration data */
  962. if (!conf_data_saved) {
  963. /* initially clear previously stored conf_data */
  964. dasd_eckd_clear_conf_data(device);
  965. private->conf_data = conf_data;
  966. private->conf_len = conf_len;
  967. if (dasd_eckd_identify_conf_parts(private)) {
  968. private->conf_data = NULL;
  969. private->conf_len = 0;
  970. kfree(conf_data);
  971. continue;
  972. }
  973. pos = pathmask_to_pos(lpm);
  974. /* store per path conf_data */
  975. device->path[pos].conf_data = conf_data;
  976. device->path[pos].cssid = sch_id.cssid;
  977. device->path[pos].ssid = sch_id.ssid;
  978. chp_desc = ccw_device_get_chp_desc(device->cdev, pos);
  979. if (chp_desc)
  980. device->path[pos].chpid = chp_desc->chpid;
  981. kfree(chp_desc);
  982. /*
  983. * build device UID that other path data
  984. * can be compared to it
  985. */
  986. dasd_eckd_generate_uid(device);
  987. conf_data_saved++;
  988. } else {
  989. path_private.conf_data = conf_data;
  990. path_private.conf_len = DASD_ECKD_RCD_DATA_SIZE;
  991. if (dasd_eckd_identify_conf_parts(
  992. &path_private)) {
  993. path_private.conf_data = NULL;
  994. path_private.conf_len = 0;
  995. kfree(conf_data);
  996. continue;
  997. }
  998. if (dasd_eckd_compare_path_uid(
  999. device, &path_private)) {
  1000. uid = &path_private.uid;
  1001. if (strlen(uid->vduit) > 0)
  1002. snprintf(print_path_uid,
  1003. sizeof(print_path_uid),
  1004. "%s.%s.%04x.%02x.%s",
  1005. uid->vendor, uid->serial,
  1006. uid->ssid, uid->real_unit_addr,
  1007. uid->vduit);
  1008. else
  1009. snprintf(print_path_uid,
  1010. sizeof(print_path_uid),
  1011. "%s.%s.%04x.%02x",
  1012. uid->vendor, uid->serial,
  1013. uid->ssid,
  1014. uid->real_unit_addr);
  1015. uid = &private->uid;
  1016. if (strlen(uid->vduit) > 0)
  1017. snprintf(print_device_uid,
  1018. sizeof(print_device_uid),
  1019. "%s.%s.%04x.%02x.%s",
  1020. uid->vendor, uid->serial,
  1021. uid->ssid, uid->real_unit_addr,
  1022. uid->vduit);
  1023. else
  1024. snprintf(print_device_uid,
  1025. sizeof(print_device_uid),
  1026. "%s.%s.%04x.%02x",
  1027. uid->vendor, uid->serial,
  1028. uid->ssid,
  1029. uid->real_unit_addr);
  1030. dev_err(&device->cdev->dev,
  1031. "Not all channel paths lead to "
  1032. "the same device, path %02X leads to "
  1033. "device %s instead of %s\n", lpm,
  1034. print_path_uid, print_device_uid);
  1035. path_err = -EINVAL;
  1036. dasd_path_add_cablepm(device, lpm);
  1037. continue;
  1038. }
  1039. pos = pathmask_to_pos(lpm);
  1040. /* store per path conf_data */
  1041. device->path[pos].conf_data = conf_data;
  1042. device->path[pos].cssid = sch_id.cssid;
  1043. device->path[pos].ssid = sch_id.ssid;
  1044. chp_desc = ccw_device_get_chp_desc(device->cdev, pos);
  1045. if (chp_desc)
  1046. device->path[pos].chpid = chp_desc->chpid;
  1047. kfree(chp_desc);
  1048. path_private.conf_data = NULL;
  1049. path_private.conf_len = 0;
  1050. }
  1051. switch (dasd_eckd_path_access(conf_data, conf_len)) {
  1052. case 0x02:
  1053. dasd_path_add_nppm(device, lpm);
  1054. break;
  1055. case 0x03:
  1056. dasd_path_add_ppm(device, lpm);
  1057. break;
  1058. }
  1059. if (!dasd_path_get_opm(device)) {
  1060. dasd_path_set_opm(device, lpm);
  1061. dasd_generic_path_operational(device);
  1062. } else {
  1063. dasd_path_add_opm(device, lpm);
  1064. }
  1065. }
  1066. return path_err;
  1067. }
  1068. static u32 get_fcx_max_data(struct dasd_device *device)
  1069. {
  1070. struct dasd_eckd_private *private = device->private;
  1071. int fcx_in_css, fcx_in_gneq, fcx_in_features;
  1072. unsigned int mdc;
  1073. int tpm;
  1074. if (dasd_nofcx)
  1075. return 0;
  1076. /* is transport mode supported? */
  1077. fcx_in_css = css_general_characteristics.fcx;
  1078. fcx_in_gneq = private->gneq->reserved2[7] & 0x04;
  1079. fcx_in_features = private->features.feature[40] & 0x80;
  1080. tpm = fcx_in_css && fcx_in_gneq && fcx_in_features;
  1081. if (!tpm)
  1082. return 0;
  1083. mdc = ccw_device_get_mdc(device->cdev, 0);
  1084. if (mdc == 0) {
  1085. dev_warn(&device->cdev->dev, "Detecting the maximum supported data size for zHPF requests failed\n");
  1086. return 0;
  1087. } else {
  1088. return (u32)mdc * FCX_MAX_DATA_FACTOR;
  1089. }
  1090. }
  1091. static int verify_fcx_max_data(struct dasd_device *device, __u8 lpm)
  1092. {
  1093. struct dasd_eckd_private *private = device->private;
  1094. unsigned int mdc;
  1095. u32 fcx_max_data;
  1096. if (private->fcx_max_data) {
  1097. mdc = ccw_device_get_mdc(device->cdev, lpm);
  1098. if (mdc == 0) {
  1099. dev_warn(&device->cdev->dev,
  1100. "Detecting the maximum data size for zHPF "
  1101. "requests failed (rc=%d) for a new path %x\n",
  1102. mdc, lpm);
  1103. return mdc;
  1104. }
  1105. fcx_max_data = (u32)mdc * FCX_MAX_DATA_FACTOR;
  1106. if (fcx_max_data < private->fcx_max_data) {
  1107. dev_warn(&device->cdev->dev,
  1108. "The maximum data size for zHPF requests %u "
  1109. "on a new path %x is below the active maximum "
  1110. "%u\n", fcx_max_data, lpm,
  1111. private->fcx_max_data);
  1112. return -EACCES;
  1113. }
  1114. }
  1115. return 0;
  1116. }
  1117. static int rebuild_device_uid(struct dasd_device *device,
  1118. struct path_verification_work_data *data)
  1119. {
  1120. struct dasd_eckd_private *private = device->private;
  1121. __u8 lpm, opm = dasd_path_get_opm(device);
  1122. int rc = -ENODEV;
  1123. for (lpm = 0x80; lpm; lpm >>= 1) {
  1124. if (!(lpm & opm))
  1125. continue;
  1126. memset(&data->rcd_buffer, 0, sizeof(data->rcd_buffer));
  1127. memset(&data->cqr, 0, sizeof(data->cqr));
  1128. data->cqr.cpaddr = &data->ccw;
  1129. rc = dasd_eckd_read_conf_immediately(device, &data->cqr,
  1130. data->rcd_buffer,
  1131. lpm);
  1132. if (rc) {
  1133. if (rc == -EOPNOTSUPP) /* -EOPNOTSUPP is ok */
  1134. continue;
  1135. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  1136. "Read configuration data "
  1137. "returned error %d", rc);
  1138. break;
  1139. }
  1140. memcpy(private->conf_data, data->rcd_buffer,
  1141. DASD_ECKD_RCD_DATA_SIZE);
  1142. if (dasd_eckd_identify_conf_parts(private)) {
  1143. rc = -ENODEV;
  1144. } else /* first valid path is enough */
  1145. break;
  1146. }
  1147. if (!rc)
  1148. rc = dasd_eckd_generate_uid(device);
  1149. return rc;
  1150. }
  1151. static void do_path_verification_work(struct work_struct *work)
  1152. {
  1153. struct path_verification_work_data *data;
  1154. struct dasd_device *device;
  1155. struct dasd_eckd_private path_private;
  1156. struct dasd_uid *uid;
  1157. __u8 path_rcd_buf[DASD_ECKD_RCD_DATA_SIZE];
  1158. __u8 lpm, opm, npm, ppm, epm, hpfpm, cablepm;
  1159. unsigned long flags;
  1160. char print_uid[60];
  1161. int rc;
  1162. data = container_of(work, struct path_verification_work_data, worker);
  1163. device = data->device;
  1164. /* delay path verification until device was resumed */
  1165. if (test_bit(DASD_FLAG_SUSPENDED, &device->flags)) {
  1166. schedule_work(work);
  1167. return;
  1168. }
  1169. /* check if path verification already running and delay if so */
  1170. if (test_and_set_bit(DASD_FLAG_PATH_VERIFY, &device->flags)) {
  1171. schedule_work(work);
  1172. return;
  1173. }
  1174. opm = 0;
  1175. npm = 0;
  1176. ppm = 0;
  1177. epm = 0;
  1178. hpfpm = 0;
  1179. cablepm = 0;
  1180. for (lpm = 0x80; lpm; lpm >>= 1) {
  1181. if (!(lpm & data->tbvpm))
  1182. continue;
  1183. memset(&data->rcd_buffer, 0, sizeof(data->rcd_buffer));
  1184. memset(&data->cqr, 0, sizeof(data->cqr));
  1185. data->cqr.cpaddr = &data->ccw;
  1186. rc = dasd_eckd_read_conf_immediately(device, &data->cqr,
  1187. data->rcd_buffer,
  1188. lpm);
  1189. if (!rc) {
  1190. switch (dasd_eckd_path_access(data->rcd_buffer,
  1191. DASD_ECKD_RCD_DATA_SIZE)
  1192. ) {
  1193. case 0x02:
  1194. npm |= lpm;
  1195. break;
  1196. case 0x03:
  1197. ppm |= lpm;
  1198. break;
  1199. }
  1200. opm |= lpm;
  1201. } else if (rc == -EOPNOTSUPP) {
  1202. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  1203. "path verification: No configuration "
  1204. "data retrieved");
  1205. opm |= lpm;
  1206. } else if (rc == -EAGAIN) {
  1207. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  1208. "path verification: device is stopped,"
  1209. " try again later");
  1210. epm |= lpm;
  1211. } else {
  1212. dev_warn(&device->cdev->dev,
  1213. "Reading device feature codes failed "
  1214. "(rc=%d) for new path %x\n", rc, lpm);
  1215. continue;
  1216. }
  1217. if (verify_fcx_max_data(device, lpm)) {
  1218. opm &= ~lpm;
  1219. npm &= ~lpm;
  1220. ppm &= ~lpm;
  1221. hpfpm |= lpm;
  1222. continue;
  1223. }
  1224. /*
  1225. * save conf_data for comparison after
  1226. * rebuild_device_uid may have changed
  1227. * the original data
  1228. */
  1229. memcpy(&path_rcd_buf, data->rcd_buffer,
  1230. DASD_ECKD_RCD_DATA_SIZE);
  1231. path_private.conf_data = (void *) &path_rcd_buf;
  1232. path_private.conf_len = DASD_ECKD_RCD_DATA_SIZE;
  1233. if (dasd_eckd_identify_conf_parts(&path_private)) {
  1234. path_private.conf_data = NULL;
  1235. path_private.conf_len = 0;
  1236. continue;
  1237. }
  1238. /*
  1239. * compare path UID with device UID only if at least
  1240. * one valid path is left
  1241. * in other case the device UID may have changed and
  1242. * the first working path UID will be used as device UID
  1243. */
  1244. if (dasd_path_get_opm(device) &&
  1245. dasd_eckd_compare_path_uid(device, &path_private)) {
  1246. /*
  1247. * the comparison was not successful
  1248. * rebuild the device UID with at least one
  1249. * known path in case a z/VM hyperswap command
  1250. * has changed the device
  1251. *
  1252. * after this compare again
  1253. *
  1254. * if either the rebuild or the recompare fails
  1255. * the path can not be used
  1256. */
  1257. if (rebuild_device_uid(device, data) ||
  1258. dasd_eckd_compare_path_uid(
  1259. device, &path_private)) {
  1260. uid = &path_private.uid;
  1261. if (strlen(uid->vduit) > 0)
  1262. snprintf(print_uid, sizeof(print_uid),
  1263. "%s.%s.%04x.%02x.%s",
  1264. uid->vendor, uid->serial,
  1265. uid->ssid, uid->real_unit_addr,
  1266. uid->vduit);
  1267. else
  1268. snprintf(print_uid, sizeof(print_uid),
  1269. "%s.%s.%04x.%02x",
  1270. uid->vendor, uid->serial,
  1271. uid->ssid,
  1272. uid->real_unit_addr);
  1273. dev_err(&device->cdev->dev,
  1274. "The newly added channel path %02X "
  1275. "will not be used because it leads "
  1276. "to a different device %s\n",
  1277. lpm, print_uid);
  1278. opm &= ~lpm;
  1279. npm &= ~lpm;
  1280. ppm &= ~lpm;
  1281. cablepm |= lpm;
  1282. continue;
  1283. }
  1284. }
  1285. /*
  1286. * There is a small chance that a path is lost again between
  1287. * above path verification and the following modification of
  1288. * the device opm mask. We could avoid that race here by using
  1289. * yet another path mask, but we rather deal with this unlikely
  1290. * situation in dasd_start_IO.
  1291. */
  1292. spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
  1293. if (!dasd_path_get_opm(device) && opm) {
  1294. dasd_path_set_opm(device, opm);
  1295. dasd_generic_path_operational(device);
  1296. } else {
  1297. dasd_path_add_opm(device, opm);
  1298. }
  1299. dasd_path_add_nppm(device, npm);
  1300. dasd_path_add_ppm(device, ppm);
  1301. dasd_path_add_tbvpm(device, epm);
  1302. dasd_path_add_cablepm(device, cablepm);
  1303. dasd_path_add_nohpfpm(device, hpfpm);
  1304. spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
  1305. }
  1306. clear_bit(DASD_FLAG_PATH_VERIFY, &device->flags);
  1307. dasd_put_device(device);
  1308. if (data->isglobal)
  1309. mutex_unlock(&dasd_path_verification_mutex);
  1310. else
  1311. kfree(data);
  1312. }
  1313. static int dasd_eckd_verify_path(struct dasd_device *device, __u8 lpm)
  1314. {
  1315. struct path_verification_work_data *data;
  1316. data = kmalloc(sizeof(*data), GFP_ATOMIC | GFP_DMA);
  1317. if (!data) {
  1318. if (mutex_trylock(&dasd_path_verification_mutex)) {
  1319. data = path_verification_worker;
  1320. data->isglobal = 1;
  1321. } else
  1322. return -ENOMEM;
  1323. } else {
  1324. memset(data, 0, sizeof(*data));
  1325. data->isglobal = 0;
  1326. }
  1327. INIT_WORK(&data->worker, do_path_verification_work);
  1328. dasd_get_device(device);
  1329. data->device = device;
  1330. data->tbvpm = lpm;
  1331. schedule_work(&data->worker);
  1332. return 0;
  1333. }
  1334. static void dasd_eckd_reset_path(struct dasd_device *device, __u8 pm)
  1335. {
  1336. struct dasd_eckd_private *private = device->private;
  1337. unsigned long flags;
  1338. if (!private->fcx_max_data)
  1339. private->fcx_max_data = get_fcx_max_data(device);
  1340. spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
  1341. dasd_path_set_tbvpm(device, pm ? : dasd_path_get_notoperpm(device));
  1342. dasd_schedule_device_bh(device);
  1343. spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
  1344. }
  1345. static int dasd_eckd_read_features(struct dasd_device *device)
  1346. {
  1347. struct dasd_eckd_private *private = device->private;
  1348. struct dasd_psf_prssd_data *prssdp;
  1349. struct dasd_rssd_features *features;
  1350. struct dasd_ccw_req *cqr;
  1351. struct ccw1 *ccw;
  1352. int rc;
  1353. memset(&private->features, 0, sizeof(struct dasd_rssd_features));
  1354. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
  1355. (sizeof(struct dasd_psf_prssd_data) +
  1356. sizeof(struct dasd_rssd_features)),
  1357. device, NULL);
  1358. if (IS_ERR(cqr)) {
  1359. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", "Could not "
  1360. "allocate initialization request");
  1361. return PTR_ERR(cqr);
  1362. }
  1363. cqr->startdev = device;
  1364. cqr->memdev = device;
  1365. cqr->block = NULL;
  1366. cqr->retries = 256;
  1367. cqr->expires = 10 * HZ;
  1368. /* Prepare for Read Subsystem Data */
  1369. prssdp = (struct dasd_psf_prssd_data *) cqr->data;
  1370. memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
  1371. prssdp->order = PSF_ORDER_PRSSD;
  1372. prssdp->suborder = 0x41; /* Read Feature Codes */
  1373. /* all other bytes of prssdp must be zero */
  1374. ccw = cqr->cpaddr;
  1375. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  1376. ccw->count = sizeof(struct dasd_psf_prssd_data);
  1377. ccw->flags |= CCW_FLAG_CC;
  1378. ccw->cda = (__u32)(addr_t) prssdp;
  1379. /* Read Subsystem Data - feature codes */
  1380. features = (struct dasd_rssd_features *) (prssdp + 1);
  1381. memset(features, 0, sizeof(struct dasd_rssd_features));
  1382. ccw++;
  1383. ccw->cmd_code = DASD_ECKD_CCW_RSSD;
  1384. ccw->count = sizeof(struct dasd_rssd_features);
  1385. ccw->cda = (__u32)(addr_t) features;
  1386. cqr->buildclk = get_tod_clock();
  1387. cqr->status = DASD_CQR_FILLED;
  1388. rc = dasd_sleep_on(cqr);
  1389. if (rc == 0) {
  1390. prssdp = (struct dasd_psf_prssd_data *) cqr->data;
  1391. features = (struct dasd_rssd_features *) (prssdp + 1);
  1392. memcpy(&private->features, features,
  1393. sizeof(struct dasd_rssd_features));
  1394. } else
  1395. dev_warn(&device->cdev->dev, "Reading device feature codes"
  1396. " failed with rc=%d\n", rc);
  1397. dasd_sfree_request(cqr, cqr->memdev);
  1398. return rc;
  1399. }
  1400. /* Read Volume Information - Volume Storage Query */
  1401. static int dasd_eckd_read_vol_info(struct dasd_device *device)
  1402. {
  1403. struct dasd_eckd_private *private = device->private;
  1404. struct dasd_psf_prssd_data *prssdp;
  1405. struct dasd_rssd_vsq *vsq;
  1406. struct dasd_ccw_req *cqr;
  1407. struct ccw1 *ccw;
  1408. int useglobal;
  1409. int rc;
  1410. /* This command cannot be executed on an alias device */
  1411. if (private->uid.type == UA_BASE_PAV_ALIAS ||
  1412. private->uid.type == UA_HYPER_PAV_ALIAS)
  1413. return 0;
  1414. useglobal = 0;
  1415. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 /* PSF + RSSD */,
  1416. sizeof(*prssdp) + sizeof(*vsq), device, NULL);
  1417. if (IS_ERR(cqr)) {
  1418. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  1419. "Could not allocate initialization request");
  1420. mutex_lock(&dasd_vol_info_mutex);
  1421. useglobal = 1;
  1422. cqr = &dasd_vol_info_req->cqr;
  1423. memset(cqr, 0, sizeof(*cqr));
  1424. memset(dasd_vol_info_req, 0, sizeof(*dasd_vol_info_req));
  1425. cqr->cpaddr = &dasd_vol_info_req->ccw;
  1426. cqr->data = &dasd_vol_info_req->data;
  1427. cqr->magic = DASD_ECKD_MAGIC;
  1428. }
  1429. /* Prepare for Read Subsystem Data */
  1430. prssdp = cqr->data;
  1431. prssdp->order = PSF_ORDER_PRSSD;
  1432. prssdp->suborder = PSF_SUBORDER_VSQ; /* Volume Storage Query */
  1433. prssdp->lss = private->ned->ID;
  1434. prssdp->volume = private->ned->unit_addr;
  1435. ccw = cqr->cpaddr;
  1436. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  1437. ccw->count = sizeof(*prssdp);
  1438. ccw->flags |= CCW_FLAG_CC;
  1439. ccw->cda = (__u32)(addr_t)prssdp;
  1440. /* Read Subsystem Data - Volume Storage Query */
  1441. vsq = (struct dasd_rssd_vsq *)(prssdp + 1);
  1442. memset(vsq, 0, sizeof(*vsq));
  1443. ccw++;
  1444. ccw->cmd_code = DASD_ECKD_CCW_RSSD;
  1445. ccw->count = sizeof(*vsq);
  1446. ccw->flags |= CCW_FLAG_SLI;
  1447. ccw->cda = (__u32)(addr_t)vsq;
  1448. cqr->buildclk = get_tod_clock();
  1449. cqr->status = DASD_CQR_FILLED;
  1450. cqr->startdev = device;
  1451. cqr->memdev = device;
  1452. cqr->block = NULL;
  1453. cqr->retries = 256;
  1454. cqr->expires = device->default_expires * HZ;
  1455. /* The command might not be supported. Suppress the error output */
  1456. __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags);
  1457. rc = dasd_sleep_on_interruptible(cqr);
  1458. if (rc == 0) {
  1459. memcpy(&private->vsq, vsq, sizeof(*vsq));
  1460. } else {
  1461. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  1462. "Reading the volume storage information failed with rc=%d", rc);
  1463. }
  1464. if (useglobal)
  1465. mutex_unlock(&dasd_vol_info_mutex);
  1466. else
  1467. dasd_sfree_request(cqr, cqr->memdev);
  1468. return rc;
  1469. }
  1470. static int dasd_eckd_is_ese(struct dasd_device *device)
  1471. {
  1472. struct dasd_eckd_private *private = device->private;
  1473. return private->vsq.vol_info.ese;
  1474. }
  1475. static int dasd_eckd_ext_pool_id(struct dasd_device *device)
  1476. {
  1477. struct dasd_eckd_private *private = device->private;
  1478. return private->vsq.extent_pool_id;
  1479. }
  1480. /*
  1481. * This value represents the total amount of available space. As more space is
  1482. * allocated by ESE volumes, this value will decrease.
  1483. * The data for this value is therefore updated on any call.
  1484. */
  1485. static int dasd_eckd_space_configured(struct dasd_device *device)
  1486. {
  1487. struct dasd_eckd_private *private = device->private;
  1488. int rc;
  1489. rc = dasd_eckd_read_vol_info(device);
  1490. return rc ? : private->vsq.space_configured;
  1491. }
  1492. /*
  1493. * The value of space allocated by an ESE volume may have changed and is
  1494. * therefore updated on any call.
  1495. */
  1496. static int dasd_eckd_space_allocated(struct dasd_device *device)
  1497. {
  1498. struct dasd_eckd_private *private = device->private;
  1499. int rc;
  1500. rc = dasd_eckd_read_vol_info(device);
  1501. return rc ? : private->vsq.space_allocated;
  1502. }
  1503. static int dasd_eckd_logical_capacity(struct dasd_device *device)
  1504. {
  1505. struct dasd_eckd_private *private = device->private;
  1506. return private->vsq.logical_capacity;
  1507. }
  1508. static void dasd_eckd_ext_pool_exhaust_work(struct work_struct *work)
  1509. {
  1510. struct ext_pool_exhaust_work_data *data;
  1511. struct dasd_device *device;
  1512. struct dasd_device *base;
  1513. data = container_of(work, struct ext_pool_exhaust_work_data, worker);
  1514. device = data->device;
  1515. base = data->base;
  1516. if (!base)
  1517. base = device;
  1518. if (dasd_eckd_space_configured(base) != 0) {
  1519. dasd_generic_space_avail(device);
  1520. } else {
  1521. dev_warn(&device->cdev->dev, "No space left in the extent pool\n");
  1522. DBF_DEV_EVENT(DBF_WARNING, device, "%s", "out of space");
  1523. }
  1524. dasd_put_device(device);
  1525. kfree(data);
  1526. }
  1527. static int dasd_eckd_ext_pool_exhaust(struct dasd_device *device,
  1528. struct dasd_ccw_req *cqr)
  1529. {
  1530. struct ext_pool_exhaust_work_data *data;
  1531. data = kzalloc(sizeof(*data), GFP_ATOMIC);
  1532. if (!data)
  1533. return -ENOMEM;
  1534. INIT_WORK(&data->worker, dasd_eckd_ext_pool_exhaust_work);
  1535. dasd_get_device(device);
  1536. data->device = device;
  1537. if (cqr->block)
  1538. data->base = cqr->block->base;
  1539. else if (cqr->basedev)
  1540. data->base = cqr->basedev;
  1541. else
  1542. data->base = NULL;
  1543. schedule_work(&data->worker);
  1544. return 0;
  1545. }
  1546. static void dasd_eckd_cpy_ext_pool_data(struct dasd_device *device,
  1547. struct dasd_rssd_lcq *lcq)
  1548. {
  1549. struct dasd_eckd_private *private = device->private;
  1550. int pool_id = dasd_eckd_ext_pool_id(device);
  1551. struct dasd_ext_pool_sum eps;
  1552. int i;
  1553. for (i = 0; i < lcq->pool_count; i++) {
  1554. eps = lcq->ext_pool_sum[i];
  1555. if (eps.pool_id == pool_id) {
  1556. memcpy(&private->eps, &eps,
  1557. sizeof(struct dasd_ext_pool_sum));
  1558. }
  1559. }
  1560. }
  1561. /* Read Extent Pool Information - Logical Configuration Query */
  1562. static int dasd_eckd_read_ext_pool_info(struct dasd_device *device)
  1563. {
  1564. struct dasd_eckd_private *private = device->private;
  1565. struct dasd_psf_prssd_data *prssdp;
  1566. struct dasd_rssd_lcq *lcq;
  1567. struct dasd_ccw_req *cqr;
  1568. struct ccw1 *ccw;
  1569. int rc;
  1570. /* This command cannot be executed on an alias device */
  1571. if (private->uid.type == UA_BASE_PAV_ALIAS ||
  1572. private->uid.type == UA_HYPER_PAV_ALIAS)
  1573. return 0;
  1574. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 /* PSF + RSSD */,
  1575. sizeof(*prssdp) + sizeof(*lcq), device, NULL);
  1576. if (IS_ERR(cqr)) {
  1577. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  1578. "Could not allocate initialization request");
  1579. return PTR_ERR(cqr);
  1580. }
  1581. /* Prepare for Read Subsystem Data */
  1582. prssdp = cqr->data;
  1583. memset(prssdp, 0, sizeof(*prssdp));
  1584. prssdp->order = PSF_ORDER_PRSSD;
  1585. prssdp->suborder = PSF_SUBORDER_LCQ; /* Logical Configuration Query */
  1586. ccw = cqr->cpaddr;
  1587. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  1588. ccw->count = sizeof(*prssdp);
  1589. ccw->flags |= CCW_FLAG_CC;
  1590. ccw->cda = (__u32)(addr_t)prssdp;
  1591. lcq = (struct dasd_rssd_lcq *)(prssdp + 1);
  1592. memset(lcq, 0, sizeof(*lcq));
  1593. ccw++;
  1594. ccw->cmd_code = DASD_ECKD_CCW_RSSD;
  1595. ccw->count = sizeof(*lcq);
  1596. ccw->flags |= CCW_FLAG_SLI;
  1597. ccw->cda = (__u32)(addr_t)lcq;
  1598. cqr->buildclk = get_tod_clock();
  1599. cqr->status = DASD_CQR_FILLED;
  1600. cqr->startdev = device;
  1601. cqr->memdev = device;
  1602. cqr->block = NULL;
  1603. cqr->retries = 256;
  1604. cqr->expires = device->default_expires * HZ;
  1605. /* The command might not be supported. Suppress the error output */
  1606. __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags);
  1607. rc = dasd_sleep_on_interruptible(cqr);
  1608. if (rc == 0) {
  1609. dasd_eckd_cpy_ext_pool_data(device, lcq);
  1610. } else {
  1611. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  1612. "Reading the logical configuration failed with rc=%d", rc);
  1613. }
  1614. dasd_sfree_request(cqr, cqr->memdev);
  1615. return rc;
  1616. }
  1617. /*
  1618. * Depending on the device type, the extent size is specified either as
  1619. * cylinders per extent (CKD) or size per extent (FBA)
  1620. * A 1GB size corresponds to 1113cyl, and 16MB to 21cyl.
  1621. */
  1622. static int dasd_eckd_ext_size(struct dasd_device *device)
  1623. {
  1624. struct dasd_eckd_private *private = device->private;
  1625. struct dasd_ext_pool_sum eps = private->eps;
  1626. if (!eps.flags.extent_size_valid)
  1627. return 0;
  1628. if (eps.extent_size.size_1G)
  1629. return 1113;
  1630. if (eps.extent_size.size_16M)
  1631. return 21;
  1632. return 0;
  1633. }
  1634. static int dasd_eckd_ext_pool_warn_thrshld(struct dasd_device *device)
  1635. {
  1636. struct dasd_eckd_private *private = device->private;
  1637. return private->eps.warn_thrshld;
  1638. }
  1639. static int dasd_eckd_ext_pool_cap_at_warnlevel(struct dasd_device *device)
  1640. {
  1641. struct dasd_eckd_private *private = device->private;
  1642. return private->eps.flags.capacity_at_warnlevel;
  1643. }
  1644. /*
  1645. * Extent Pool out of space
  1646. */
  1647. static int dasd_eckd_ext_pool_oos(struct dasd_device *device)
  1648. {
  1649. struct dasd_eckd_private *private = device->private;
  1650. return private->eps.flags.pool_oos;
  1651. }
  1652. /*
  1653. * Build CP for Perform Subsystem Function - SSC.
  1654. */
  1655. static struct dasd_ccw_req *dasd_eckd_build_psf_ssc(struct dasd_device *device,
  1656. int enable_pav)
  1657. {
  1658. struct dasd_ccw_req *cqr;
  1659. struct dasd_psf_ssc_data *psf_ssc_data;
  1660. struct ccw1 *ccw;
  1661. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ ,
  1662. sizeof(struct dasd_psf_ssc_data),
  1663. device, NULL);
  1664. if (IS_ERR(cqr)) {
  1665. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  1666. "Could not allocate PSF-SSC request");
  1667. return cqr;
  1668. }
  1669. psf_ssc_data = (struct dasd_psf_ssc_data *)cqr->data;
  1670. psf_ssc_data->order = PSF_ORDER_SSC;
  1671. psf_ssc_data->suborder = 0xc0;
  1672. if (enable_pav) {
  1673. psf_ssc_data->suborder |= 0x08;
  1674. psf_ssc_data->reserved[0] = 0x88;
  1675. }
  1676. ccw = cqr->cpaddr;
  1677. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  1678. ccw->cda = (__u32)(addr_t)psf_ssc_data;
  1679. ccw->count = 66;
  1680. cqr->startdev = device;
  1681. cqr->memdev = device;
  1682. cqr->block = NULL;
  1683. cqr->retries = 256;
  1684. cqr->expires = 10*HZ;
  1685. cqr->buildclk = get_tod_clock();
  1686. cqr->status = DASD_CQR_FILLED;
  1687. return cqr;
  1688. }
  1689. /*
  1690. * Perform Subsystem Function.
  1691. * It is necessary to trigger CIO for channel revalidation since this
  1692. * call might change behaviour of DASD devices.
  1693. */
  1694. static int
  1695. dasd_eckd_psf_ssc(struct dasd_device *device, int enable_pav,
  1696. unsigned long flags)
  1697. {
  1698. struct dasd_ccw_req *cqr;
  1699. int rc;
  1700. cqr = dasd_eckd_build_psf_ssc(device, enable_pav);
  1701. if (IS_ERR(cqr))
  1702. return PTR_ERR(cqr);
  1703. /*
  1704. * set flags e.g. turn on failfast, to prevent blocking
  1705. * the calling function should handle failed requests
  1706. */
  1707. cqr->flags |= flags;
  1708. rc = dasd_sleep_on(cqr);
  1709. if (!rc)
  1710. /* trigger CIO to reprobe devices */
  1711. css_schedule_reprobe();
  1712. else if (cqr->intrc == -EAGAIN)
  1713. rc = -EAGAIN;
  1714. dasd_sfree_request(cqr, cqr->memdev);
  1715. return rc;
  1716. }
  1717. /*
  1718. * Valide storage server of current device.
  1719. */
  1720. static int dasd_eckd_validate_server(struct dasd_device *device,
  1721. unsigned long flags)
  1722. {
  1723. struct dasd_eckd_private *private = device->private;
  1724. int enable_pav, rc;
  1725. if (private->uid.type == UA_BASE_PAV_ALIAS ||
  1726. private->uid.type == UA_HYPER_PAV_ALIAS)
  1727. return 0;
  1728. if (dasd_nopav || MACHINE_IS_VM)
  1729. enable_pav = 0;
  1730. else
  1731. enable_pav = 1;
  1732. rc = dasd_eckd_psf_ssc(device, enable_pav, flags);
  1733. /* may be requested feature is not available on server,
  1734. * therefore just report error and go ahead */
  1735. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "PSF-SSC for SSID %04x "
  1736. "returned rc=%d", private->uid.ssid, rc);
  1737. return rc;
  1738. }
  1739. /*
  1740. * worker to do a validate server in case of a lost pathgroup
  1741. */
  1742. static void dasd_eckd_do_validate_server(struct work_struct *work)
  1743. {
  1744. struct dasd_device *device = container_of(work, struct dasd_device,
  1745. kick_validate);
  1746. unsigned long flags = 0;
  1747. set_bit(DASD_CQR_FLAGS_FAILFAST, &flags);
  1748. if (dasd_eckd_validate_server(device, flags)
  1749. == -EAGAIN) {
  1750. /* schedule worker again if failed */
  1751. schedule_work(&device->kick_validate);
  1752. return;
  1753. }
  1754. dasd_put_device(device);
  1755. }
  1756. static void dasd_eckd_kick_validate_server(struct dasd_device *device)
  1757. {
  1758. dasd_get_device(device);
  1759. /* exit if device not online or in offline processing */
  1760. if (test_bit(DASD_FLAG_OFFLINE, &device->flags) ||
  1761. device->state < DASD_STATE_ONLINE) {
  1762. dasd_put_device(device);
  1763. return;
  1764. }
  1765. /* queue call to do_validate_server to the kernel event daemon. */
  1766. if (!schedule_work(&device->kick_validate))
  1767. dasd_put_device(device);
  1768. }
  1769. /*
  1770. * Check device characteristics.
  1771. * If the device is accessible using ECKD discipline, the device is enabled.
  1772. */
  1773. static int
  1774. dasd_eckd_check_characteristics(struct dasd_device *device)
  1775. {
  1776. struct dasd_eckd_private *private = device->private;
  1777. struct dasd_block *block;
  1778. struct dasd_uid temp_uid;
  1779. int rc, i;
  1780. int readonly;
  1781. unsigned long value;
  1782. /* setup work queue for validate server*/
  1783. INIT_WORK(&device->kick_validate, dasd_eckd_do_validate_server);
  1784. /* setup work queue for summary unit check */
  1785. INIT_WORK(&device->suc_work, dasd_alias_handle_summary_unit_check);
  1786. if (!ccw_device_is_pathgroup(device->cdev)) {
  1787. dev_warn(&device->cdev->dev,
  1788. "A channel path group could not be established\n");
  1789. return -EIO;
  1790. }
  1791. if (!ccw_device_is_multipath(device->cdev)) {
  1792. dev_info(&device->cdev->dev,
  1793. "The DASD is not operating in multipath mode\n");
  1794. }
  1795. if (!private) {
  1796. private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA);
  1797. if (!private) {
  1798. dev_warn(&device->cdev->dev,
  1799. "Allocating memory for private DASD data "
  1800. "failed\n");
  1801. return -ENOMEM;
  1802. }
  1803. device->private = private;
  1804. } else {
  1805. memset(private, 0, sizeof(*private));
  1806. }
  1807. /* Invalidate status of initial analysis. */
  1808. private->init_cqr_status = -1;
  1809. /* Set default cache operations. */
  1810. private->attrib.operation = DASD_NORMAL_CACHE;
  1811. private->attrib.nr_cyl = 0;
  1812. /* Read Configuration Data */
  1813. rc = dasd_eckd_read_conf(device);
  1814. if (rc)
  1815. goto out_err1;
  1816. /* set some default values */
  1817. device->default_expires = DASD_EXPIRES;
  1818. device->default_retries = DASD_RETRIES;
  1819. device->path_thrhld = DASD_ECKD_PATH_THRHLD;
  1820. device->path_interval = DASD_ECKD_PATH_INTERVAL;
  1821. if (private->gneq) {
  1822. value = 1;
  1823. for (i = 0; i < private->gneq->timeout.value; i++)
  1824. value = 10 * value;
  1825. value = value * private->gneq->timeout.number;
  1826. /* do not accept useless values */
  1827. if (value != 0 && value <= DASD_EXPIRES_MAX)
  1828. device->default_expires = value;
  1829. }
  1830. dasd_eckd_get_uid(device, &temp_uid);
  1831. if (temp_uid.type == UA_BASE_DEVICE) {
  1832. block = dasd_alloc_block();
  1833. if (IS_ERR(block)) {
  1834. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  1835. "could not allocate dasd "
  1836. "block structure");
  1837. rc = PTR_ERR(block);
  1838. goto out_err1;
  1839. }
  1840. device->block = block;
  1841. block->base = device;
  1842. }
  1843. /* register lcu with alias handling, enable PAV */
  1844. rc = dasd_alias_make_device_known_to_lcu(device);
  1845. if (rc)
  1846. goto out_err2;
  1847. dasd_eckd_validate_server(device, 0);
  1848. /* device may report different configuration data after LCU setup */
  1849. rc = dasd_eckd_read_conf(device);
  1850. if (rc)
  1851. goto out_err3;
  1852. /* Read Feature Codes */
  1853. dasd_eckd_read_features(device);
  1854. /* Read Volume Information */
  1855. dasd_eckd_read_vol_info(device);
  1856. /* Read Extent Pool Information */
  1857. dasd_eckd_read_ext_pool_info(device);
  1858. /* Read Device Characteristics */
  1859. rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
  1860. &private->rdc_data, 64);
  1861. if (rc) {
  1862. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  1863. "Read device characteristic failed, rc=%d", rc);
  1864. goto out_err3;
  1865. }
  1866. if ((device->features & DASD_FEATURE_USERAW) &&
  1867. !(private->rdc_data.facilities.RT_in_LR)) {
  1868. dev_err(&device->cdev->dev, "The storage server does not "
  1869. "support raw-track access\n");
  1870. rc = -EINVAL;
  1871. goto out_err3;
  1872. }
  1873. /* find the valid cylinder size */
  1874. if (private->rdc_data.no_cyl == LV_COMPAT_CYL &&
  1875. private->rdc_data.long_no_cyl)
  1876. private->real_cyl = private->rdc_data.long_no_cyl;
  1877. else
  1878. private->real_cyl = private->rdc_data.no_cyl;
  1879. private->fcx_max_data = get_fcx_max_data(device);
  1880. readonly = dasd_device_is_ro(device);
  1881. if (readonly)
  1882. set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
  1883. dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) "
  1884. "with %d cylinders, %d heads, %d sectors%s\n",
  1885. private->rdc_data.dev_type,
  1886. private->rdc_data.dev_model,
  1887. private->rdc_data.cu_type,
  1888. private->rdc_data.cu_model.model,
  1889. private->real_cyl,
  1890. private->rdc_data.trk_per_cyl,
  1891. private->rdc_data.sec_per_trk,
  1892. readonly ? ", read-only device" : "");
  1893. return 0;
  1894. out_err3:
  1895. dasd_alias_disconnect_device_from_lcu(device);
  1896. out_err2:
  1897. dasd_free_block(device->block);
  1898. device->block = NULL;
  1899. out_err1:
  1900. dasd_eckd_clear_conf_data(device);
  1901. kfree(device->private);
  1902. device->private = NULL;
  1903. return rc;
  1904. }
  1905. static void dasd_eckd_uncheck_device(struct dasd_device *device)
  1906. {
  1907. struct dasd_eckd_private *private = device->private;
  1908. if (!private)
  1909. return;
  1910. dasd_alias_disconnect_device_from_lcu(device);
  1911. private->ned = NULL;
  1912. private->sneq = NULL;
  1913. private->vdsneq = NULL;
  1914. private->gneq = NULL;
  1915. dasd_eckd_clear_conf_data(device);
  1916. }
  1917. static struct dasd_ccw_req *
  1918. dasd_eckd_analysis_ccw(struct dasd_device *device)
  1919. {
  1920. struct dasd_eckd_private *private = device->private;
  1921. struct eckd_count *count_data;
  1922. struct LO_eckd_data *LO_data;
  1923. struct dasd_ccw_req *cqr;
  1924. struct ccw1 *ccw;
  1925. int cplength, datasize;
  1926. int i;
  1927. cplength = 8;
  1928. datasize = sizeof(struct DE_eckd_data) + 2*sizeof(struct LO_eckd_data);
  1929. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device,
  1930. NULL);
  1931. if (IS_ERR(cqr))
  1932. return cqr;
  1933. ccw = cqr->cpaddr;
  1934. /* Define extent for the first 2 tracks. */
  1935. define_extent(ccw++, cqr->data, 0, 1,
  1936. DASD_ECKD_CCW_READ_COUNT, device, 0);
  1937. LO_data = cqr->data + sizeof(struct DE_eckd_data);
  1938. /* Locate record for the first 4 records on track 0. */
  1939. ccw[-1].flags |= CCW_FLAG_CC;
  1940. locate_record(ccw++, LO_data++, 0, 0, 4,
  1941. DASD_ECKD_CCW_READ_COUNT, device, 0);
  1942. count_data = private->count_area;
  1943. for (i = 0; i < 4; i++) {
  1944. ccw[-1].flags |= CCW_FLAG_CC;
  1945. ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT;
  1946. ccw->flags = 0;
  1947. ccw->count = 8;
  1948. ccw->cda = (__u32)(addr_t) count_data;
  1949. ccw++;
  1950. count_data++;
  1951. }
  1952. /* Locate record for the first record on track 1. */
  1953. ccw[-1].flags |= CCW_FLAG_CC;
  1954. locate_record(ccw++, LO_data++, 1, 0, 1,
  1955. DASD_ECKD_CCW_READ_COUNT, device, 0);
  1956. /* Read count ccw. */
  1957. ccw[-1].flags |= CCW_FLAG_CC;
  1958. ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT;
  1959. ccw->flags = 0;
  1960. ccw->count = 8;
  1961. ccw->cda = (__u32)(addr_t) count_data;
  1962. cqr->block = NULL;
  1963. cqr->startdev = device;
  1964. cqr->memdev = device;
  1965. cqr->retries = 255;
  1966. cqr->buildclk = get_tod_clock();
  1967. cqr->status = DASD_CQR_FILLED;
  1968. /* Set flags to suppress output for expected errors */
  1969. set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
  1970. return cqr;
  1971. }
  1972. /* differentiate between 'no record found' and any other error */
  1973. static int dasd_eckd_analysis_evaluation(struct dasd_ccw_req *init_cqr)
  1974. {
  1975. char *sense;
  1976. if (init_cqr->status == DASD_CQR_DONE)
  1977. return INIT_CQR_OK;
  1978. else if (init_cqr->status == DASD_CQR_NEED_ERP ||
  1979. init_cqr->status == DASD_CQR_FAILED) {
  1980. sense = dasd_get_sense(&init_cqr->irb);
  1981. if (sense && (sense[1] & SNS1_NO_REC_FOUND))
  1982. return INIT_CQR_UNFORMATTED;
  1983. else
  1984. return INIT_CQR_ERROR;
  1985. } else
  1986. return INIT_CQR_ERROR;
  1987. }
  1988. /*
  1989. * This is the callback function for the init_analysis cqr. It saves
  1990. * the status of the initial analysis ccw before it frees it and kicks
  1991. * the device to continue the startup sequence. This will call
  1992. * dasd_eckd_do_analysis again (if the devices has not been marked
  1993. * for deletion in the meantime).
  1994. */
  1995. static void dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr,
  1996. void *data)
  1997. {
  1998. struct dasd_device *device = init_cqr->startdev;
  1999. struct dasd_eckd_private *private = device->private;
  2000. private->init_cqr_status = dasd_eckd_analysis_evaluation(init_cqr);
  2001. dasd_sfree_request(init_cqr, device);
  2002. dasd_kick_device(device);
  2003. }
  2004. static int dasd_eckd_start_analysis(struct dasd_block *block)
  2005. {
  2006. struct dasd_ccw_req *init_cqr;
  2007. init_cqr = dasd_eckd_analysis_ccw(block->base);
  2008. if (IS_ERR(init_cqr))
  2009. return PTR_ERR(init_cqr);
  2010. init_cqr->callback = dasd_eckd_analysis_callback;
  2011. init_cqr->callback_data = NULL;
  2012. init_cqr->expires = 5*HZ;
  2013. /* first try without ERP, so we can later handle unformatted
  2014. * devices as special case
  2015. */
  2016. clear_bit(DASD_CQR_FLAGS_USE_ERP, &init_cqr->flags);
  2017. init_cqr->retries = 0;
  2018. dasd_add_request_head(init_cqr);
  2019. return -EAGAIN;
  2020. }
  2021. static int dasd_eckd_end_analysis(struct dasd_block *block)
  2022. {
  2023. struct dasd_device *device = block->base;
  2024. struct dasd_eckd_private *private = device->private;
  2025. struct eckd_count *count_area;
  2026. unsigned int sb, blk_per_trk;
  2027. int status, i;
  2028. struct dasd_ccw_req *init_cqr;
  2029. status = private->init_cqr_status;
  2030. private->init_cqr_status = -1;
  2031. if (status == INIT_CQR_ERROR) {
  2032. /* try again, this time with full ERP */
  2033. init_cqr = dasd_eckd_analysis_ccw(device);
  2034. dasd_sleep_on(init_cqr);
  2035. status = dasd_eckd_analysis_evaluation(init_cqr);
  2036. dasd_sfree_request(init_cqr, device);
  2037. }
  2038. if (device->features & DASD_FEATURE_USERAW) {
  2039. block->bp_block = DASD_RAW_BLOCKSIZE;
  2040. blk_per_trk = DASD_RAW_BLOCK_PER_TRACK;
  2041. block->s2b_shift = 3;
  2042. goto raw;
  2043. }
  2044. if (status == INIT_CQR_UNFORMATTED) {
  2045. dev_warn(&device->cdev->dev, "The DASD is not formatted\n");
  2046. return -EMEDIUMTYPE;
  2047. } else if (status == INIT_CQR_ERROR) {
  2048. dev_err(&device->cdev->dev,
  2049. "Detecting the DASD disk layout failed because "
  2050. "of an I/O error\n");
  2051. return -EIO;
  2052. }
  2053. private->uses_cdl = 1;
  2054. /* Check Track 0 for Compatible Disk Layout */
  2055. count_area = NULL;
  2056. for (i = 0; i < 3; i++) {
  2057. if (private->count_area[i].kl != 4 ||
  2058. private->count_area[i].dl != dasd_eckd_cdl_reclen(i) - 4 ||
  2059. private->count_area[i].cyl != 0 ||
  2060. private->count_area[i].head != count_area_head[i] ||
  2061. private->count_area[i].record != count_area_rec[i]) {
  2062. private->uses_cdl = 0;
  2063. break;
  2064. }
  2065. }
  2066. if (i == 3)
  2067. count_area = &private->count_area[3];
  2068. if (private->uses_cdl == 0) {
  2069. for (i = 0; i < 5; i++) {
  2070. if ((private->count_area[i].kl != 0) ||
  2071. (private->count_area[i].dl !=
  2072. private->count_area[0].dl) ||
  2073. private->count_area[i].cyl != 0 ||
  2074. private->count_area[i].head != count_area_head[i] ||
  2075. private->count_area[i].record != count_area_rec[i])
  2076. break;
  2077. }
  2078. if (i == 5)
  2079. count_area = &private->count_area[0];
  2080. } else {
  2081. if (private->count_area[3].record == 1)
  2082. dev_warn(&device->cdev->dev,
  2083. "Track 0 has no records following the VTOC\n");
  2084. }
  2085. if (count_area != NULL && count_area->kl == 0) {
  2086. /* we found notthing violating our disk layout */
  2087. if (dasd_check_blocksize(count_area->dl) == 0)
  2088. block->bp_block = count_area->dl;
  2089. }
  2090. if (block->bp_block == 0) {
  2091. dev_warn(&device->cdev->dev,
  2092. "The disk layout of the DASD is not supported\n");
  2093. return -EMEDIUMTYPE;
  2094. }
  2095. block->s2b_shift = 0; /* bits to shift 512 to get a block */
  2096. for (sb = 512; sb < block->bp_block; sb = sb << 1)
  2097. block->s2b_shift++;
  2098. blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);
  2099. raw:
  2100. block->blocks = ((unsigned long) private->real_cyl *
  2101. private->rdc_data.trk_per_cyl *
  2102. blk_per_trk);
  2103. dev_info(&device->cdev->dev,
  2104. "DASD with %u KB/block, %lu KB total size, %u KB/track, "
  2105. "%s\n", (block->bp_block >> 10),
  2106. (((unsigned long) private->real_cyl *
  2107. private->rdc_data.trk_per_cyl *
  2108. blk_per_trk * (block->bp_block >> 9)) >> 1),
  2109. ((blk_per_trk * block->bp_block) >> 10),
  2110. private->uses_cdl ?
  2111. "compatible disk layout" : "linux disk layout");
  2112. return 0;
  2113. }
  2114. static int dasd_eckd_do_analysis(struct dasd_block *block)
  2115. {
  2116. struct dasd_eckd_private *private = block->base->private;
  2117. if (private->init_cqr_status < 0)
  2118. return dasd_eckd_start_analysis(block);
  2119. else
  2120. return dasd_eckd_end_analysis(block);
  2121. }
  2122. static int dasd_eckd_basic_to_ready(struct dasd_device *device)
  2123. {
  2124. return dasd_alias_add_device(device);
  2125. };
  2126. static int dasd_eckd_online_to_ready(struct dasd_device *device)
  2127. {
  2128. if (cancel_work_sync(&device->reload_device))
  2129. dasd_put_device(device);
  2130. if (cancel_work_sync(&device->kick_validate))
  2131. dasd_put_device(device);
  2132. return 0;
  2133. };
  2134. static int dasd_eckd_basic_to_known(struct dasd_device *device)
  2135. {
  2136. return dasd_alias_remove_device(device);
  2137. };
  2138. static int
  2139. dasd_eckd_fill_geometry(struct dasd_block *block, struct hd_geometry *geo)
  2140. {
  2141. struct dasd_eckd_private *private = block->base->private;
  2142. if (dasd_check_blocksize(block->bp_block) == 0) {
  2143. geo->sectors = recs_per_track(&private->rdc_data,
  2144. 0, block->bp_block);
  2145. }
  2146. geo->cylinders = private->rdc_data.no_cyl;
  2147. geo->heads = private->rdc_data.trk_per_cyl;
  2148. return 0;
  2149. }
  2150. /*
  2151. * Build the TCW request for the format check
  2152. */
  2153. static struct dasd_ccw_req *
  2154. dasd_eckd_build_check_tcw(struct dasd_device *base, struct format_data_t *fdata,
  2155. int enable_pav, struct eckd_count *fmt_buffer,
  2156. int rpt)
  2157. {
  2158. struct dasd_eckd_private *start_priv;
  2159. struct dasd_device *startdev = NULL;
  2160. struct tidaw *last_tidaw = NULL;
  2161. struct dasd_ccw_req *cqr;
  2162. struct itcw *itcw;
  2163. int itcw_size;
  2164. int count;
  2165. int rc;
  2166. int i;
  2167. if (enable_pav)
  2168. startdev = dasd_alias_get_start_dev(base);
  2169. if (!startdev)
  2170. startdev = base;
  2171. start_priv = startdev->private;
  2172. count = rpt * (fdata->stop_unit - fdata->start_unit + 1);
  2173. /*
  2174. * we're adding 'count' amount of tidaw to the itcw.
  2175. * calculate the corresponding itcw_size
  2176. */
  2177. itcw_size = itcw_calc_size(0, count, 0);
  2178. cqr = dasd_fmalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev);
  2179. if (IS_ERR(cqr))
  2180. return cqr;
  2181. start_priv->count++;
  2182. itcw = itcw_init(cqr->data, itcw_size, ITCW_OP_READ, 0, count, 0);
  2183. if (IS_ERR(itcw)) {
  2184. rc = -EINVAL;
  2185. goto out_err;
  2186. }
  2187. cqr->cpaddr = itcw_get_tcw(itcw);
  2188. rc = prepare_itcw(itcw, fdata->start_unit, fdata->stop_unit,
  2189. DASD_ECKD_CCW_READ_COUNT_MT, base, startdev, 0, count,
  2190. sizeof(struct eckd_count),
  2191. count * sizeof(struct eckd_count), 0, rpt);
  2192. if (rc)
  2193. goto out_err;
  2194. for (i = 0; i < count; i++) {
  2195. last_tidaw = itcw_add_tidaw(itcw, 0, fmt_buffer++,
  2196. sizeof(struct eckd_count));
  2197. if (IS_ERR(last_tidaw)) {
  2198. rc = -EINVAL;
  2199. goto out_err;
  2200. }
  2201. }
  2202. last_tidaw->flags |= TIDAW_FLAGS_LAST;
  2203. itcw_finalize(itcw);
  2204. cqr->cpmode = 1;
  2205. cqr->startdev = startdev;
  2206. cqr->memdev = startdev;
  2207. cqr->basedev = base;
  2208. cqr->retries = startdev->default_retries;
  2209. cqr->expires = startdev->default_expires * HZ;
  2210. cqr->buildclk = get_tod_clock();
  2211. cqr->status = DASD_CQR_FILLED;
  2212. /* Set flags to suppress output for expected errors */
  2213. set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags);
  2214. set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags);
  2215. return cqr;
  2216. out_err:
  2217. dasd_sfree_request(cqr, startdev);
  2218. return ERR_PTR(rc);
  2219. }
  2220. /*
  2221. * Build the CCW request for the format check
  2222. */
  2223. static struct dasd_ccw_req *
  2224. dasd_eckd_build_check(struct dasd_device *base, struct format_data_t *fdata,
  2225. int enable_pav, struct eckd_count *fmt_buffer, int rpt)
  2226. {
  2227. struct dasd_eckd_private *start_priv;
  2228. struct dasd_eckd_private *base_priv;
  2229. struct dasd_device *startdev = NULL;
  2230. struct dasd_ccw_req *cqr;
  2231. struct ccw1 *ccw;
  2232. void *data;
  2233. int cplength, datasize;
  2234. int use_prefix;
  2235. int count;
  2236. int i;
  2237. if (enable_pav)
  2238. startdev = dasd_alias_get_start_dev(base);
  2239. if (!startdev)
  2240. startdev = base;
  2241. start_priv = startdev->private;
  2242. base_priv = base->private;
  2243. count = rpt * (fdata->stop_unit - fdata->start_unit + 1);
  2244. use_prefix = base_priv->features.feature[8] & 0x01;
  2245. if (use_prefix) {
  2246. cplength = 1;
  2247. datasize = sizeof(struct PFX_eckd_data);
  2248. } else {
  2249. cplength = 2;
  2250. datasize = sizeof(struct DE_eckd_data) +
  2251. sizeof(struct LO_eckd_data);
  2252. }
  2253. cplength += count;
  2254. cqr = dasd_fmalloc_request(DASD_ECKD_MAGIC, cplength, datasize, startdev);
  2255. if (IS_ERR(cqr))
  2256. return cqr;
  2257. start_priv->count++;
  2258. data = cqr->data;
  2259. ccw = cqr->cpaddr;
  2260. if (use_prefix) {
  2261. prefix_LRE(ccw++, data, fdata->start_unit, fdata->stop_unit,
  2262. DASD_ECKD_CCW_READ_COUNT, base, startdev, 1, 0,
  2263. count, 0, 0);
  2264. } else {
  2265. define_extent(ccw++, data, fdata->start_unit, fdata->stop_unit,
  2266. DASD_ECKD_CCW_READ_COUNT, startdev, 0);
  2267. data += sizeof(struct DE_eckd_data);
  2268. ccw[-1].flags |= CCW_FLAG_CC;
  2269. locate_record(ccw++, data, fdata->start_unit, 0, count,
  2270. DASD_ECKD_CCW_READ_COUNT, base, 0);
  2271. }
  2272. for (i = 0; i < count; i++) {
  2273. ccw[-1].flags |= CCW_FLAG_CC;
  2274. ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT;
  2275. ccw->flags = CCW_FLAG_SLI;
  2276. ccw->count = 8;
  2277. ccw->cda = (__u32)(addr_t) fmt_buffer;
  2278. ccw++;
  2279. fmt_buffer++;
  2280. }
  2281. cqr->startdev = startdev;
  2282. cqr->memdev = startdev;
  2283. cqr->basedev = base;
  2284. cqr->retries = DASD_RETRIES;
  2285. cqr->expires = startdev->default_expires * HZ;
  2286. cqr->buildclk = get_tod_clock();
  2287. cqr->status = DASD_CQR_FILLED;
  2288. /* Set flags to suppress output for expected errors */
  2289. set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
  2290. return cqr;
  2291. }
  2292. static struct dasd_ccw_req *
  2293. dasd_eckd_build_format(struct dasd_device *base, struct dasd_device *startdev,
  2294. struct format_data_t *fdata, int enable_pav)
  2295. {
  2296. struct dasd_eckd_private *base_priv;
  2297. struct dasd_eckd_private *start_priv;
  2298. struct dasd_ccw_req *fcp;
  2299. struct eckd_count *ect;
  2300. struct ch_t address;
  2301. struct ccw1 *ccw;
  2302. void *data;
  2303. int rpt;
  2304. int cplength, datasize;
  2305. int i, j;
  2306. int intensity = 0;
  2307. int r0_perm;
  2308. int nr_tracks;
  2309. int use_prefix;
  2310. if (enable_pav)
  2311. startdev = dasd_alias_get_start_dev(base);
  2312. if (!startdev)
  2313. startdev = base;
  2314. start_priv = startdev->private;
  2315. base_priv = base->private;
  2316. rpt = recs_per_track(&base_priv->rdc_data, 0, fdata->blksize);
  2317. nr_tracks = fdata->stop_unit - fdata->start_unit + 1;
  2318. /*
  2319. * fdata->intensity is a bit string that tells us what to do:
  2320. * Bit 0: write record zero
  2321. * Bit 1: write home address, currently not supported
  2322. * Bit 2: invalidate tracks
  2323. * Bit 3: use OS/390 compatible disk layout (cdl)
  2324. * Bit 4: do not allow storage subsystem to modify record zero
  2325. * Only some bit combinations do make sense.
  2326. */
  2327. if (fdata->intensity & 0x10) {
  2328. r0_perm = 0;
  2329. intensity = fdata->intensity & ~0x10;
  2330. } else {
  2331. r0_perm = 1;
  2332. intensity = fdata->intensity;
  2333. }
  2334. use_prefix = base_priv->features.feature[8] & 0x01;
  2335. switch (intensity) {
  2336. case 0x00: /* Normal format */
  2337. case 0x08: /* Normal format, use cdl. */
  2338. cplength = 2 + (rpt*nr_tracks);
  2339. if (use_prefix)
  2340. datasize = sizeof(struct PFX_eckd_data) +
  2341. sizeof(struct LO_eckd_data) +
  2342. rpt * nr_tracks * sizeof(struct eckd_count);
  2343. else
  2344. datasize = sizeof(struct DE_eckd_data) +
  2345. sizeof(struct LO_eckd_data) +
  2346. rpt * nr_tracks * sizeof(struct eckd_count);
  2347. break;
  2348. case 0x01: /* Write record zero and format track. */
  2349. case 0x09: /* Write record zero and format track, use cdl. */
  2350. cplength = 2 + rpt * nr_tracks;
  2351. if (use_prefix)
  2352. datasize = sizeof(struct PFX_eckd_data) +
  2353. sizeof(struct LO_eckd_data) +
  2354. sizeof(struct eckd_count) +
  2355. rpt * nr_tracks * sizeof(struct eckd_count);
  2356. else
  2357. datasize = sizeof(struct DE_eckd_data) +
  2358. sizeof(struct LO_eckd_data) +
  2359. sizeof(struct eckd_count) +
  2360. rpt * nr_tracks * sizeof(struct eckd_count);
  2361. break;
  2362. case 0x04: /* Invalidate track. */
  2363. case 0x0c: /* Invalidate track, use cdl. */
  2364. cplength = 3;
  2365. if (use_prefix)
  2366. datasize = sizeof(struct PFX_eckd_data) +
  2367. sizeof(struct LO_eckd_data) +
  2368. sizeof(struct eckd_count);
  2369. else
  2370. datasize = sizeof(struct DE_eckd_data) +
  2371. sizeof(struct LO_eckd_data) +
  2372. sizeof(struct eckd_count);
  2373. break;
  2374. default:
  2375. dev_warn(&startdev->cdev->dev,
  2376. "An I/O control call used incorrect flags 0x%x\n",
  2377. fdata->intensity);
  2378. return ERR_PTR(-EINVAL);
  2379. }
  2380. fcp = dasd_fmalloc_request(DASD_ECKD_MAGIC, cplength, datasize, startdev);
  2381. if (IS_ERR(fcp))
  2382. return fcp;
  2383. start_priv->count++;
  2384. data = fcp->data;
  2385. ccw = fcp->cpaddr;
  2386. switch (intensity & ~0x08) {
  2387. case 0x00: /* Normal format. */
  2388. if (use_prefix) {
  2389. prefix(ccw++, (struct PFX_eckd_data *) data,
  2390. fdata->start_unit, fdata->stop_unit,
  2391. DASD_ECKD_CCW_WRITE_CKD, base, startdev);
  2392. /* grant subsystem permission to format R0 */
  2393. if (r0_perm)
  2394. ((struct PFX_eckd_data *)data)
  2395. ->define_extent.ga_extended |= 0x04;
  2396. data += sizeof(struct PFX_eckd_data);
  2397. } else {
  2398. define_extent(ccw++, (struct DE_eckd_data *) data,
  2399. fdata->start_unit, fdata->stop_unit,
  2400. DASD_ECKD_CCW_WRITE_CKD, startdev, 0);
  2401. /* grant subsystem permission to format R0 */
  2402. if (r0_perm)
  2403. ((struct DE_eckd_data *) data)
  2404. ->ga_extended |= 0x04;
  2405. data += sizeof(struct DE_eckd_data);
  2406. }
  2407. ccw[-1].flags |= CCW_FLAG_CC;
  2408. locate_record(ccw++, (struct LO_eckd_data *) data,
  2409. fdata->start_unit, 0, rpt*nr_tracks,
  2410. DASD_ECKD_CCW_WRITE_CKD, base,
  2411. fdata->blksize);
  2412. data += sizeof(struct LO_eckd_data);
  2413. break;
  2414. case 0x01: /* Write record zero + format track. */
  2415. if (use_prefix) {
  2416. prefix(ccw++, (struct PFX_eckd_data *) data,
  2417. fdata->start_unit, fdata->stop_unit,
  2418. DASD_ECKD_CCW_WRITE_RECORD_ZERO,
  2419. base, startdev);
  2420. data += sizeof(struct PFX_eckd_data);
  2421. } else {
  2422. define_extent(ccw++, (struct DE_eckd_data *) data,
  2423. fdata->start_unit, fdata->stop_unit,
  2424. DASD_ECKD_CCW_WRITE_RECORD_ZERO, startdev, 0);
  2425. data += sizeof(struct DE_eckd_data);
  2426. }
  2427. ccw[-1].flags |= CCW_FLAG_CC;
  2428. locate_record(ccw++, (struct LO_eckd_data *) data,
  2429. fdata->start_unit, 0, rpt * nr_tracks + 1,
  2430. DASD_ECKD_CCW_WRITE_RECORD_ZERO, base,
  2431. base->block->bp_block);
  2432. data += sizeof(struct LO_eckd_data);
  2433. break;
  2434. case 0x04: /* Invalidate track. */
  2435. if (use_prefix) {
  2436. prefix(ccw++, (struct PFX_eckd_data *) data,
  2437. fdata->start_unit, fdata->stop_unit,
  2438. DASD_ECKD_CCW_WRITE_CKD, base, startdev);
  2439. data += sizeof(struct PFX_eckd_data);
  2440. } else {
  2441. define_extent(ccw++, (struct DE_eckd_data *) data,
  2442. fdata->start_unit, fdata->stop_unit,
  2443. DASD_ECKD_CCW_WRITE_CKD, startdev, 0);
  2444. data += sizeof(struct DE_eckd_data);
  2445. }
  2446. ccw[-1].flags |= CCW_FLAG_CC;
  2447. locate_record(ccw++, (struct LO_eckd_data *) data,
  2448. fdata->start_unit, 0, 1,
  2449. DASD_ECKD_CCW_WRITE_CKD, base, 8);
  2450. data += sizeof(struct LO_eckd_data);
  2451. break;
  2452. }
  2453. for (j = 0; j < nr_tracks; j++) {
  2454. /* calculate cylinder and head for the current track */
  2455. set_ch_t(&address,
  2456. (fdata->start_unit + j) /
  2457. base_priv->rdc_data.trk_per_cyl,
  2458. (fdata->start_unit + j) %
  2459. base_priv->rdc_data.trk_per_cyl);
  2460. if (intensity & 0x01) { /* write record zero */
  2461. ect = (struct eckd_count *) data;
  2462. data += sizeof(struct eckd_count);
  2463. ect->cyl = address.cyl;
  2464. ect->head = address.head;
  2465. ect->record = 0;
  2466. ect->kl = 0;
  2467. ect->dl = 8;
  2468. ccw[-1].flags |= CCW_FLAG_CC;
  2469. ccw->cmd_code = DASD_ECKD_CCW_WRITE_RECORD_ZERO;
  2470. ccw->flags = CCW_FLAG_SLI;
  2471. ccw->count = 8;
  2472. ccw->cda = (__u32)(addr_t) ect;
  2473. ccw++;
  2474. }
  2475. if ((intensity & ~0x08) & 0x04) { /* erase track */
  2476. ect = (struct eckd_count *) data;
  2477. data += sizeof(struct eckd_count);
  2478. ect->cyl = address.cyl;
  2479. ect->head = address.head;
  2480. ect->record = 1;
  2481. ect->kl = 0;
  2482. ect->dl = 0;
  2483. ccw[-1].flags |= CCW_FLAG_CC;
  2484. ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD;
  2485. ccw->flags = CCW_FLAG_SLI;
  2486. ccw->count = 8;
  2487. ccw->cda = (__u32)(addr_t) ect;
  2488. } else { /* write remaining records */
  2489. for (i = 0; i < rpt; i++) {
  2490. ect = (struct eckd_count *) data;
  2491. data += sizeof(struct eckd_count);
  2492. ect->cyl = address.cyl;
  2493. ect->head = address.head;
  2494. ect->record = i + 1;
  2495. ect->kl = 0;
  2496. ect->dl = fdata->blksize;
  2497. /*
  2498. * Check for special tracks 0-1
  2499. * when formatting CDL
  2500. */
  2501. if ((intensity & 0x08) &&
  2502. address.cyl == 0 && address.head == 0) {
  2503. if (i < 3) {
  2504. ect->kl = 4;
  2505. ect->dl = sizes_trk0[i] - 4;
  2506. }
  2507. }
  2508. if ((intensity & 0x08) &&
  2509. address.cyl == 0 && address.head == 1) {
  2510. ect->kl = 44;
  2511. ect->dl = LABEL_SIZE - 44;
  2512. }
  2513. ccw[-1].flags |= CCW_FLAG_CC;
  2514. if (i != 0 || j == 0)
  2515. ccw->cmd_code =
  2516. DASD_ECKD_CCW_WRITE_CKD;
  2517. else
  2518. ccw->cmd_code =
  2519. DASD_ECKD_CCW_WRITE_CKD_MT;
  2520. ccw->flags = CCW_FLAG_SLI;
  2521. ccw->count = 8;
  2522. ccw->cda = (__u32)(addr_t) ect;
  2523. ccw++;
  2524. }
  2525. }
  2526. }
  2527. fcp->startdev = startdev;
  2528. fcp->memdev = startdev;
  2529. fcp->basedev = base;
  2530. fcp->retries = 256;
  2531. fcp->expires = startdev->default_expires * HZ;
  2532. fcp->buildclk = get_tod_clock();
  2533. fcp->status = DASD_CQR_FILLED;
  2534. return fcp;
  2535. }
  2536. /*
  2537. * Wrapper function to build a CCW request depending on input data
  2538. */
  2539. static struct dasd_ccw_req *
  2540. dasd_eckd_format_build_ccw_req(struct dasd_device *base,
  2541. struct format_data_t *fdata, int enable_pav,
  2542. int tpm, struct eckd_count *fmt_buffer, int rpt)
  2543. {
  2544. struct dasd_ccw_req *ccw_req;
  2545. if (!fmt_buffer) {
  2546. ccw_req = dasd_eckd_build_format(base, NULL, fdata, enable_pav);
  2547. } else {
  2548. if (tpm)
  2549. ccw_req = dasd_eckd_build_check_tcw(base, fdata,
  2550. enable_pav,
  2551. fmt_buffer, rpt);
  2552. else
  2553. ccw_req = dasd_eckd_build_check(base, fdata, enable_pav,
  2554. fmt_buffer, rpt);
  2555. }
  2556. return ccw_req;
  2557. }
  2558. /*
  2559. * Sanity checks on format_data
  2560. */
  2561. static int dasd_eckd_format_sanity_checks(struct dasd_device *base,
  2562. struct format_data_t *fdata)
  2563. {
  2564. struct dasd_eckd_private *private = base->private;
  2565. if (fdata->start_unit >=
  2566. (private->real_cyl * private->rdc_data.trk_per_cyl)) {
  2567. dev_warn(&base->cdev->dev,
  2568. "Start track number %u used in formatting is too big\n",
  2569. fdata->start_unit);
  2570. return -EINVAL;
  2571. }
  2572. if (fdata->stop_unit >=
  2573. (private->real_cyl * private->rdc_data.trk_per_cyl)) {
  2574. dev_warn(&base->cdev->dev,
  2575. "Stop track number %u used in formatting is too big\n",
  2576. fdata->stop_unit);
  2577. return -EINVAL;
  2578. }
  2579. if (fdata->start_unit > fdata->stop_unit) {
  2580. dev_warn(&base->cdev->dev,
  2581. "Start track %u used in formatting exceeds end track\n",
  2582. fdata->start_unit);
  2583. return -EINVAL;
  2584. }
  2585. if (dasd_check_blocksize(fdata->blksize) != 0) {
  2586. dev_warn(&base->cdev->dev,
  2587. "The DASD cannot be formatted with block size %u\n",
  2588. fdata->blksize);
  2589. return -EINVAL;
  2590. }
  2591. return 0;
  2592. }
  2593. /*
  2594. * This function will process format_data originally coming from an IOCTL
  2595. */
  2596. static int dasd_eckd_format_process_data(struct dasd_device *base,
  2597. struct format_data_t *fdata,
  2598. int enable_pav, int tpm,
  2599. struct eckd_count *fmt_buffer, int rpt,
  2600. struct irb *irb)
  2601. {
  2602. struct dasd_eckd_private *private = base->private;
  2603. struct dasd_ccw_req *cqr, *n;
  2604. struct list_head format_queue;
  2605. struct dasd_device *device;
  2606. char *sense = NULL;
  2607. int old_start, old_stop, format_step;
  2608. int step, retry;
  2609. int rc;
  2610. rc = dasd_eckd_format_sanity_checks(base, fdata);
  2611. if (rc)
  2612. return rc;
  2613. INIT_LIST_HEAD(&format_queue);
  2614. old_start = fdata->start_unit;
  2615. old_stop = fdata->stop_unit;
  2616. if (!tpm && fmt_buffer != NULL) {
  2617. /* Command Mode / Format Check */
  2618. format_step = 1;
  2619. } else if (tpm && fmt_buffer != NULL) {
  2620. /* Transport Mode / Format Check */
  2621. format_step = DASD_CQR_MAX_CCW / rpt;
  2622. } else {
  2623. /* Normal Formatting */
  2624. format_step = DASD_CQR_MAX_CCW /
  2625. recs_per_track(&private->rdc_data, 0, fdata->blksize);
  2626. }
  2627. do {
  2628. retry = 0;
  2629. while (fdata->start_unit <= old_stop) {
  2630. step = fdata->stop_unit - fdata->start_unit + 1;
  2631. if (step > format_step) {
  2632. fdata->stop_unit =
  2633. fdata->start_unit + format_step - 1;
  2634. }
  2635. cqr = dasd_eckd_format_build_ccw_req(base, fdata,
  2636. enable_pav, tpm,
  2637. fmt_buffer, rpt);
  2638. if (IS_ERR(cqr)) {
  2639. rc = PTR_ERR(cqr);
  2640. if (rc == -ENOMEM) {
  2641. if (list_empty(&format_queue))
  2642. goto out;
  2643. /*
  2644. * not enough memory available, start
  2645. * requests retry after first requests
  2646. * were finished
  2647. */
  2648. retry = 1;
  2649. break;
  2650. }
  2651. goto out_err;
  2652. }
  2653. list_add_tail(&cqr->blocklist, &format_queue);
  2654. if (fmt_buffer) {
  2655. step = fdata->stop_unit - fdata->start_unit + 1;
  2656. fmt_buffer += rpt * step;
  2657. }
  2658. fdata->start_unit = fdata->stop_unit + 1;
  2659. fdata->stop_unit = old_stop;
  2660. }
  2661. rc = dasd_sleep_on_queue(&format_queue);
  2662. out_err:
  2663. list_for_each_entry_safe(cqr, n, &format_queue, blocklist) {
  2664. device = cqr->startdev;
  2665. private = device->private;
  2666. if (cqr->status == DASD_CQR_FAILED) {
  2667. /*
  2668. * Only get sense data if called by format
  2669. * check
  2670. */
  2671. if (fmt_buffer && irb) {
  2672. sense = dasd_get_sense(&cqr->irb);
  2673. memcpy(irb, &cqr->irb, sizeof(*irb));
  2674. }
  2675. rc = -EIO;
  2676. }
  2677. list_del_init(&cqr->blocklist);
  2678. dasd_ffree_request(cqr, device);
  2679. private->count--;
  2680. }
  2681. if (rc && rc != -EIO)
  2682. goto out;
  2683. if (rc == -EIO) {
  2684. /*
  2685. * In case fewer than the expected records are on the
  2686. * track, we will most likely get a 'No Record Found'
  2687. * error (in command mode) or a 'File Protected' error
  2688. * (in transport mode). Those particular cases shouldn't
  2689. * pass the -EIO to the IOCTL, therefore reset the rc
  2690. * and continue.
  2691. */
  2692. if (sense &&
  2693. (sense[1] & SNS1_NO_REC_FOUND ||
  2694. sense[1] & SNS1_FILE_PROTECTED))
  2695. retry = 1;
  2696. else
  2697. goto out;
  2698. }
  2699. } while (retry);
  2700. out:
  2701. fdata->start_unit = old_start;
  2702. fdata->stop_unit = old_stop;
  2703. return rc;
  2704. }
  2705. static int dasd_eckd_format_device(struct dasd_device *base,
  2706. struct format_data_t *fdata, int enable_pav)
  2707. {
  2708. return dasd_eckd_format_process_data(base, fdata, enable_pav, 0, NULL,
  2709. 0, NULL);
  2710. }
  2711. static bool test_and_set_format_track(struct dasd_format_entry *to_format,
  2712. struct dasd_block *block)
  2713. {
  2714. struct dasd_format_entry *format;
  2715. unsigned long flags;
  2716. bool rc = false;
  2717. spin_lock_irqsave(&block->format_lock, flags);
  2718. list_for_each_entry(format, &block->format_list, list) {
  2719. if (format->track == to_format->track) {
  2720. rc = true;
  2721. goto out;
  2722. }
  2723. }
  2724. list_add_tail(&to_format->list, &block->format_list);
  2725. out:
  2726. spin_unlock_irqrestore(&block->format_lock, flags);
  2727. return rc;
  2728. }
  2729. static void clear_format_track(struct dasd_format_entry *format,
  2730. struct dasd_block *block)
  2731. {
  2732. unsigned long flags;
  2733. spin_lock_irqsave(&block->format_lock, flags);
  2734. list_del_init(&format->list);
  2735. spin_unlock_irqrestore(&block->format_lock, flags);
  2736. }
  2737. /*
  2738. * Callback function to free ESE format requests.
  2739. */
  2740. static void dasd_eckd_ese_format_cb(struct dasd_ccw_req *cqr, void *data)
  2741. {
  2742. struct dasd_device *device = cqr->startdev;
  2743. struct dasd_eckd_private *private = device->private;
  2744. struct dasd_format_entry *format = data;
  2745. clear_format_track(format, cqr->basedev->block);
  2746. private->count--;
  2747. dasd_ffree_request(cqr, device);
  2748. }
  2749. static struct dasd_ccw_req *
  2750. dasd_eckd_ese_format(struct dasd_device *startdev, struct dasd_ccw_req *cqr,
  2751. struct irb *irb)
  2752. {
  2753. struct dasd_eckd_private *private;
  2754. struct dasd_format_entry *format;
  2755. struct format_data_t fdata;
  2756. unsigned int recs_per_trk;
  2757. struct dasd_ccw_req *fcqr;
  2758. struct dasd_device *base;
  2759. struct dasd_block *block;
  2760. unsigned int blksize;
  2761. struct request *req;
  2762. sector_t first_trk;
  2763. sector_t last_trk;
  2764. sector_t curr_trk;
  2765. int rc;
  2766. req = cqr->callback_data;
  2767. block = cqr->block;
  2768. base = block->base;
  2769. private = base->private;
  2770. blksize = block->bp_block;
  2771. recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
  2772. format = &startdev->format_entry;
  2773. first_trk = blk_rq_pos(req) >> block->s2b_shift;
  2774. sector_div(first_trk, recs_per_trk);
  2775. last_trk =
  2776. (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
  2777. sector_div(last_trk, recs_per_trk);
  2778. rc = dasd_eckd_track_from_irb(irb, base, &curr_trk);
  2779. if (rc)
  2780. return ERR_PTR(rc);
  2781. if (curr_trk < first_trk || curr_trk > last_trk) {
  2782. DBF_DEV_EVENT(DBF_WARNING, startdev,
  2783. "ESE error track %llu not within range %llu - %llu\n",
  2784. curr_trk, first_trk, last_trk);
  2785. return ERR_PTR(-EINVAL);
  2786. }
  2787. format->track = curr_trk;
  2788. /* test if track is already in formatting by another thread */
  2789. if (test_and_set_format_track(format, block))
  2790. return ERR_PTR(-EEXIST);
  2791. fdata.start_unit = curr_trk;
  2792. fdata.stop_unit = curr_trk;
  2793. fdata.blksize = blksize;
  2794. fdata.intensity = private->uses_cdl ? DASD_FMT_INT_COMPAT : 0;
  2795. rc = dasd_eckd_format_sanity_checks(base, &fdata);
  2796. if (rc)
  2797. return ERR_PTR(-EINVAL);
  2798. /*
  2799. * We're building the request with PAV disabled as we're reusing
  2800. * the former startdev.
  2801. */
  2802. fcqr = dasd_eckd_build_format(base, startdev, &fdata, 0);
  2803. if (IS_ERR(fcqr))
  2804. return fcqr;
  2805. fcqr->callback = dasd_eckd_ese_format_cb;
  2806. fcqr->callback_data = (void *) format;
  2807. return fcqr;
  2808. }
  2809. /*
  2810. * When data is read from an unformatted area of an ESE volume, this function
  2811. * returns zeroed data and thereby mimics a read of zero data.
  2812. *
  2813. * The first unformatted track is the one that got the NRF error, the address is
  2814. * encoded in the sense data.
  2815. *
  2816. * All tracks before have returned valid data and should not be touched.
  2817. * All tracks after the unformatted track might be formatted or not. This is
  2818. * currently not known, remember the processed data and return the remainder of
  2819. * the request to the blocklayer in __dasd_cleanup_cqr().
  2820. */
  2821. static int dasd_eckd_ese_read(struct dasd_ccw_req *cqr, struct irb *irb)
  2822. {
  2823. struct dasd_eckd_private *private;
  2824. sector_t first_trk, last_trk;
  2825. sector_t first_blk, last_blk;
  2826. unsigned int blksize, off;
  2827. unsigned int recs_per_trk;
  2828. struct dasd_device *base;
  2829. struct req_iterator iter;
  2830. struct dasd_block *block;
  2831. unsigned int skip_block;
  2832. unsigned int blk_count;
  2833. struct request *req;
  2834. struct bio_vec bv;
  2835. sector_t curr_trk;
  2836. sector_t end_blk;
  2837. char *dst;
  2838. int rc;
  2839. req = (struct request *) cqr->callback_data;
  2840. base = cqr->block->base;
  2841. blksize = base->block->bp_block;
  2842. block = cqr->block;
  2843. private = base->private;
  2844. skip_block = 0;
  2845. blk_count = 0;
  2846. recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
  2847. first_trk = first_blk = blk_rq_pos(req) >> block->s2b_shift;
  2848. sector_div(first_trk, recs_per_trk);
  2849. last_trk = last_blk =
  2850. (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
  2851. sector_div(last_trk, recs_per_trk);
  2852. rc = dasd_eckd_track_from_irb(irb, base, &curr_trk);
  2853. if (rc)
  2854. return rc;
  2855. /* sanity check if the current track from sense data is valid */
  2856. if (curr_trk < first_trk || curr_trk > last_trk) {
  2857. DBF_DEV_EVENT(DBF_WARNING, base,
  2858. "ESE error track %llu not within range %llu - %llu\n",
  2859. curr_trk, first_trk, last_trk);
  2860. return -EINVAL;
  2861. }
  2862. /*
  2863. * if not the first track got the NRF error we have to skip over valid
  2864. * blocks
  2865. */
  2866. if (curr_trk != first_trk)
  2867. skip_block = curr_trk * recs_per_trk - first_blk;
  2868. /* we have no information beyond the current track */
  2869. end_blk = (curr_trk + 1) * recs_per_trk;
  2870. rq_for_each_segment(bv, req, iter) {
  2871. dst = page_address(bv.bv_page) + bv.bv_offset;
  2872. for (off = 0; off < bv.bv_len; off += blksize) {
  2873. if (first_blk + blk_count >= end_blk) {
  2874. cqr->proc_bytes = blk_count * blksize;
  2875. return 0;
  2876. }
  2877. if (dst && !skip_block) {
  2878. dst += off;
  2879. memset(dst, 0, blksize);
  2880. } else {
  2881. skip_block--;
  2882. }
  2883. blk_count++;
  2884. }
  2885. }
  2886. return 0;
  2887. }
  2888. /*
  2889. * Helper function to count consecutive records of a single track.
  2890. */
  2891. static int dasd_eckd_count_records(struct eckd_count *fmt_buffer, int start,
  2892. int max)
  2893. {
  2894. int head;
  2895. int i;
  2896. head = fmt_buffer[start].head;
  2897. /*
  2898. * There are 3 conditions where we stop counting:
  2899. * - if data reoccurs (same head and record may reoccur), which may
  2900. * happen due to the way DASD_ECKD_CCW_READ_COUNT works
  2901. * - when the head changes, because we're iterating over several tracks
  2902. * then (DASD_ECKD_CCW_READ_COUNT_MT)
  2903. * - when we've reached the end of sensible data in the buffer (the
  2904. * record will be 0 then)
  2905. */
  2906. for (i = start; i < max; i++) {
  2907. if (i > start) {
  2908. if ((fmt_buffer[i].head == head &&
  2909. fmt_buffer[i].record == 1) ||
  2910. fmt_buffer[i].head != head ||
  2911. fmt_buffer[i].record == 0)
  2912. break;
  2913. }
  2914. }
  2915. return i - start;
  2916. }
  2917. /*
  2918. * Evaluate a given range of tracks. Data like number of records, blocksize,
  2919. * record ids, and key length are compared with expected data.
  2920. *
  2921. * If a mismatch occurs, the corresponding error bit is set, as well as
  2922. * additional information, depending on the error.
  2923. */
  2924. static void dasd_eckd_format_evaluate_tracks(struct eckd_count *fmt_buffer,
  2925. struct format_check_t *cdata,
  2926. int rpt_max, int rpt_exp,
  2927. int trk_per_cyl, int tpm)
  2928. {
  2929. struct ch_t geo;
  2930. int max_entries;
  2931. int count = 0;
  2932. int trkcount;
  2933. int blksize;
  2934. int pos = 0;
  2935. int i, j;
  2936. int kl;
  2937. trkcount = cdata->expect.stop_unit - cdata->expect.start_unit + 1;
  2938. max_entries = trkcount * rpt_max;
  2939. for (i = cdata->expect.start_unit; i <= cdata->expect.stop_unit; i++) {
  2940. /* Calculate the correct next starting position in the buffer */
  2941. if (tpm) {
  2942. while (fmt_buffer[pos].record == 0 &&
  2943. fmt_buffer[pos].dl == 0) {
  2944. if (pos++ > max_entries)
  2945. break;
  2946. }
  2947. } else {
  2948. if (i != cdata->expect.start_unit)
  2949. pos += rpt_max - count;
  2950. }
  2951. /* Calculate the expected geo values for the current track */
  2952. set_ch_t(&geo, i / trk_per_cyl, i % trk_per_cyl);
  2953. /* Count and check number of records */
  2954. count = dasd_eckd_count_records(fmt_buffer, pos, pos + rpt_max);
  2955. if (count < rpt_exp) {
  2956. cdata->result = DASD_FMT_ERR_TOO_FEW_RECORDS;
  2957. break;
  2958. }
  2959. if (count > rpt_exp) {
  2960. cdata->result = DASD_FMT_ERR_TOO_MANY_RECORDS;
  2961. break;
  2962. }
  2963. for (j = 0; j < count; j++, pos++) {
  2964. blksize = cdata->expect.blksize;
  2965. kl = 0;
  2966. /*
  2967. * Set special values when checking CDL formatted
  2968. * devices.
  2969. */
  2970. if ((cdata->expect.intensity & 0x08) &&
  2971. geo.cyl == 0 && geo.head == 0) {
  2972. if (j < 3) {
  2973. blksize = sizes_trk0[j] - 4;
  2974. kl = 4;
  2975. }
  2976. }
  2977. if ((cdata->expect.intensity & 0x08) &&
  2978. geo.cyl == 0 && geo.head == 1) {
  2979. blksize = LABEL_SIZE - 44;
  2980. kl = 44;
  2981. }
  2982. /* Check blocksize */
  2983. if (fmt_buffer[pos].dl != blksize) {
  2984. cdata->result = DASD_FMT_ERR_BLKSIZE;
  2985. goto out;
  2986. }
  2987. /* Check if key length is 0 */
  2988. if (fmt_buffer[pos].kl != kl) {
  2989. cdata->result = DASD_FMT_ERR_KEY_LENGTH;
  2990. goto out;
  2991. }
  2992. /* Check if record_id is correct */
  2993. if (fmt_buffer[pos].cyl != geo.cyl ||
  2994. fmt_buffer[pos].head != geo.head ||
  2995. fmt_buffer[pos].record != (j + 1)) {
  2996. cdata->result = DASD_FMT_ERR_RECORD_ID;
  2997. goto out;
  2998. }
  2999. }
  3000. }
  3001. out:
  3002. /*
  3003. * In case of no errors, we need to decrease by one
  3004. * to get the correct positions.
  3005. */
  3006. if (!cdata->result) {
  3007. i--;
  3008. pos--;
  3009. }
  3010. cdata->unit = i;
  3011. cdata->num_records = count;
  3012. cdata->rec = fmt_buffer[pos].record;
  3013. cdata->blksize = fmt_buffer[pos].dl;
  3014. cdata->key_length = fmt_buffer[pos].kl;
  3015. }
  3016. /*
  3017. * Check the format of a range of tracks of a DASD.
  3018. */
  3019. static int dasd_eckd_check_device_format(struct dasd_device *base,
  3020. struct format_check_t *cdata,
  3021. int enable_pav)
  3022. {
  3023. struct dasd_eckd_private *private = base->private;
  3024. struct eckd_count *fmt_buffer;
  3025. struct irb irb;
  3026. int rpt_max, rpt_exp;
  3027. int fmt_buffer_size;
  3028. int trk_per_cyl;
  3029. int trkcount;
  3030. int tpm = 0;
  3031. int rc;
  3032. trk_per_cyl = private->rdc_data.trk_per_cyl;
  3033. /* Get maximum and expected amount of records per track */
  3034. rpt_max = recs_per_track(&private->rdc_data, 0, 512) + 1;
  3035. rpt_exp = recs_per_track(&private->rdc_data, 0, cdata->expect.blksize);
  3036. trkcount = cdata->expect.stop_unit - cdata->expect.start_unit + 1;
  3037. fmt_buffer_size = trkcount * rpt_max * sizeof(struct eckd_count);
  3038. fmt_buffer = kzalloc(fmt_buffer_size, GFP_KERNEL | GFP_DMA);
  3039. if (!fmt_buffer)
  3040. return -ENOMEM;
  3041. /*
  3042. * A certain FICON feature subset is needed to operate in transport
  3043. * mode. Additionally, the support for transport mode is implicitly
  3044. * checked by comparing the buffer size with fcx_max_data. As long as
  3045. * the buffer size is smaller we can operate in transport mode and
  3046. * process multiple tracks. If not, only one track at once is being
  3047. * processed using command mode.
  3048. */
  3049. if ((private->features.feature[40] & 0x04) &&
  3050. fmt_buffer_size <= private->fcx_max_data)
  3051. tpm = 1;
  3052. rc = dasd_eckd_format_process_data(base, &cdata->expect, enable_pav,
  3053. tpm, fmt_buffer, rpt_max, &irb);
  3054. if (rc && rc != -EIO)
  3055. goto out;
  3056. if (rc == -EIO) {
  3057. /*
  3058. * If our first attempt with transport mode enabled comes back
  3059. * with an incorrect length error, we're going to retry the
  3060. * check with command mode.
  3061. */
  3062. if (tpm && scsw_cstat(&irb.scsw) == 0x40) {
  3063. tpm = 0;
  3064. rc = dasd_eckd_format_process_data(base, &cdata->expect,
  3065. enable_pav, tpm,
  3066. fmt_buffer, rpt_max,
  3067. &irb);
  3068. if (rc)
  3069. goto out;
  3070. } else {
  3071. goto out;
  3072. }
  3073. }
  3074. dasd_eckd_format_evaluate_tracks(fmt_buffer, cdata, rpt_max, rpt_exp,
  3075. trk_per_cyl, tpm);
  3076. out:
  3077. kfree(fmt_buffer);
  3078. return rc;
  3079. }
  3080. static void dasd_eckd_handle_terminated_request(struct dasd_ccw_req *cqr)
  3081. {
  3082. if (cqr->retries < 0) {
  3083. cqr->status = DASD_CQR_FAILED;
  3084. return;
  3085. }
  3086. cqr->status = DASD_CQR_FILLED;
  3087. if (cqr->block && (cqr->startdev != cqr->block->base)) {
  3088. dasd_eckd_reset_ccw_to_base_io(cqr);
  3089. cqr->startdev = cqr->block->base;
  3090. cqr->lpm = dasd_path_get_opm(cqr->block->base);
  3091. }
  3092. };
  3093. static dasd_erp_fn_t
  3094. dasd_eckd_erp_action(struct dasd_ccw_req * cqr)
  3095. {
  3096. struct dasd_device *device = (struct dasd_device *) cqr->startdev;
  3097. struct ccw_device *cdev = device->cdev;
  3098. switch (cdev->id.cu_type) {
  3099. case 0x3990:
  3100. case 0x2105:
  3101. case 0x2107:
  3102. case 0x1750:
  3103. return dasd_3990_erp_action;
  3104. case 0x9343:
  3105. case 0x3880:
  3106. default:
  3107. return dasd_default_erp_action;
  3108. }
  3109. }
  3110. static dasd_erp_fn_t
  3111. dasd_eckd_erp_postaction(struct dasd_ccw_req * cqr)
  3112. {
  3113. return dasd_default_erp_postaction;
  3114. }
  3115. static void dasd_eckd_check_for_device_change(struct dasd_device *device,
  3116. struct dasd_ccw_req *cqr,
  3117. struct irb *irb)
  3118. {
  3119. char mask;
  3120. char *sense = NULL;
  3121. struct dasd_eckd_private *private = device->private;
  3122. /* first of all check for state change pending interrupt */
  3123. mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP;
  3124. if ((scsw_dstat(&irb->scsw) & mask) == mask) {
  3125. /*
  3126. * for alias only, not in offline processing
  3127. * and only if not suspended
  3128. */
  3129. if (!device->block && private->lcu &&
  3130. device->state == DASD_STATE_ONLINE &&
  3131. !test_bit(DASD_FLAG_OFFLINE, &device->flags) &&
  3132. !test_bit(DASD_FLAG_SUSPENDED, &device->flags)) {
  3133. /* schedule worker to reload device */
  3134. dasd_reload_device(device);
  3135. }
  3136. dasd_generic_handle_state_change(device);
  3137. return;
  3138. }
  3139. sense = dasd_get_sense(irb);
  3140. if (!sense)
  3141. return;
  3142. /* summary unit check */
  3143. if ((sense[27] & DASD_SENSE_BIT_0) && (sense[7] == 0x0D) &&
  3144. (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK)) {
  3145. if (test_and_set_bit(DASD_FLAG_SUC, &device->flags)) {
  3146. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  3147. "eckd suc: device already notified");
  3148. return;
  3149. }
  3150. sense = dasd_get_sense(irb);
  3151. if (!sense) {
  3152. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  3153. "eckd suc: no reason code available");
  3154. clear_bit(DASD_FLAG_SUC, &device->flags);
  3155. return;
  3156. }
  3157. private->suc_reason = sense[8];
  3158. DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x",
  3159. "eckd handle summary unit check: reason",
  3160. private->suc_reason);
  3161. dasd_get_device(device);
  3162. if (!schedule_work(&device->suc_work))
  3163. dasd_put_device(device);
  3164. return;
  3165. }
  3166. /* service information message SIM */
  3167. if (!cqr && !(sense[27] & DASD_SENSE_BIT_0) &&
  3168. ((sense[6] & DASD_SIM_SENSE) == DASD_SIM_SENSE)) {
  3169. dasd_3990_erp_handle_sim(device, sense);
  3170. return;
  3171. }
  3172. /* loss of device reservation is handled via base devices only
  3173. * as alias devices may be used with several bases
  3174. */
  3175. if (device->block && (sense[27] & DASD_SENSE_BIT_0) &&
  3176. (sense[7] == 0x3F) &&
  3177. (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) &&
  3178. test_bit(DASD_FLAG_IS_RESERVED, &device->flags)) {
  3179. if (device->features & DASD_FEATURE_FAILONSLCK)
  3180. set_bit(DASD_FLAG_LOCK_STOLEN, &device->flags);
  3181. clear_bit(DASD_FLAG_IS_RESERVED, &device->flags);
  3182. dev_err(&device->cdev->dev,
  3183. "The device reservation was lost\n");
  3184. }
  3185. }
  3186. static int dasd_eckd_ras_sanity_checks(struct dasd_device *device,
  3187. unsigned int first_trk,
  3188. unsigned int last_trk)
  3189. {
  3190. struct dasd_eckd_private *private = device->private;
  3191. unsigned int trks_per_vol;
  3192. int rc = 0;
  3193. trks_per_vol = private->real_cyl * private->rdc_data.trk_per_cyl;
  3194. if (first_trk >= trks_per_vol) {
  3195. dev_warn(&device->cdev->dev,
  3196. "Start track number %u used in the space release command is too big\n",
  3197. first_trk);
  3198. rc = -EINVAL;
  3199. } else if (last_trk >= trks_per_vol) {
  3200. dev_warn(&device->cdev->dev,
  3201. "Stop track number %u used in the space release command is too big\n",
  3202. last_trk);
  3203. rc = -EINVAL;
  3204. } else if (first_trk > last_trk) {
  3205. dev_warn(&device->cdev->dev,
  3206. "Start track %u used in the space release command exceeds the end track\n",
  3207. first_trk);
  3208. rc = -EINVAL;
  3209. }
  3210. return rc;
  3211. }
  3212. /*
  3213. * Helper function to count the amount of involved extents within a given range
  3214. * with extent alignment in mind.
  3215. */
  3216. static int count_exts(unsigned int from, unsigned int to, int trks_per_ext)
  3217. {
  3218. int cur_pos = 0;
  3219. int count = 0;
  3220. int tmp;
  3221. if (from == to)
  3222. return 1;
  3223. /* Count first partial extent */
  3224. if (from % trks_per_ext != 0) {
  3225. tmp = from + trks_per_ext - (from % trks_per_ext) - 1;
  3226. if (tmp > to)
  3227. tmp = to;
  3228. cur_pos = tmp - from + 1;
  3229. count++;
  3230. }
  3231. /* Count full extents */
  3232. if (to - (from + cur_pos) + 1 >= trks_per_ext) {
  3233. tmp = to - ((to - trks_per_ext + 1) % trks_per_ext);
  3234. count += (tmp - (from + cur_pos) + 1) / trks_per_ext;
  3235. cur_pos = tmp;
  3236. }
  3237. /* Count last partial extent */
  3238. if (cur_pos < to)
  3239. count++;
  3240. return count;
  3241. }
  3242. /*
  3243. * Release allocated space for a given range or an entire volume.
  3244. */
  3245. static struct dasd_ccw_req *
  3246. dasd_eckd_dso_ras(struct dasd_device *device, struct dasd_block *block,
  3247. struct request *req, unsigned int first_trk,
  3248. unsigned int last_trk, int by_extent)
  3249. {
  3250. struct dasd_eckd_private *private = device->private;
  3251. struct dasd_dso_ras_ext_range *ras_range;
  3252. struct dasd_rssd_features *features;
  3253. struct dasd_dso_ras_data *ras_data;
  3254. u16 heads, beg_head, end_head;
  3255. int cur_to_trk, cur_from_trk;
  3256. struct dasd_ccw_req *cqr;
  3257. u32 beg_cyl, end_cyl;
  3258. struct ccw1 *ccw;
  3259. int trks_per_ext;
  3260. size_t ras_size;
  3261. size_t size;
  3262. int nr_exts;
  3263. void *rq;
  3264. int i;
  3265. if (dasd_eckd_ras_sanity_checks(device, first_trk, last_trk))
  3266. return ERR_PTR(-EINVAL);
  3267. rq = req ? blk_mq_rq_to_pdu(req) : NULL;
  3268. features = &private->features;
  3269. trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl;
  3270. nr_exts = 0;
  3271. if (by_extent)
  3272. nr_exts = count_exts(first_trk, last_trk, trks_per_ext);
  3273. ras_size = sizeof(*ras_data);
  3274. size = ras_size + (nr_exts * sizeof(*ras_range));
  3275. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, size, device, rq);
  3276. if (IS_ERR(cqr)) {
  3277. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  3278. "Could not allocate RAS request");
  3279. return cqr;
  3280. }
  3281. ras_data = cqr->data;
  3282. memset(ras_data, 0, size);
  3283. ras_data->order = DSO_ORDER_RAS;
  3284. ras_data->flags.vol_type = 0; /* CKD volume */
  3285. /* Release specified extents or entire volume */
  3286. ras_data->op_flags.by_extent = by_extent;
  3287. /*
  3288. * This bit guarantees initialisation of tracks within an extent that is
  3289. * not fully specified, but is only supported with a certain feature
  3290. * subset.
  3291. */
  3292. ras_data->op_flags.guarantee_init = !!(features->feature[56] & 0x01);
  3293. ras_data->lss = private->ned->ID;
  3294. ras_data->dev_addr = private->ned->unit_addr;
  3295. ras_data->nr_exts = nr_exts;
  3296. if (by_extent) {
  3297. heads = private->rdc_data.trk_per_cyl;
  3298. cur_from_trk = first_trk;
  3299. cur_to_trk = first_trk + trks_per_ext -
  3300. (first_trk % trks_per_ext) - 1;
  3301. if (cur_to_trk > last_trk)
  3302. cur_to_trk = last_trk;
  3303. ras_range = (struct dasd_dso_ras_ext_range *)(cqr->data + ras_size);
  3304. for (i = 0; i < nr_exts; i++) {
  3305. beg_cyl = cur_from_trk / heads;
  3306. beg_head = cur_from_trk % heads;
  3307. end_cyl = cur_to_trk / heads;
  3308. end_head = cur_to_trk % heads;
  3309. set_ch_t(&ras_range->beg_ext, beg_cyl, beg_head);
  3310. set_ch_t(&ras_range->end_ext, end_cyl, end_head);
  3311. cur_from_trk = cur_to_trk + 1;
  3312. cur_to_trk = cur_from_trk + trks_per_ext - 1;
  3313. if (cur_to_trk > last_trk)
  3314. cur_to_trk = last_trk;
  3315. ras_range++;
  3316. }
  3317. }
  3318. ccw = cqr->cpaddr;
  3319. ccw->cda = (__u32)(addr_t)cqr->data;
  3320. ccw->cmd_code = DASD_ECKD_CCW_DSO;
  3321. ccw->count = size;
  3322. cqr->startdev = device;
  3323. cqr->memdev = device;
  3324. cqr->block = block;
  3325. cqr->retries = 256;
  3326. cqr->expires = device->default_expires * HZ;
  3327. cqr->buildclk = get_tod_clock();
  3328. cqr->status = DASD_CQR_FILLED;
  3329. return cqr;
  3330. }
  3331. static int dasd_eckd_release_space_full(struct dasd_device *device)
  3332. {
  3333. struct dasd_ccw_req *cqr;
  3334. int rc;
  3335. cqr = dasd_eckd_dso_ras(device, NULL, NULL, 0, 0, 0);
  3336. if (IS_ERR(cqr))
  3337. return PTR_ERR(cqr);
  3338. rc = dasd_sleep_on_interruptible(cqr);
  3339. dasd_sfree_request(cqr, cqr->memdev);
  3340. return rc;
  3341. }
  3342. static int dasd_eckd_release_space_trks(struct dasd_device *device,
  3343. unsigned int from, unsigned int to)
  3344. {
  3345. struct dasd_eckd_private *private = device->private;
  3346. struct dasd_block *block = device->block;
  3347. struct dasd_ccw_req *cqr, *n;
  3348. struct list_head ras_queue;
  3349. unsigned int device_exts;
  3350. int trks_per_ext;
  3351. int stop, step;
  3352. int cur_pos;
  3353. int rc = 0;
  3354. int retry;
  3355. INIT_LIST_HEAD(&ras_queue);
  3356. device_exts = private->real_cyl / dasd_eckd_ext_size(device);
  3357. trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl;
  3358. /* Make sure device limits are not exceeded */
  3359. step = trks_per_ext * min(device_exts, DASD_ECKD_RAS_EXTS_MAX);
  3360. cur_pos = from;
  3361. do {
  3362. retry = 0;
  3363. while (cur_pos < to) {
  3364. stop = cur_pos + step -
  3365. ((cur_pos + step) % trks_per_ext) - 1;
  3366. if (stop > to)
  3367. stop = to;
  3368. cqr = dasd_eckd_dso_ras(device, NULL, NULL, cur_pos, stop, 1);
  3369. if (IS_ERR(cqr)) {
  3370. rc = PTR_ERR(cqr);
  3371. if (rc == -ENOMEM) {
  3372. if (list_empty(&ras_queue))
  3373. goto out;
  3374. retry = 1;
  3375. break;
  3376. }
  3377. goto err_out;
  3378. }
  3379. spin_lock_irq(&block->queue_lock);
  3380. list_add_tail(&cqr->blocklist, &ras_queue);
  3381. spin_unlock_irq(&block->queue_lock);
  3382. cur_pos = stop + 1;
  3383. }
  3384. rc = dasd_sleep_on_queue_interruptible(&ras_queue);
  3385. err_out:
  3386. list_for_each_entry_safe(cqr, n, &ras_queue, blocklist) {
  3387. device = cqr->startdev;
  3388. private = device->private;
  3389. spin_lock_irq(&block->queue_lock);
  3390. list_del_init(&cqr->blocklist);
  3391. spin_unlock_irq(&block->queue_lock);
  3392. dasd_sfree_request(cqr, device);
  3393. private->count--;
  3394. }
  3395. } while (retry);
  3396. out:
  3397. return rc;
  3398. }
  3399. static int dasd_eckd_release_space(struct dasd_device *device,
  3400. struct format_data_t *rdata)
  3401. {
  3402. if (rdata->intensity & DASD_FMT_INT_ESE_FULL)
  3403. return dasd_eckd_release_space_full(device);
  3404. else if (rdata->intensity == 0)
  3405. return dasd_eckd_release_space_trks(device, rdata->start_unit,
  3406. rdata->stop_unit);
  3407. else
  3408. return -EINVAL;
  3409. }
  3410. static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_single(
  3411. struct dasd_device *startdev,
  3412. struct dasd_block *block,
  3413. struct request *req,
  3414. sector_t first_rec,
  3415. sector_t last_rec,
  3416. sector_t first_trk,
  3417. sector_t last_trk,
  3418. unsigned int first_offs,
  3419. unsigned int last_offs,
  3420. unsigned int blk_per_trk,
  3421. unsigned int blksize)
  3422. {
  3423. struct dasd_eckd_private *private;
  3424. unsigned long *idaws;
  3425. struct LO_eckd_data *LO_data;
  3426. struct dasd_ccw_req *cqr;
  3427. struct ccw1 *ccw;
  3428. struct req_iterator iter;
  3429. struct bio_vec bv;
  3430. char *dst;
  3431. unsigned int off;
  3432. int count, cidaw, cplength, datasize;
  3433. sector_t recid;
  3434. unsigned char cmd, rcmd;
  3435. int use_prefix;
  3436. struct dasd_device *basedev;
  3437. basedev = block->base;
  3438. private = basedev->private;
  3439. if (rq_data_dir(req) == READ)
  3440. cmd = DASD_ECKD_CCW_READ_MT;
  3441. else if (rq_data_dir(req) == WRITE)
  3442. cmd = DASD_ECKD_CCW_WRITE_MT;
  3443. else
  3444. return ERR_PTR(-EINVAL);
  3445. /* Check struct bio and count the number of blocks for the request. */
  3446. count = 0;
  3447. cidaw = 0;
  3448. rq_for_each_segment(bv, req, iter) {
  3449. if (bv.bv_len & (blksize - 1))
  3450. /* Eckd can only do full blocks. */
  3451. return ERR_PTR(-EINVAL);
  3452. count += bv.bv_len >> (block->s2b_shift + 9);
  3453. if (idal_is_needed (page_address(bv.bv_page), bv.bv_len))
  3454. cidaw += bv.bv_len >> (block->s2b_shift + 9);
  3455. }
  3456. /* Paranoia. */
  3457. if (count != last_rec - first_rec + 1)
  3458. return ERR_PTR(-EINVAL);
  3459. /* use the prefix command if available */
  3460. use_prefix = private->features.feature[8] & 0x01;
  3461. if (use_prefix) {
  3462. /* 1x prefix + number of blocks */
  3463. cplength = 2 + count;
  3464. /* 1x prefix + cidaws*sizeof(long) */
  3465. datasize = sizeof(struct PFX_eckd_data) +
  3466. sizeof(struct LO_eckd_data) +
  3467. cidaw * sizeof(unsigned long);
  3468. } else {
  3469. /* 1x define extent + 1x locate record + number of blocks */
  3470. cplength = 2 + count;
  3471. /* 1x define extent + 1x locate record + cidaws*sizeof(long) */
  3472. datasize = sizeof(struct DE_eckd_data) +
  3473. sizeof(struct LO_eckd_data) +
  3474. cidaw * sizeof(unsigned long);
  3475. }
  3476. /* Find out the number of additional locate record ccws for cdl. */
  3477. if (private->uses_cdl && first_rec < 2*blk_per_trk) {
  3478. if (last_rec >= 2*blk_per_trk)
  3479. count = 2*blk_per_trk - first_rec;
  3480. cplength += count;
  3481. datasize += count*sizeof(struct LO_eckd_data);
  3482. }
  3483. /* Allocate the ccw request. */
  3484. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize,
  3485. startdev, blk_mq_rq_to_pdu(req));
  3486. if (IS_ERR(cqr))
  3487. return cqr;
  3488. ccw = cqr->cpaddr;
  3489. /* First ccw is define extent or prefix. */
  3490. if (use_prefix) {
  3491. if (prefix(ccw++, cqr->data, first_trk,
  3492. last_trk, cmd, basedev, startdev) == -EAGAIN) {
  3493. /* Clock not in sync and XRC is enabled.
  3494. * Try again later.
  3495. */
  3496. dasd_sfree_request(cqr, startdev);
  3497. return ERR_PTR(-EAGAIN);
  3498. }
  3499. idaws = (unsigned long *) (cqr->data +
  3500. sizeof(struct PFX_eckd_data));
  3501. } else {
  3502. if (define_extent(ccw++, cqr->data, first_trk,
  3503. last_trk, cmd, basedev, 0) == -EAGAIN) {
  3504. /* Clock not in sync and XRC is enabled.
  3505. * Try again later.
  3506. */
  3507. dasd_sfree_request(cqr, startdev);
  3508. return ERR_PTR(-EAGAIN);
  3509. }
  3510. idaws = (unsigned long *) (cqr->data +
  3511. sizeof(struct DE_eckd_data));
  3512. }
  3513. /* Build locate_record+read/write/ccws. */
  3514. LO_data = (struct LO_eckd_data *) (idaws + cidaw);
  3515. recid = first_rec;
  3516. if (private->uses_cdl == 0 || recid > 2*blk_per_trk) {
  3517. /* Only standard blocks so there is just one locate record. */
  3518. ccw[-1].flags |= CCW_FLAG_CC;
  3519. locate_record(ccw++, LO_data++, first_trk, first_offs + 1,
  3520. last_rec - recid + 1, cmd, basedev, blksize);
  3521. }
  3522. rq_for_each_segment(bv, req, iter) {
  3523. dst = page_address(bv.bv_page) + bv.bv_offset;
  3524. if (dasd_page_cache) {
  3525. char *copy = kmem_cache_alloc(dasd_page_cache,
  3526. GFP_DMA | __GFP_NOWARN);
  3527. if (copy && rq_data_dir(req) == WRITE)
  3528. memcpy(copy + bv.bv_offset, dst, bv.bv_len);
  3529. if (copy)
  3530. dst = copy + bv.bv_offset;
  3531. }
  3532. for (off = 0; off < bv.bv_len; off += blksize) {
  3533. sector_t trkid = recid;
  3534. unsigned int recoffs = sector_div(trkid, blk_per_trk);
  3535. rcmd = cmd;
  3536. count = blksize;
  3537. /* Locate record for cdl special block ? */
  3538. if (private->uses_cdl && recid < 2*blk_per_trk) {
  3539. if (dasd_eckd_cdl_special(blk_per_trk, recid)){
  3540. rcmd |= 0x8;
  3541. count = dasd_eckd_cdl_reclen(recid);
  3542. if (count < blksize &&
  3543. rq_data_dir(req) == READ)
  3544. memset(dst + count, 0xe5,
  3545. blksize - count);
  3546. }
  3547. ccw[-1].flags |= CCW_FLAG_CC;
  3548. locate_record(ccw++, LO_data++,
  3549. trkid, recoffs + 1,
  3550. 1, rcmd, basedev, count);
  3551. }
  3552. /* Locate record for standard blocks ? */
  3553. if (private->uses_cdl && recid == 2*blk_per_trk) {
  3554. ccw[-1].flags |= CCW_FLAG_CC;
  3555. locate_record(ccw++, LO_data++,
  3556. trkid, recoffs + 1,
  3557. last_rec - recid + 1,
  3558. cmd, basedev, count);
  3559. }
  3560. /* Read/write ccw. */
  3561. ccw[-1].flags |= CCW_FLAG_CC;
  3562. ccw->cmd_code = rcmd;
  3563. ccw->count = count;
  3564. if (idal_is_needed(dst, blksize)) {
  3565. ccw->cda = (__u32)(addr_t) idaws;
  3566. ccw->flags = CCW_FLAG_IDA;
  3567. idaws = idal_create_words(idaws, dst, blksize);
  3568. } else {
  3569. ccw->cda = (__u32)(addr_t) dst;
  3570. ccw->flags = 0;
  3571. }
  3572. ccw++;
  3573. dst += blksize;
  3574. recid++;
  3575. }
  3576. }
  3577. if (blk_noretry_request(req) ||
  3578. block->base->features & DASD_FEATURE_FAILFAST)
  3579. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
  3580. cqr->startdev = startdev;
  3581. cqr->memdev = startdev;
  3582. cqr->block = block;
  3583. cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */
  3584. cqr->lpm = dasd_path_get_ppm(startdev);
  3585. cqr->retries = startdev->default_retries;
  3586. cqr->buildclk = get_tod_clock();
  3587. cqr->status = DASD_CQR_FILLED;
  3588. /* Set flags to suppress output for expected errors */
  3589. if (dasd_eckd_is_ese(basedev)) {
  3590. set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags);
  3591. set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags);
  3592. set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
  3593. }
  3594. return cqr;
  3595. }
  3596. static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_track(
  3597. struct dasd_device *startdev,
  3598. struct dasd_block *block,
  3599. struct request *req,
  3600. sector_t first_rec,
  3601. sector_t last_rec,
  3602. sector_t first_trk,
  3603. sector_t last_trk,
  3604. unsigned int first_offs,
  3605. unsigned int last_offs,
  3606. unsigned int blk_per_trk,
  3607. unsigned int blksize)
  3608. {
  3609. unsigned long *idaws;
  3610. struct dasd_ccw_req *cqr;
  3611. struct ccw1 *ccw;
  3612. struct req_iterator iter;
  3613. struct bio_vec bv;
  3614. char *dst, *idaw_dst;
  3615. unsigned int cidaw, cplength, datasize;
  3616. unsigned int tlf;
  3617. sector_t recid;
  3618. unsigned char cmd;
  3619. struct dasd_device *basedev;
  3620. unsigned int trkcount, count, count_to_trk_end;
  3621. unsigned int idaw_len, seg_len, part_len, len_to_track_end;
  3622. unsigned char new_track, end_idaw;
  3623. sector_t trkid;
  3624. unsigned int recoffs;
  3625. basedev = block->base;
  3626. if (rq_data_dir(req) == READ)
  3627. cmd = DASD_ECKD_CCW_READ_TRACK_DATA;
  3628. else if (rq_data_dir(req) == WRITE)
  3629. cmd = DASD_ECKD_CCW_WRITE_TRACK_DATA;
  3630. else
  3631. return ERR_PTR(-EINVAL);
  3632. /* Track based I/O needs IDAWs for each page, and not just for
  3633. * 64 bit addresses. We need additional idals for pages
  3634. * that get filled from two tracks, so we use the number
  3635. * of records as upper limit.
  3636. */
  3637. cidaw = last_rec - first_rec + 1;
  3638. trkcount = last_trk - first_trk + 1;
  3639. /* 1x prefix + one read/write ccw per track */
  3640. cplength = 1 + trkcount;
  3641. datasize = sizeof(struct PFX_eckd_data) + cidaw * sizeof(unsigned long);
  3642. /* Allocate the ccw request. */
  3643. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize,
  3644. startdev, blk_mq_rq_to_pdu(req));
  3645. if (IS_ERR(cqr))
  3646. return cqr;
  3647. ccw = cqr->cpaddr;
  3648. /* transfer length factor: how many bytes to read from the last track */
  3649. if (first_trk == last_trk)
  3650. tlf = last_offs - first_offs + 1;
  3651. else
  3652. tlf = last_offs + 1;
  3653. tlf *= blksize;
  3654. if (prefix_LRE(ccw++, cqr->data, first_trk,
  3655. last_trk, cmd, basedev, startdev,
  3656. 1 /* format */, first_offs + 1,
  3657. trkcount, blksize,
  3658. tlf) == -EAGAIN) {
  3659. /* Clock not in sync and XRC is enabled.
  3660. * Try again later.
  3661. */
  3662. dasd_sfree_request(cqr, startdev);
  3663. return ERR_PTR(-EAGAIN);
  3664. }
  3665. /*
  3666. * The translation of request into ccw programs must meet the
  3667. * following conditions:
  3668. * - all idaws but the first and the last must address full pages
  3669. * (or 2K blocks on 31-bit)
  3670. * - the scope of a ccw and it's idal ends with the track boundaries
  3671. */
  3672. idaws = (unsigned long *) (cqr->data + sizeof(struct PFX_eckd_data));
  3673. recid = first_rec;
  3674. new_track = 1;
  3675. end_idaw = 0;
  3676. len_to_track_end = 0;
  3677. idaw_dst = NULL;
  3678. idaw_len = 0;
  3679. rq_for_each_segment(bv, req, iter) {
  3680. dst = page_address(bv.bv_page) + bv.bv_offset;
  3681. seg_len = bv.bv_len;
  3682. while (seg_len) {
  3683. if (new_track) {
  3684. trkid = recid;
  3685. recoffs = sector_div(trkid, blk_per_trk);
  3686. count_to_trk_end = blk_per_trk - recoffs;
  3687. count = min((last_rec - recid + 1),
  3688. (sector_t)count_to_trk_end);
  3689. len_to_track_end = count * blksize;
  3690. ccw[-1].flags |= CCW_FLAG_CC;
  3691. ccw->cmd_code = cmd;
  3692. ccw->count = len_to_track_end;
  3693. ccw->cda = (__u32)(addr_t)idaws;
  3694. ccw->flags = CCW_FLAG_IDA;
  3695. ccw++;
  3696. recid += count;
  3697. new_track = 0;
  3698. /* first idaw for a ccw may start anywhere */
  3699. if (!idaw_dst)
  3700. idaw_dst = dst;
  3701. }
  3702. /* If we start a new idaw, we must make sure that it
  3703. * starts on an IDA_BLOCK_SIZE boundary.
  3704. * If we continue an idaw, we must make sure that the
  3705. * current segment begins where the so far accumulated
  3706. * idaw ends
  3707. */
  3708. if (!idaw_dst) {
  3709. if (__pa(dst) & (IDA_BLOCK_SIZE-1)) {
  3710. dasd_sfree_request(cqr, startdev);
  3711. return ERR_PTR(-ERANGE);
  3712. } else
  3713. idaw_dst = dst;
  3714. }
  3715. if ((idaw_dst + idaw_len) != dst) {
  3716. dasd_sfree_request(cqr, startdev);
  3717. return ERR_PTR(-ERANGE);
  3718. }
  3719. part_len = min(seg_len, len_to_track_end);
  3720. seg_len -= part_len;
  3721. dst += part_len;
  3722. idaw_len += part_len;
  3723. len_to_track_end -= part_len;
  3724. /* collected memory area ends on an IDA_BLOCK border,
  3725. * -> create an idaw
  3726. * idal_create_words will handle cases where idaw_len
  3727. * is larger then IDA_BLOCK_SIZE
  3728. */
  3729. if (!(__pa(idaw_dst + idaw_len) & (IDA_BLOCK_SIZE-1)))
  3730. end_idaw = 1;
  3731. /* We also need to end the idaw at track end */
  3732. if (!len_to_track_end) {
  3733. new_track = 1;
  3734. end_idaw = 1;
  3735. }
  3736. if (end_idaw) {
  3737. idaws = idal_create_words(idaws, idaw_dst,
  3738. idaw_len);
  3739. idaw_dst = NULL;
  3740. idaw_len = 0;
  3741. end_idaw = 0;
  3742. }
  3743. }
  3744. }
  3745. if (blk_noretry_request(req) ||
  3746. block->base->features & DASD_FEATURE_FAILFAST)
  3747. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
  3748. cqr->startdev = startdev;
  3749. cqr->memdev = startdev;
  3750. cqr->block = block;
  3751. cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */
  3752. cqr->lpm = dasd_path_get_ppm(startdev);
  3753. cqr->retries = startdev->default_retries;
  3754. cqr->buildclk = get_tod_clock();
  3755. cqr->status = DASD_CQR_FILLED;
  3756. /* Set flags to suppress output for expected errors */
  3757. if (dasd_eckd_is_ese(basedev))
  3758. set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
  3759. return cqr;
  3760. }
  3761. static int prepare_itcw(struct itcw *itcw,
  3762. unsigned int trk, unsigned int totrk, int cmd,
  3763. struct dasd_device *basedev,
  3764. struct dasd_device *startdev,
  3765. unsigned int rec_on_trk, int count,
  3766. unsigned int blksize,
  3767. unsigned int total_data_size,
  3768. unsigned int tlf,
  3769. unsigned int blk_per_trk)
  3770. {
  3771. struct PFX_eckd_data pfxdata;
  3772. struct dasd_eckd_private *basepriv, *startpriv;
  3773. struct DE_eckd_data *dedata;
  3774. struct LRE_eckd_data *lredata;
  3775. struct dcw *dcw;
  3776. u32 begcyl, endcyl;
  3777. u16 heads, beghead, endhead;
  3778. u8 pfx_cmd;
  3779. int rc = 0;
  3780. int sector = 0;
  3781. int dn, d;
  3782. /* setup prefix data */
  3783. basepriv = basedev->private;
  3784. startpriv = startdev->private;
  3785. dedata = &pfxdata.define_extent;
  3786. lredata = &pfxdata.locate_record;
  3787. memset(&pfxdata, 0, sizeof(pfxdata));
  3788. pfxdata.format = 1; /* PFX with LRE */
  3789. pfxdata.base_address = basepriv->ned->unit_addr;
  3790. pfxdata.base_lss = basepriv->ned->ID;
  3791. pfxdata.validity.define_extent = 1;
  3792. /* private uid is kept up to date, conf_data may be outdated */
  3793. if (startpriv->uid.type == UA_BASE_PAV_ALIAS)
  3794. pfxdata.validity.verify_base = 1;
  3795. if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) {
  3796. pfxdata.validity.verify_base = 1;
  3797. pfxdata.validity.hyper_pav = 1;
  3798. }
  3799. switch (cmd) {
  3800. case DASD_ECKD_CCW_READ_TRACK_DATA:
  3801. dedata->mask.perm = 0x1;
  3802. dedata->attributes.operation = basepriv->attrib.operation;
  3803. dedata->blk_size = blksize;
  3804. dedata->ga_extended |= 0x42;
  3805. lredata->operation.orientation = 0x0;
  3806. lredata->operation.operation = 0x0C;
  3807. lredata->auxiliary.check_bytes = 0x01;
  3808. pfx_cmd = DASD_ECKD_CCW_PFX_READ;
  3809. break;
  3810. case DASD_ECKD_CCW_WRITE_TRACK_DATA:
  3811. dedata->mask.perm = 0x02;
  3812. dedata->attributes.operation = basepriv->attrib.operation;
  3813. dedata->blk_size = blksize;
  3814. rc = set_timestamp(NULL, dedata, basedev);
  3815. dedata->ga_extended |= 0x42;
  3816. lredata->operation.orientation = 0x0;
  3817. lredata->operation.operation = 0x3F;
  3818. lredata->extended_operation = 0x23;
  3819. lredata->auxiliary.check_bytes = 0x2;
  3820. /*
  3821. * If XRC is supported the System Time Stamp is set. The
  3822. * validity of the time stamp must be reflected in the prefix
  3823. * data as well.
  3824. */
  3825. if (dedata->ga_extended & 0x08 && dedata->ga_extended & 0x02)
  3826. pfxdata.validity.time_stamp = 1; /* 'Time Stamp Valid' */
  3827. pfx_cmd = DASD_ECKD_CCW_PFX;
  3828. break;
  3829. case DASD_ECKD_CCW_READ_COUNT_MT:
  3830. dedata->mask.perm = 0x1;
  3831. dedata->attributes.operation = DASD_BYPASS_CACHE;
  3832. dedata->ga_extended |= 0x42;
  3833. dedata->blk_size = blksize;
  3834. lredata->operation.orientation = 0x2;
  3835. lredata->operation.operation = 0x16;
  3836. lredata->auxiliary.check_bytes = 0x01;
  3837. pfx_cmd = DASD_ECKD_CCW_PFX_READ;
  3838. break;
  3839. default:
  3840. DBF_DEV_EVENT(DBF_ERR, basedev,
  3841. "prepare itcw, unknown opcode 0x%x", cmd);
  3842. BUG();
  3843. break;
  3844. }
  3845. if (rc)
  3846. return rc;
  3847. dedata->attributes.mode = 0x3; /* ECKD */
  3848. heads = basepriv->rdc_data.trk_per_cyl;
  3849. begcyl = trk / heads;
  3850. beghead = trk % heads;
  3851. endcyl = totrk / heads;
  3852. endhead = totrk % heads;
  3853. /* check for sequential prestage - enhance cylinder range */
  3854. if (dedata->attributes.operation == DASD_SEQ_PRESTAGE ||
  3855. dedata->attributes.operation == DASD_SEQ_ACCESS) {
  3856. if (endcyl + basepriv->attrib.nr_cyl < basepriv->real_cyl)
  3857. endcyl += basepriv->attrib.nr_cyl;
  3858. else
  3859. endcyl = (basepriv->real_cyl - 1);
  3860. }
  3861. set_ch_t(&dedata->beg_ext, begcyl, beghead);
  3862. set_ch_t(&dedata->end_ext, endcyl, endhead);
  3863. dedata->ep_format = 0x20; /* records per track is valid */
  3864. dedata->ep_rec_per_track = blk_per_trk;
  3865. if (rec_on_trk) {
  3866. switch (basepriv->rdc_data.dev_type) {
  3867. case 0x3390:
  3868. dn = ceil_quot(blksize + 6, 232);
  3869. d = 9 + ceil_quot(blksize + 6 * (dn + 1), 34);
  3870. sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8;
  3871. break;
  3872. case 0x3380:
  3873. d = 7 + ceil_quot(blksize + 12, 32);
  3874. sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7;
  3875. break;
  3876. }
  3877. }
  3878. if (cmd == DASD_ECKD_CCW_READ_COUNT_MT) {
  3879. lredata->auxiliary.length_valid = 0;
  3880. lredata->auxiliary.length_scope = 0;
  3881. lredata->sector = 0xff;
  3882. } else {
  3883. lredata->auxiliary.length_valid = 1;
  3884. lredata->auxiliary.length_scope = 1;
  3885. lredata->sector = sector;
  3886. }
  3887. lredata->auxiliary.imbedded_ccw_valid = 1;
  3888. lredata->length = tlf;
  3889. lredata->imbedded_ccw = cmd;
  3890. lredata->count = count;
  3891. set_ch_t(&lredata->seek_addr, begcyl, beghead);
  3892. lredata->search_arg.cyl = lredata->seek_addr.cyl;
  3893. lredata->search_arg.head = lredata->seek_addr.head;
  3894. lredata->search_arg.record = rec_on_trk;
  3895. dcw = itcw_add_dcw(itcw, pfx_cmd, 0,
  3896. &pfxdata, sizeof(pfxdata), total_data_size);
  3897. return PTR_ERR_OR_ZERO(dcw);
  3898. }
  3899. static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track(
  3900. struct dasd_device *startdev,
  3901. struct dasd_block *block,
  3902. struct request *req,
  3903. sector_t first_rec,
  3904. sector_t last_rec,
  3905. sector_t first_trk,
  3906. sector_t last_trk,
  3907. unsigned int first_offs,
  3908. unsigned int last_offs,
  3909. unsigned int blk_per_trk,
  3910. unsigned int blksize)
  3911. {
  3912. struct dasd_ccw_req *cqr;
  3913. struct req_iterator iter;
  3914. struct bio_vec bv;
  3915. char *dst;
  3916. unsigned int trkcount, ctidaw;
  3917. unsigned char cmd;
  3918. struct dasd_device *basedev;
  3919. unsigned int tlf;
  3920. struct itcw *itcw;
  3921. struct tidaw *last_tidaw = NULL;
  3922. int itcw_op;
  3923. size_t itcw_size;
  3924. u8 tidaw_flags;
  3925. unsigned int seg_len, part_len, len_to_track_end;
  3926. unsigned char new_track;
  3927. sector_t recid, trkid;
  3928. unsigned int offs;
  3929. unsigned int count, count_to_trk_end;
  3930. int ret;
  3931. basedev = block->base;
  3932. if (rq_data_dir(req) == READ) {
  3933. cmd = DASD_ECKD_CCW_READ_TRACK_DATA;
  3934. itcw_op = ITCW_OP_READ;
  3935. } else if (rq_data_dir(req) == WRITE) {
  3936. cmd = DASD_ECKD_CCW_WRITE_TRACK_DATA;
  3937. itcw_op = ITCW_OP_WRITE;
  3938. } else
  3939. return ERR_PTR(-EINVAL);
  3940. /* trackbased I/O needs address all memory via TIDAWs,
  3941. * not just for 64 bit addresses. This allows us to map
  3942. * each segment directly to one tidaw.
  3943. * In the case of write requests, additional tidaws may
  3944. * be needed when a segment crosses a track boundary.
  3945. */
  3946. trkcount = last_trk - first_trk + 1;
  3947. ctidaw = 0;
  3948. rq_for_each_segment(bv, req, iter) {
  3949. ++ctidaw;
  3950. }
  3951. if (rq_data_dir(req) == WRITE)
  3952. ctidaw += (last_trk - first_trk);
  3953. /* Allocate the ccw request. */
  3954. itcw_size = itcw_calc_size(0, ctidaw, 0);
  3955. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev,
  3956. blk_mq_rq_to_pdu(req));
  3957. if (IS_ERR(cqr))
  3958. return cqr;
  3959. /* transfer length factor: how many bytes to read from the last track */
  3960. if (first_trk == last_trk)
  3961. tlf = last_offs - first_offs + 1;
  3962. else
  3963. tlf = last_offs + 1;
  3964. tlf *= blksize;
  3965. itcw = itcw_init(cqr->data, itcw_size, itcw_op, 0, ctidaw, 0);
  3966. if (IS_ERR(itcw)) {
  3967. ret = -EINVAL;
  3968. goto out_error;
  3969. }
  3970. cqr->cpaddr = itcw_get_tcw(itcw);
  3971. if (prepare_itcw(itcw, first_trk, last_trk,
  3972. cmd, basedev, startdev,
  3973. first_offs + 1,
  3974. trkcount, blksize,
  3975. (last_rec - first_rec + 1) * blksize,
  3976. tlf, blk_per_trk) == -EAGAIN) {
  3977. /* Clock not in sync and XRC is enabled.
  3978. * Try again later.
  3979. */
  3980. ret = -EAGAIN;
  3981. goto out_error;
  3982. }
  3983. len_to_track_end = 0;
  3984. /*
  3985. * A tidaw can address 4k of memory, but must not cross page boundaries
  3986. * We can let the block layer handle this by setting
  3987. * blk_queue_segment_boundary to page boundaries and
  3988. * blk_max_segment_size to page size when setting up the request queue.
  3989. * For write requests, a TIDAW must not cross track boundaries, because
  3990. * we have to set the CBC flag on the last tidaw for each track.
  3991. */
  3992. if (rq_data_dir(req) == WRITE) {
  3993. new_track = 1;
  3994. recid = first_rec;
  3995. rq_for_each_segment(bv, req, iter) {
  3996. dst = page_address(bv.bv_page) + bv.bv_offset;
  3997. seg_len = bv.bv_len;
  3998. while (seg_len) {
  3999. if (new_track) {
  4000. trkid = recid;
  4001. offs = sector_div(trkid, blk_per_trk);
  4002. count_to_trk_end = blk_per_trk - offs;
  4003. count = min((last_rec - recid + 1),
  4004. (sector_t)count_to_trk_end);
  4005. len_to_track_end = count * blksize;
  4006. recid += count;
  4007. new_track = 0;
  4008. }
  4009. part_len = min(seg_len, len_to_track_end);
  4010. seg_len -= part_len;
  4011. len_to_track_end -= part_len;
  4012. /* We need to end the tidaw at track end */
  4013. if (!len_to_track_end) {
  4014. new_track = 1;
  4015. tidaw_flags = TIDAW_FLAGS_INSERT_CBC;
  4016. } else
  4017. tidaw_flags = 0;
  4018. last_tidaw = itcw_add_tidaw(itcw, tidaw_flags,
  4019. dst, part_len);
  4020. if (IS_ERR(last_tidaw)) {
  4021. ret = -EINVAL;
  4022. goto out_error;
  4023. }
  4024. dst += part_len;
  4025. }
  4026. }
  4027. } else {
  4028. rq_for_each_segment(bv, req, iter) {
  4029. dst = page_address(bv.bv_page) + bv.bv_offset;
  4030. last_tidaw = itcw_add_tidaw(itcw, 0x00,
  4031. dst, bv.bv_len);
  4032. if (IS_ERR(last_tidaw)) {
  4033. ret = -EINVAL;
  4034. goto out_error;
  4035. }
  4036. }
  4037. }
  4038. last_tidaw->flags |= TIDAW_FLAGS_LAST;
  4039. last_tidaw->flags &= ~TIDAW_FLAGS_INSERT_CBC;
  4040. itcw_finalize(itcw);
  4041. if (blk_noretry_request(req) ||
  4042. block->base->features & DASD_FEATURE_FAILFAST)
  4043. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
  4044. cqr->cpmode = 1;
  4045. cqr->startdev = startdev;
  4046. cqr->memdev = startdev;
  4047. cqr->block = block;
  4048. cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */
  4049. cqr->lpm = dasd_path_get_ppm(startdev);
  4050. cqr->retries = startdev->default_retries;
  4051. cqr->buildclk = get_tod_clock();
  4052. cqr->status = DASD_CQR_FILLED;
  4053. /* Set flags to suppress output for expected errors */
  4054. if (dasd_eckd_is_ese(basedev)) {
  4055. set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags);
  4056. set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags);
  4057. set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
  4058. }
  4059. return cqr;
  4060. out_error:
  4061. dasd_sfree_request(cqr, startdev);
  4062. return ERR_PTR(ret);
  4063. }
  4064. static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
  4065. struct dasd_block *block,
  4066. struct request *req)
  4067. {
  4068. int cmdrtd, cmdwtd;
  4069. int use_prefix;
  4070. int fcx_multitrack;
  4071. struct dasd_eckd_private *private;
  4072. struct dasd_device *basedev;
  4073. sector_t first_rec, last_rec;
  4074. sector_t first_trk, last_trk;
  4075. unsigned int first_offs, last_offs;
  4076. unsigned int blk_per_trk, blksize;
  4077. int cdlspecial;
  4078. unsigned int data_size;
  4079. struct dasd_ccw_req *cqr;
  4080. basedev = block->base;
  4081. private = basedev->private;
  4082. /* Calculate number of blocks/records per track. */
  4083. blksize = block->bp_block;
  4084. blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
  4085. if (blk_per_trk == 0)
  4086. return ERR_PTR(-EINVAL);
  4087. /* Calculate record id of first and last block. */
  4088. first_rec = first_trk = blk_rq_pos(req) >> block->s2b_shift;
  4089. first_offs = sector_div(first_trk, blk_per_trk);
  4090. last_rec = last_trk =
  4091. (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
  4092. last_offs = sector_div(last_trk, blk_per_trk);
  4093. cdlspecial = (private->uses_cdl && first_rec < 2*blk_per_trk);
  4094. fcx_multitrack = private->features.feature[40] & 0x20;
  4095. data_size = blk_rq_bytes(req);
  4096. if (data_size % blksize)
  4097. return ERR_PTR(-EINVAL);
  4098. /* tpm write request add CBC data on each track boundary */
  4099. if (rq_data_dir(req) == WRITE)
  4100. data_size += (last_trk - first_trk) * 4;
  4101. /* is read track data and write track data in command mode supported? */
  4102. cmdrtd = private->features.feature[9] & 0x20;
  4103. cmdwtd = private->features.feature[12] & 0x40;
  4104. use_prefix = private->features.feature[8] & 0x01;
  4105. cqr = NULL;
  4106. if (cdlspecial || dasd_page_cache) {
  4107. /* do nothing, just fall through to the cmd mode single case */
  4108. } else if ((data_size <= private->fcx_max_data)
  4109. && (fcx_multitrack || (first_trk == last_trk))) {
  4110. cqr = dasd_eckd_build_cp_tpm_track(startdev, block, req,
  4111. first_rec, last_rec,
  4112. first_trk, last_trk,
  4113. first_offs, last_offs,
  4114. blk_per_trk, blksize);
  4115. if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) &&
  4116. (PTR_ERR(cqr) != -ENOMEM))
  4117. cqr = NULL;
  4118. } else if (use_prefix &&
  4119. (((rq_data_dir(req) == READ) && cmdrtd) ||
  4120. ((rq_data_dir(req) == WRITE) && cmdwtd))) {
  4121. cqr = dasd_eckd_build_cp_cmd_track(startdev, block, req,
  4122. first_rec, last_rec,
  4123. first_trk, last_trk,
  4124. first_offs, last_offs,
  4125. blk_per_trk, blksize);
  4126. if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) &&
  4127. (PTR_ERR(cqr) != -ENOMEM))
  4128. cqr = NULL;
  4129. }
  4130. if (!cqr)
  4131. cqr = dasd_eckd_build_cp_cmd_single(startdev, block, req,
  4132. first_rec, last_rec,
  4133. first_trk, last_trk,
  4134. first_offs, last_offs,
  4135. blk_per_trk, blksize);
  4136. return cqr;
  4137. }
  4138. static struct dasd_ccw_req *dasd_eckd_build_cp_raw(struct dasd_device *startdev,
  4139. struct dasd_block *block,
  4140. struct request *req)
  4141. {
  4142. sector_t start_padding_sectors, end_sector_offset, end_padding_sectors;
  4143. unsigned int seg_len, len_to_track_end;
  4144. unsigned int cidaw, cplength, datasize;
  4145. sector_t first_trk, last_trk, sectors;
  4146. struct dasd_eckd_private *base_priv;
  4147. struct dasd_device *basedev;
  4148. struct req_iterator iter;
  4149. struct dasd_ccw_req *cqr;
  4150. unsigned int first_offs;
  4151. unsigned int trkcount;
  4152. unsigned long *idaws;
  4153. unsigned int size;
  4154. unsigned char cmd;
  4155. struct bio_vec bv;
  4156. struct ccw1 *ccw;
  4157. int use_prefix;
  4158. void *data;
  4159. char *dst;
  4160. /*
  4161. * raw track access needs to be mutiple of 64k and on 64k boundary
  4162. * For read requests we can fix an incorrect alignment by padding
  4163. * the request with dummy pages.
  4164. */
  4165. start_padding_sectors = blk_rq_pos(req) % DASD_RAW_SECTORS_PER_TRACK;
  4166. end_sector_offset = (blk_rq_pos(req) + blk_rq_sectors(req)) %
  4167. DASD_RAW_SECTORS_PER_TRACK;
  4168. end_padding_sectors = (DASD_RAW_SECTORS_PER_TRACK - end_sector_offset) %
  4169. DASD_RAW_SECTORS_PER_TRACK;
  4170. basedev = block->base;
  4171. if ((start_padding_sectors || end_padding_sectors) &&
  4172. (rq_data_dir(req) == WRITE)) {
  4173. DBF_DEV_EVENT(DBF_ERR, basedev,
  4174. "raw write not track aligned (%llu,%llu) req %p",
  4175. start_padding_sectors, end_padding_sectors, req);
  4176. return ERR_PTR(-EINVAL);
  4177. }
  4178. first_trk = blk_rq_pos(req) / DASD_RAW_SECTORS_PER_TRACK;
  4179. last_trk = (blk_rq_pos(req) + blk_rq_sectors(req) - 1) /
  4180. DASD_RAW_SECTORS_PER_TRACK;
  4181. trkcount = last_trk - first_trk + 1;
  4182. first_offs = 0;
  4183. if (rq_data_dir(req) == READ)
  4184. cmd = DASD_ECKD_CCW_READ_TRACK;
  4185. else if (rq_data_dir(req) == WRITE)
  4186. cmd = DASD_ECKD_CCW_WRITE_FULL_TRACK;
  4187. else
  4188. return ERR_PTR(-EINVAL);
  4189. /*
  4190. * Raw track based I/O needs IDAWs for each page,
  4191. * and not just for 64 bit addresses.
  4192. */
  4193. cidaw = trkcount * DASD_RAW_BLOCK_PER_TRACK;
  4194. /*
  4195. * struct PFX_eckd_data and struct LRE_eckd_data can have up to 2 bytes
  4196. * of extended parameter. This is needed for write full track.
  4197. */
  4198. base_priv = basedev->private;
  4199. use_prefix = base_priv->features.feature[8] & 0x01;
  4200. if (use_prefix) {
  4201. cplength = 1 + trkcount;
  4202. size = sizeof(struct PFX_eckd_data) + 2;
  4203. } else {
  4204. cplength = 2 + trkcount;
  4205. size = sizeof(struct DE_eckd_data) +
  4206. sizeof(struct LRE_eckd_data) + 2;
  4207. }
  4208. size = ALIGN(size, 8);
  4209. datasize = size + cidaw * sizeof(unsigned long);
  4210. /* Allocate the ccw request. */
  4211. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength,
  4212. datasize, startdev, blk_mq_rq_to_pdu(req));
  4213. if (IS_ERR(cqr))
  4214. return cqr;
  4215. ccw = cqr->cpaddr;
  4216. data = cqr->data;
  4217. if (use_prefix) {
  4218. prefix_LRE(ccw++, data, first_trk, last_trk, cmd, basedev,
  4219. startdev, 1, first_offs + 1, trkcount, 0, 0);
  4220. } else {
  4221. define_extent(ccw++, data, first_trk, last_trk, cmd, basedev, 0);
  4222. ccw[-1].flags |= CCW_FLAG_CC;
  4223. data += sizeof(struct DE_eckd_data);
  4224. locate_record_ext(ccw++, data, first_trk, first_offs + 1,
  4225. trkcount, cmd, basedev, 0, 0);
  4226. }
  4227. idaws = (unsigned long *)(cqr->data + size);
  4228. len_to_track_end = 0;
  4229. if (start_padding_sectors) {
  4230. ccw[-1].flags |= CCW_FLAG_CC;
  4231. ccw->cmd_code = cmd;
  4232. /* maximum 3390 track size */
  4233. ccw->count = 57326;
  4234. /* 64k map to one track */
  4235. len_to_track_end = 65536 - start_padding_sectors * 512;
  4236. ccw->cda = (__u32)(addr_t)idaws;
  4237. ccw->flags |= CCW_FLAG_IDA;
  4238. ccw->flags |= CCW_FLAG_SLI;
  4239. ccw++;
  4240. for (sectors = 0; sectors < start_padding_sectors; sectors += 8)
  4241. idaws = idal_create_words(idaws, rawpadpage, PAGE_SIZE);
  4242. }
  4243. rq_for_each_segment(bv, req, iter) {
  4244. dst = page_address(bv.bv_page) + bv.bv_offset;
  4245. seg_len = bv.bv_len;
  4246. if (cmd == DASD_ECKD_CCW_READ_TRACK)
  4247. memset(dst, 0, seg_len);
  4248. if (!len_to_track_end) {
  4249. ccw[-1].flags |= CCW_FLAG_CC;
  4250. ccw->cmd_code = cmd;
  4251. /* maximum 3390 track size */
  4252. ccw->count = 57326;
  4253. /* 64k map to one track */
  4254. len_to_track_end = 65536;
  4255. ccw->cda = (__u32)(addr_t)idaws;
  4256. ccw->flags |= CCW_FLAG_IDA;
  4257. ccw->flags |= CCW_FLAG_SLI;
  4258. ccw++;
  4259. }
  4260. len_to_track_end -= seg_len;
  4261. idaws = idal_create_words(idaws, dst, seg_len);
  4262. }
  4263. for (sectors = 0; sectors < end_padding_sectors; sectors += 8)
  4264. idaws = idal_create_words(idaws, rawpadpage, PAGE_SIZE);
  4265. if (blk_noretry_request(req) ||
  4266. block->base->features & DASD_FEATURE_FAILFAST)
  4267. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
  4268. cqr->startdev = startdev;
  4269. cqr->memdev = startdev;
  4270. cqr->block = block;
  4271. cqr->expires = startdev->default_expires * HZ;
  4272. cqr->lpm = dasd_path_get_ppm(startdev);
  4273. cqr->retries = startdev->default_retries;
  4274. cqr->buildclk = get_tod_clock();
  4275. cqr->status = DASD_CQR_FILLED;
  4276. return cqr;
  4277. }
  4278. static int
  4279. dasd_eckd_free_cp(struct dasd_ccw_req *cqr, struct request *req)
  4280. {
  4281. struct dasd_eckd_private *private;
  4282. struct ccw1 *ccw;
  4283. struct req_iterator iter;
  4284. struct bio_vec bv;
  4285. char *dst, *cda;
  4286. unsigned int blksize, blk_per_trk, off;
  4287. sector_t recid;
  4288. int status;
  4289. if (!dasd_page_cache)
  4290. goto out;
  4291. private = cqr->block->base->private;
  4292. blksize = cqr->block->bp_block;
  4293. blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
  4294. recid = blk_rq_pos(req) >> cqr->block->s2b_shift;
  4295. ccw = cqr->cpaddr;
  4296. /* Skip over define extent & locate record. */
  4297. ccw++;
  4298. if (private->uses_cdl == 0 || recid > 2*blk_per_trk)
  4299. ccw++;
  4300. rq_for_each_segment(bv, req, iter) {
  4301. dst = page_address(bv.bv_page) + bv.bv_offset;
  4302. for (off = 0; off < bv.bv_len; off += blksize) {
  4303. /* Skip locate record. */
  4304. if (private->uses_cdl && recid <= 2*blk_per_trk)
  4305. ccw++;
  4306. if (dst) {
  4307. if (ccw->flags & CCW_FLAG_IDA)
  4308. cda = *((char **)((addr_t) ccw->cda));
  4309. else
  4310. cda = (char *)((addr_t) ccw->cda);
  4311. if (dst != cda) {
  4312. if (rq_data_dir(req) == READ)
  4313. memcpy(dst, cda, bv.bv_len);
  4314. kmem_cache_free(dasd_page_cache,
  4315. (void *)((addr_t)cda & PAGE_MASK));
  4316. }
  4317. dst = NULL;
  4318. }
  4319. ccw++;
  4320. recid++;
  4321. }
  4322. }
  4323. out:
  4324. status = cqr->status == DASD_CQR_DONE;
  4325. dasd_sfree_request(cqr, cqr->memdev);
  4326. return status;
  4327. }
  4328. /*
  4329. * Modify ccw/tcw in cqr so it can be started on a base device.
  4330. *
  4331. * Note that this is not enough to restart the cqr!
  4332. * Either reset cqr->startdev as well (summary unit check handling)
  4333. * or restart via separate cqr (as in ERP handling).
  4334. */
  4335. void dasd_eckd_reset_ccw_to_base_io(struct dasd_ccw_req *cqr)
  4336. {
  4337. struct ccw1 *ccw;
  4338. struct PFX_eckd_data *pfxdata;
  4339. struct tcw *tcw;
  4340. struct tccb *tccb;
  4341. struct dcw *dcw;
  4342. if (cqr->cpmode == 1) {
  4343. tcw = cqr->cpaddr;
  4344. tccb = tcw_get_tccb(tcw);
  4345. dcw = (struct dcw *)&tccb->tca[0];
  4346. pfxdata = (struct PFX_eckd_data *)&dcw->cd[0];
  4347. pfxdata->validity.verify_base = 0;
  4348. pfxdata->validity.hyper_pav = 0;
  4349. } else {
  4350. ccw = cqr->cpaddr;
  4351. pfxdata = cqr->data;
  4352. if (ccw->cmd_code == DASD_ECKD_CCW_PFX) {
  4353. pfxdata->validity.verify_base = 0;
  4354. pfxdata->validity.hyper_pav = 0;
  4355. }
  4356. }
  4357. }
  4358. #define DASD_ECKD_CHANQ_MAX_SIZE 4
  4359. static struct dasd_ccw_req *dasd_eckd_build_alias_cp(struct dasd_device *base,
  4360. struct dasd_block *block,
  4361. struct request *req)
  4362. {
  4363. struct dasd_eckd_private *private;
  4364. struct dasd_device *startdev;
  4365. unsigned long flags;
  4366. struct dasd_ccw_req *cqr;
  4367. startdev = dasd_alias_get_start_dev(base);
  4368. if (!startdev)
  4369. startdev = base;
  4370. private = startdev->private;
  4371. if (private->count >= DASD_ECKD_CHANQ_MAX_SIZE)
  4372. return ERR_PTR(-EBUSY);
  4373. spin_lock_irqsave(get_ccwdev_lock(startdev->cdev), flags);
  4374. private->count++;
  4375. if ((base->features & DASD_FEATURE_USERAW))
  4376. cqr = dasd_eckd_build_cp_raw(startdev, block, req);
  4377. else
  4378. cqr = dasd_eckd_build_cp(startdev, block, req);
  4379. if (IS_ERR(cqr))
  4380. private->count--;
  4381. spin_unlock_irqrestore(get_ccwdev_lock(startdev->cdev), flags);
  4382. return cqr;
  4383. }
  4384. static int dasd_eckd_free_alias_cp(struct dasd_ccw_req *cqr,
  4385. struct request *req)
  4386. {
  4387. struct dasd_eckd_private *private;
  4388. unsigned long flags;
  4389. spin_lock_irqsave(get_ccwdev_lock(cqr->memdev->cdev), flags);
  4390. private = cqr->memdev->private;
  4391. private->count--;
  4392. spin_unlock_irqrestore(get_ccwdev_lock(cqr->memdev->cdev), flags);
  4393. return dasd_eckd_free_cp(cqr, req);
  4394. }
  4395. static int
  4396. dasd_eckd_fill_info(struct dasd_device * device,
  4397. struct dasd_information2_t * info)
  4398. {
  4399. struct dasd_eckd_private *private = device->private;
  4400. info->label_block = 2;
  4401. info->FBA_layout = private->uses_cdl ? 0 : 1;
  4402. info->format = private->uses_cdl ? DASD_FORMAT_CDL : DASD_FORMAT_LDL;
  4403. info->characteristics_size = sizeof(private->rdc_data);
  4404. memcpy(info->characteristics, &private->rdc_data,
  4405. sizeof(private->rdc_data));
  4406. info->confdata_size = min((unsigned long)private->conf_len,
  4407. sizeof(info->configuration_data));
  4408. memcpy(info->configuration_data, private->conf_data,
  4409. info->confdata_size);
  4410. return 0;
  4411. }
  4412. /*
  4413. * SECTION: ioctl functions for eckd devices.
  4414. */
  4415. /*
  4416. * Release device ioctl.
  4417. * Buils a channel programm to releases a prior reserved
  4418. * (see dasd_eckd_reserve) device.
  4419. */
  4420. static int
  4421. dasd_eckd_release(struct dasd_device *device)
  4422. {
  4423. struct dasd_ccw_req *cqr;
  4424. int rc;
  4425. struct ccw1 *ccw;
  4426. int useglobal;
  4427. if (!capable(CAP_SYS_ADMIN))
  4428. return -EACCES;
  4429. useglobal = 0;
  4430. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL);
  4431. if (IS_ERR(cqr)) {
  4432. mutex_lock(&dasd_reserve_mutex);
  4433. useglobal = 1;
  4434. cqr = &dasd_reserve_req->cqr;
  4435. memset(cqr, 0, sizeof(*cqr));
  4436. memset(&dasd_reserve_req->ccw, 0,
  4437. sizeof(dasd_reserve_req->ccw));
  4438. cqr->cpaddr = &dasd_reserve_req->ccw;
  4439. cqr->data = &dasd_reserve_req->data;
  4440. cqr->magic = DASD_ECKD_MAGIC;
  4441. }
  4442. ccw = cqr->cpaddr;
  4443. ccw->cmd_code = DASD_ECKD_CCW_RELEASE;
  4444. ccw->flags |= CCW_FLAG_SLI;
  4445. ccw->count = 32;
  4446. ccw->cda = (__u32)(addr_t) cqr->data;
  4447. cqr->startdev = device;
  4448. cqr->memdev = device;
  4449. clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  4450. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
  4451. cqr->retries = 2; /* set retry counter to enable basic ERP */
  4452. cqr->expires = 2 * HZ;
  4453. cqr->buildclk = get_tod_clock();
  4454. cqr->status = DASD_CQR_FILLED;
  4455. rc = dasd_sleep_on_immediatly(cqr);
  4456. if (!rc)
  4457. clear_bit(DASD_FLAG_IS_RESERVED, &device->flags);
  4458. if (useglobal)
  4459. mutex_unlock(&dasd_reserve_mutex);
  4460. else
  4461. dasd_sfree_request(cqr, cqr->memdev);
  4462. return rc;
  4463. }
  4464. /*
  4465. * Reserve device ioctl.
  4466. * Options are set to 'synchronous wait for interrupt' and
  4467. * 'timeout the request'. This leads to a terminate IO if
  4468. * the interrupt is outstanding for a certain time.
  4469. */
  4470. static int
  4471. dasd_eckd_reserve(struct dasd_device *device)
  4472. {
  4473. struct dasd_ccw_req *cqr;
  4474. int rc;
  4475. struct ccw1 *ccw;
  4476. int useglobal;
  4477. if (!capable(CAP_SYS_ADMIN))
  4478. return -EACCES;
  4479. useglobal = 0;
  4480. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL);
  4481. if (IS_ERR(cqr)) {
  4482. mutex_lock(&dasd_reserve_mutex);
  4483. useglobal = 1;
  4484. cqr = &dasd_reserve_req->cqr;
  4485. memset(cqr, 0, sizeof(*cqr));
  4486. memset(&dasd_reserve_req->ccw, 0,
  4487. sizeof(dasd_reserve_req->ccw));
  4488. cqr->cpaddr = &dasd_reserve_req->ccw;
  4489. cqr->data = &dasd_reserve_req->data;
  4490. cqr->magic = DASD_ECKD_MAGIC;
  4491. }
  4492. ccw = cqr->cpaddr;
  4493. ccw->cmd_code = DASD_ECKD_CCW_RESERVE;
  4494. ccw->flags |= CCW_FLAG_SLI;
  4495. ccw->count = 32;
  4496. ccw->cda = (__u32)(addr_t) cqr->data;
  4497. cqr->startdev = device;
  4498. cqr->memdev = device;
  4499. clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  4500. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
  4501. cqr->retries = 2; /* set retry counter to enable basic ERP */
  4502. cqr->expires = 2 * HZ;
  4503. cqr->buildclk = get_tod_clock();
  4504. cqr->status = DASD_CQR_FILLED;
  4505. rc = dasd_sleep_on_immediatly(cqr);
  4506. if (!rc)
  4507. set_bit(DASD_FLAG_IS_RESERVED, &device->flags);
  4508. if (useglobal)
  4509. mutex_unlock(&dasd_reserve_mutex);
  4510. else
  4511. dasd_sfree_request(cqr, cqr->memdev);
  4512. return rc;
  4513. }
  4514. /*
  4515. * Steal lock ioctl - unconditional reserve device.
  4516. * Buils a channel programm to break a device's reservation.
  4517. * (unconditional reserve)
  4518. */
  4519. static int
  4520. dasd_eckd_steal_lock(struct dasd_device *device)
  4521. {
  4522. struct dasd_ccw_req *cqr;
  4523. int rc;
  4524. struct ccw1 *ccw;
  4525. int useglobal;
  4526. if (!capable(CAP_SYS_ADMIN))
  4527. return -EACCES;
  4528. useglobal = 0;
  4529. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL);
  4530. if (IS_ERR(cqr)) {
  4531. mutex_lock(&dasd_reserve_mutex);
  4532. useglobal = 1;
  4533. cqr = &dasd_reserve_req->cqr;
  4534. memset(cqr, 0, sizeof(*cqr));
  4535. memset(&dasd_reserve_req->ccw, 0,
  4536. sizeof(dasd_reserve_req->ccw));
  4537. cqr->cpaddr = &dasd_reserve_req->ccw;
  4538. cqr->data = &dasd_reserve_req->data;
  4539. cqr->magic = DASD_ECKD_MAGIC;
  4540. }
  4541. ccw = cqr->cpaddr;
  4542. ccw->cmd_code = DASD_ECKD_CCW_SLCK;
  4543. ccw->flags |= CCW_FLAG_SLI;
  4544. ccw->count = 32;
  4545. ccw->cda = (__u32)(addr_t) cqr->data;
  4546. cqr->startdev = device;
  4547. cqr->memdev = device;
  4548. clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  4549. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
  4550. cqr->retries = 2; /* set retry counter to enable basic ERP */
  4551. cqr->expires = 2 * HZ;
  4552. cqr->buildclk = get_tod_clock();
  4553. cqr->status = DASD_CQR_FILLED;
  4554. rc = dasd_sleep_on_immediatly(cqr);
  4555. if (!rc)
  4556. set_bit(DASD_FLAG_IS_RESERVED, &device->flags);
  4557. if (useglobal)
  4558. mutex_unlock(&dasd_reserve_mutex);
  4559. else
  4560. dasd_sfree_request(cqr, cqr->memdev);
  4561. return rc;
  4562. }
  4563. /*
  4564. * SNID - Sense Path Group ID
  4565. * This ioctl may be used in situations where I/O is stalled due to
  4566. * a reserve, so if the normal dasd_smalloc_request fails, we use the
  4567. * preallocated dasd_reserve_req.
  4568. */
  4569. static int dasd_eckd_snid(struct dasd_device *device,
  4570. void __user *argp)
  4571. {
  4572. struct dasd_ccw_req *cqr;
  4573. int rc;
  4574. struct ccw1 *ccw;
  4575. int useglobal;
  4576. struct dasd_snid_ioctl_data usrparm;
  4577. if (!capable(CAP_SYS_ADMIN))
  4578. return -EACCES;
  4579. if (copy_from_user(&usrparm, argp, sizeof(usrparm)))
  4580. return -EFAULT;
  4581. useglobal = 0;
  4582. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1,
  4583. sizeof(struct dasd_snid_data), device,
  4584. NULL);
  4585. if (IS_ERR(cqr)) {
  4586. mutex_lock(&dasd_reserve_mutex);
  4587. useglobal = 1;
  4588. cqr = &dasd_reserve_req->cqr;
  4589. memset(cqr, 0, sizeof(*cqr));
  4590. memset(&dasd_reserve_req->ccw, 0,
  4591. sizeof(dasd_reserve_req->ccw));
  4592. cqr->cpaddr = &dasd_reserve_req->ccw;
  4593. cqr->data = &dasd_reserve_req->data;
  4594. cqr->magic = DASD_ECKD_MAGIC;
  4595. }
  4596. ccw = cqr->cpaddr;
  4597. ccw->cmd_code = DASD_ECKD_CCW_SNID;
  4598. ccw->flags |= CCW_FLAG_SLI;
  4599. ccw->count = 12;
  4600. ccw->cda = (__u32)(addr_t) cqr->data;
  4601. cqr->startdev = device;
  4602. cqr->memdev = device;
  4603. clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  4604. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
  4605. set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags);
  4606. cqr->retries = 5;
  4607. cqr->expires = 10 * HZ;
  4608. cqr->buildclk = get_tod_clock();
  4609. cqr->status = DASD_CQR_FILLED;
  4610. cqr->lpm = usrparm.path_mask;
  4611. rc = dasd_sleep_on_immediatly(cqr);
  4612. /* verify that I/O processing didn't modify the path mask */
  4613. if (!rc && usrparm.path_mask && (cqr->lpm != usrparm.path_mask))
  4614. rc = -EIO;
  4615. if (!rc) {
  4616. usrparm.data = *((struct dasd_snid_data *)cqr->data);
  4617. if (copy_to_user(argp, &usrparm, sizeof(usrparm)))
  4618. rc = -EFAULT;
  4619. }
  4620. if (useglobal)
  4621. mutex_unlock(&dasd_reserve_mutex);
  4622. else
  4623. dasd_sfree_request(cqr, cqr->memdev);
  4624. return rc;
  4625. }
  4626. /*
  4627. * Read performance statistics
  4628. */
  4629. static int
  4630. dasd_eckd_performance(struct dasd_device *device, void __user *argp)
  4631. {
  4632. struct dasd_psf_prssd_data *prssdp;
  4633. struct dasd_rssd_perf_stats_t *stats;
  4634. struct dasd_ccw_req *cqr;
  4635. struct ccw1 *ccw;
  4636. int rc;
  4637. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
  4638. (sizeof(struct dasd_psf_prssd_data) +
  4639. sizeof(struct dasd_rssd_perf_stats_t)),
  4640. device, NULL);
  4641. if (IS_ERR(cqr)) {
  4642. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  4643. "Could not allocate initialization request");
  4644. return PTR_ERR(cqr);
  4645. }
  4646. cqr->startdev = device;
  4647. cqr->memdev = device;
  4648. cqr->retries = 0;
  4649. clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  4650. cqr->expires = 10 * HZ;
  4651. /* Prepare for Read Subsystem Data */
  4652. prssdp = (struct dasd_psf_prssd_data *) cqr->data;
  4653. memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
  4654. prssdp->order = PSF_ORDER_PRSSD;
  4655. prssdp->suborder = 0x01; /* Performance Statistics */
  4656. prssdp->varies[1] = 0x01; /* Perf Statistics for the Subsystem */
  4657. ccw = cqr->cpaddr;
  4658. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  4659. ccw->count = sizeof(struct dasd_psf_prssd_data);
  4660. ccw->flags |= CCW_FLAG_CC;
  4661. ccw->cda = (__u32)(addr_t) prssdp;
  4662. /* Read Subsystem Data - Performance Statistics */
  4663. stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1);
  4664. memset(stats, 0, sizeof(struct dasd_rssd_perf_stats_t));
  4665. ccw++;
  4666. ccw->cmd_code = DASD_ECKD_CCW_RSSD;
  4667. ccw->count = sizeof(struct dasd_rssd_perf_stats_t);
  4668. ccw->cda = (__u32)(addr_t) stats;
  4669. cqr->buildclk = get_tod_clock();
  4670. cqr->status = DASD_CQR_FILLED;
  4671. rc = dasd_sleep_on(cqr);
  4672. if (rc == 0) {
  4673. prssdp = (struct dasd_psf_prssd_data *) cqr->data;
  4674. stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1);
  4675. if (copy_to_user(argp, stats,
  4676. sizeof(struct dasd_rssd_perf_stats_t)))
  4677. rc = -EFAULT;
  4678. }
  4679. dasd_sfree_request(cqr, cqr->memdev);
  4680. return rc;
  4681. }
  4682. /*
  4683. * Get attributes (cache operations)
  4684. * Returnes the cache attributes used in Define Extend (DE).
  4685. */
  4686. static int
  4687. dasd_eckd_get_attrib(struct dasd_device *device, void __user *argp)
  4688. {
  4689. struct dasd_eckd_private *private = device->private;
  4690. struct attrib_data_t attrib = private->attrib;
  4691. int rc;
  4692. if (!capable(CAP_SYS_ADMIN))
  4693. return -EACCES;
  4694. if (!argp)
  4695. return -EINVAL;
  4696. rc = 0;
  4697. if (copy_to_user(argp, (long *) &attrib,
  4698. sizeof(struct attrib_data_t)))
  4699. rc = -EFAULT;
  4700. return rc;
  4701. }
  4702. /*
  4703. * Set attributes (cache operations)
  4704. * Stores the attributes for cache operation to be used in Define Extend (DE).
  4705. */
  4706. static int
  4707. dasd_eckd_set_attrib(struct dasd_device *device, void __user *argp)
  4708. {
  4709. struct dasd_eckd_private *private = device->private;
  4710. struct attrib_data_t attrib;
  4711. if (!capable(CAP_SYS_ADMIN))
  4712. return -EACCES;
  4713. if (!argp)
  4714. return -EINVAL;
  4715. if (copy_from_user(&attrib, argp, sizeof(struct attrib_data_t)))
  4716. return -EFAULT;
  4717. private->attrib = attrib;
  4718. dev_info(&device->cdev->dev,
  4719. "The DASD cache mode was set to %x (%i cylinder prestage)\n",
  4720. private->attrib.operation, private->attrib.nr_cyl);
  4721. return 0;
  4722. }
  4723. /*
  4724. * Issue syscall I/O to EMC Symmetrix array.
  4725. * CCWs are PSF and RSSD
  4726. */
  4727. static int dasd_symm_io(struct dasd_device *device, void __user *argp)
  4728. {
  4729. struct dasd_symmio_parms usrparm;
  4730. char *psf_data, *rssd_result;
  4731. struct dasd_ccw_req *cqr;
  4732. struct ccw1 *ccw;
  4733. char psf0, psf1;
  4734. int rc;
  4735. if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
  4736. return -EACCES;
  4737. psf0 = psf1 = 0;
  4738. /* Copy parms from caller */
  4739. rc = -EFAULT;
  4740. if (copy_from_user(&usrparm, argp, sizeof(usrparm)))
  4741. goto out;
  4742. if (is_compat_task()) {
  4743. /* Make sure pointers are sane even on 31 bit. */
  4744. rc = -EINVAL;
  4745. if ((usrparm.psf_data >> 32) != 0)
  4746. goto out;
  4747. if ((usrparm.rssd_result >> 32) != 0)
  4748. goto out;
  4749. usrparm.psf_data &= 0x7fffffffULL;
  4750. usrparm.rssd_result &= 0x7fffffffULL;
  4751. }
  4752. /* at least 2 bytes are accessed and should be allocated */
  4753. if (usrparm.psf_data_len < 2) {
  4754. DBF_DEV_EVENT(DBF_WARNING, device,
  4755. "Symmetrix ioctl invalid data length %d",
  4756. usrparm.psf_data_len);
  4757. rc = -EINVAL;
  4758. goto out;
  4759. }
  4760. /* alloc I/O data area */
  4761. psf_data = kzalloc(usrparm.psf_data_len, GFP_KERNEL | GFP_DMA);
  4762. rssd_result = kzalloc(usrparm.rssd_result_len, GFP_KERNEL | GFP_DMA);
  4763. if (!psf_data || !rssd_result) {
  4764. rc = -ENOMEM;
  4765. goto out_free;
  4766. }
  4767. /* get syscall header from user space */
  4768. rc = -EFAULT;
  4769. if (copy_from_user(psf_data,
  4770. (void __user *)(unsigned long) usrparm.psf_data,
  4771. usrparm.psf_data_len))
  4772. goto out_free;
  4773. psf0 = psf_data[0];
  4774. psf1 = psf_data[1];
  4775. /* setup CCWs for PSF + RSSD */
  4776. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2, 0, device, NULL);
  4777. if (IS_ERR(cqr)) {
  4778. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  4779. "Could not allocate initialization request");
  4780. rc = PTR_ERR(cqr);
  4781. goto out_free;
  4782. }
  4783. cqr->startdev = device;
  4784. cqr->memdev = device;
  4785. cqr->retries = 3;
  4786. cqr->expires = 10 * HZ;
  4787. cqr->buildclk = get_tod_clock();
  4788. cqr->status = DASD_CQR_FILLED;
  4789. /* Build the ccws */
  4790. ccw = cqr->cpaddr;
  4791. /* PSF ccw */
  4792. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  4793. ccw->count = usrparm.psf_data_len;
  4794. ccw->flags |= CCW_FLAG_CC;
  4795. ccw->cda = (__u32)(addr_t) psf_data;
  4796. ccw++;
  4797. /* RSSD ccw */
  4798. ccw->cmd_code = DASD_ECKD_CCW_RSSD;
  4799. ccw->count = usrparm.rssd_result_len;
  4800. ccw->flags = CCW_FLAG_SLI ;
  4801. ccw->cda = (__u32)(addr_t) rssd_result;
  4802. rc = dasd_sleep_on(cqr);
  4803. if (rc)
  4804. goto out_sfree;
  4805. rc = -EFAULT;
  4806. if (copy_to_user((void __user *)(unsigned long) usrparm.rssd_result,
  4807. rssd_result, usrparm.rssd_result_len))
  4808. goto out_sfree;
  4809. rc = 0;
  4810. out_sfree:
  4811. dasd_sfree_request(cqr, cqr->memdev);
  4812. out_free:
  4813. kfree(rssd_result);
  4814. kfree(psf_data);
  4815. out:
  4816. DBF_DEV_EVENT(DBF_WARNING, device,
  4817. "Symmetrix ioctl (0x%02x 0x%02x): rc=%d",
  4818. (int) psf0, (int) psf1, rc);
  4819. return rc;
  4820. }
  4821. static int
  4822. dasd_eckd_ioctl(struct dasd_block *block, unsigned int cmd, void __user *argp)
  4823. {
  4824. struct dasd_device *device = block->base;
  4825. switch (cmd) {
  4826. case BIODASDGATTR:
  4827. return dasd_eckd_get_attrib(device, argp);
  4828. case BIODASDSATTR:
  4829. return dasd_eckd_set_attrib(device, argp);
  4830. case BIODASDPSRD:
  4831. return dasd_eckd_performance(device, argp);
  4832. case BIODASDRLSE:
  4833. return dasd_eckd_release(device);
  4834. case BIODASDRSRV:
  4835. return dasd_eckd_reserve(device);
  4836. case BIODASDSLCK:
  4837. return dasd_eckd_steal_lock(device);
  4838. case BIODASDSNID:
  4839. return dasd_eckd_snid(device, argp);
  4840. case BIODASDSYMMIO:
  4841. return dasd_symm_io(device, argp);
  4842. default:
  4843. return -ENOTTY;
  4844. }
  4845. }
  4846. /*
  4847. * Dump the range of CCWs into 'page' buffer
  4848. * and return number of printed chars.
  4849. */
  4850. static int
  4851. dasd_eckd_dump_ccw_range(struct ccw1 *from, struct ccw1 *to, char *page)
  4852. {
  4853. int len, count;
  4854. char *datap;
  4855. len = 0;
  4856. while (from <= to) {
  4857. len += sprintf(page + len, PRINTK_HEADER
  4858. " CCW %p: %08X %08X DAT:",
  4859. from, ((int *) from)[0], ((int *) from)[1]);
  4860. /* get pointer to data (consider IDALs) */
  4861. if (from->flags & CCW_FLAG_IDA)
  4862. datap = (char *) *((addr_t *) (addr_t) from->cda);
  4863. else
  4864. datap = (char *) ((addr_t) from->cda);
  4865. /* dump data (max 32 bytes) */
  4866. for (count = 0; count < from->count && count < 32; count++) {
  4867. if (count % 8 == 0) len += sprintf(page + len, " ");
  4868. if (count % 4 == 0) len += sprintf(page + len, " ");
  4869. len += sprintf(page + len, "%02x", datap[count]);
  4870. }
  4871. len += sprintf(page + len, "\n");
  4872. from++;
  4873. }
  4874. return len;
  4875. }
  4876. static void
  4877. dasd_eckd_dump_sense_dbf(struct dasd_device *device, struct irb *irb,
  4878. char *reason)
  4879. {
  4880. u64 *sense;
  4881. u64 *stat;
  4882. sense = (u64 *) dasd_get_sense(irb);
  4883. stat = (u64 *) &irb->scsw;
  4884. if (sense) {
  4885. DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : "
  4886. "%016llx %016llx %016llx %016llx",
  4887. reason, *stat, *((u32 *) (stat + 1)),
  4888. sense[0], sense[1], sense[2], sense[3]);
  4889. } else {
  4890. DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : %s",
  4891. reason, *stat, *((u32 *) (stat + 1)),
  4892. "NO VALID SENSE");
  4893. }
  4894. }
  4895. /*
  4896. * Print sense data and related channel program.
  4897. * Parts are printed because printk buffer is only 1024 bytes.
  4898. */
  4899. static void dasd_eckd_dump_sense_ccw(struct dasd_device *device,
  4900. struct dasd_ccw_req *req, struct irb *irb)
  4901. {
  4902. char *page;
  4903. struct ccw1 *first, *last, *fail, *from, *to;
  4904. int len, sl, sct;
  4905. page = (char *) get_zeroed_page(GFP_ATOMIC);
  4906. if (page == NULL) {
  4907. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  4908. "No memory to dump sense data\n");
  4909. return;
  4910. }
  4911. /* dump the sense data */
  4912. len = sprintf(page, PRINTK_HEADER
  4913. " I/O status report for device %s:\n",
  4914. dev_name(&device->cdev->dev));
  4915. len += sprintf(page + len, PRINTK_HEADER
  4916. " in req: %p CC:%02X FC:%02X AC:%02X SC:%02X DS:%02X "
  4917. "CS:%02X RC:%d\n",
  4918. req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw),
  4919. scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw),
  4920. scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw),
  4921. req ? req->intrc : 0);
  4922. len += sprintf(page + len, PRINTK_HEADER
  4923. " device %s: Failing CCW: %p\n",
  4924. dev_name(&device->cdev->dev),
  4925. (void *) (addr_t) irb->scsw.cmd.cpa);
  4926. if (irb->esw.esw0.erw.cons) {
  4927. for (sl = 0; sl < 4; sl++) {
  4928. len += sprintf(page + len, PRINTK_HEADER
  4929. " Sense(hex) %2d-%2d:",
  4930. (8 * sl), ((8 * sl) + 7));
  4931. for (sct = 0; sct < 8; sct++) {
  4932. len += sprintf(page + len, " %02x",
  4933. irb->ecw[8 * sl + sct]);
  4934. }
  4935. len += sprintf(page + len, "\n");
  4936. }
  4937. if (irb->ecw[27] & DASD_SENSE_BIT_0) {
  4938. /* 24 Byte Sense Data */
  4939. sprintf(page + len, PRINTK_HEADER
  4940. " 24 Byte: %x MSG %x, "
  4941. "%s MSGb to SYSOP\n",
  4942. irb->ecw[7] >> 4, irb->ecw[7] & 0x0f,
  4943. irb->ecw[1] & 0x10 ? "" : "no");
  4944. } else {
  4945. /* 32 Byte Sense Data */
  4946. sprintf(page + len, PRINTK_HEADER
  4947. " 32 Byte: Format: %x "
  4948. "Exception class %x\n",
  4949. irb->ecw[6] & 0x0f, irb->ecw[22] >> 4);
  4950. }
  4951. } else {
  4952. sprintf(page + len, PRINTK_HEADER
  4953. " SORRY - NO VALID SENSE AVAILABLE\n");
  4954. }
  4955. printk(KERN_ERR "%s", page);
  4956. if (req) {
  4957. /* req == NULL for unsolicited interrupts */
  4958. /* dump the Channel Program (max 140 Bytes per line) */
  4959. /* Count CCW and print first CCWs (maximum 1024 % 140 = 7) */
  4960. first = req->cpaddr;
  4961. for (last = first; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++);
  4962. to = min(first + 6, last);
  4963. len = sprintf(page, PRINTK_HEADER
  4964. " Related CP in req: %p\n", req);
  4965. dasd_eckd_dump_ccw_range(first, to, page + len);
  4966. printk(KERN_ERR "%s", page);
  4967. /* print failing CCW area (maximum 4) */
  4968. /* scsw->cda is either valid or zero */
  4969. len = 0;
  4970. from = ++to;
  4971. fail = (struct ccw1 *)(addr_t)
  4972. irb->scsw.cmd.cpa; /* failing CCW */
  4973. if (from < fail - 2) {
  4974. from = fail - 2; /* there is a gap - print header */
  4975. len += sprintf(page, PRINTK_HEADER "......\n");
  4976. }
  4977. to = min(fail + 1, last);
  4978. len += dasd_eckd_dump_ccw_range(from, to, page + len);
  4979. /* print last CCWs (maximum 2) */
  4980. from = max(from, ++to);
  4981. if (from < last - 1) {
  4982. from = last - 1; /* there is a gap - print header */
  4983. len += sprintf(page + len, PRINTK_HEADER "......\n");
  4984. }
  4985. len += dasd_eckd_dump_ccw_range(from, last, page + len);
  4986. if (len > 0)
  4987. printk(KERN_ERR "%s", page);
  4988. }
  4989. free_page((unsigned long) page);
  4990. }
  4991. /*
  4992. * Print sense data from a tcw.
  4993. */
  4994. static void dasd_eckd_dump_sense_tcw(struct dasd_device *device,
  4995. struct dasd_ccw_req *req, struct irb *irb)
  4996. {
  4997. char *page;
  4998. int len, sl, sct, residual;
  4999. struct tsb *tsb;
  5000. u8 *sense, *rcq;
  5001. page = (char *) get_zeroed_page(GFP_ATOMIC);
  5002. if (page == NULL) {
  5003. DBF_DEV_EVENT(DBF_WARNING, device, " %s",
  5004. "No memory to dump sense data");
  5005. return;
  5006. }
  5007. /* dump the sense data */
  5008. len = sprintf(page, PRINTK_HEADER
  5009. " I/O status report for device %s:\n",
  5010. dev_name(&device->cdev->dev));
  5011. len += sprintf(page + len, PRINTK_HEADER
  5012. " in req: %p CC:%02X FC:%02X AC:%02X SC:%02X DS:%02X "
  5013. "CS:%02X fcxs:%02X schxs:%02X RC:%d\n",
  5014. req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw),
  5015. scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw),
  5016. scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw),
  5017. irb->scsw.tm.fcxs,
  5018. (irb->scsw.tm.ifob << 7) | irb->scsw.tm.sesq,
  5019. req ? req->intrc : 0);
  5020. len += sprintf(page + len, PRINTK_HEADER
  5021. " device %s: Failing TCW: %p\n",
  5022. dev_name(&device->cdev->dev),
  5023. (void *) (addr_t) irb->scsw.tm.tcw);
  5024. tsb = NULL;
  5025. sense = NULL;
  5026. if (irb->scsw.tm.tcw && (irb->scsw.tm.fcxs & 0x01))
  5027. tsb = tcw_get_tsb(
  5028. (struct tcw *)(unsigned long)irb->scsw.tm.tcw);
  5029. if (tsb) {
  5030. len += sprintf(page + len, PRINTK_HEADER
  5031. " tsb->length %d\n", tsb->length);
  5032. len += sprintf(page + len, PRINTK_HEADER
  5033. " tsb->flags %x\n", tsb->flags);
  5034. len += sprintf(page + len, PRINTK_HEADER
  5035. " tsb->dcw_offset %d\n", tsb->dcw_offset);
  5036. len += sprintf(page + len, PRINTK_HEADER
  5037. " tsb->count %d\n", tsb->count);
  5038. residual = tsb->count - 28;
  5039. len += sprintf(page + len, PRINTK_HEADER
  5040. " residual %d\n", residual);
  5041. switch (tsb->flags & 0x07) {
  5042. case 1: /* tsa_iostat */
  5043. len += sprintf(page + len, PRINTK_HEADER
  5044. " tsb->tsa.iostat.dev_time %d\n",
  5045. tsb->tsa.iostat.dev_time);
  5046. len += sprintf(page + len, PRINTK_HEADER
  5047. " tsb->tsa.iostat.def_time %d\n",
  5048. tsb->tsa.iostat.def_time);
  5049. len += sprintf(page + len, PRINTK_HEADER
  5050. " tsb->tsa.iostat.queue_time %d\n",
  5051. tsb->tsa.iostat.queue_time);
  5052. len += sprintf(page + len, PRINTK_HEADER
  5053. " tsb->tsa.iostat.dev_busy_time %d\n",
  5054. tsb->tsa.iostat.dev_busy_time);
  5055. len += sprintf(page + len, PRINTK_HEADER
  5056. " tsb->tsa.iostat.dev_act_time %d\n",
  5057. tsb->tsa.iostat.dev_act_time);
  5058. sense = tsb->tsa.iostat.sense;
  5059. break;
  5060. case 2: /* ts_ddpc */
  5061. len += sprintf(page + len, PRINTK_HEADER
  5062. " tsb->tsa.ddpc.rc %d\n", tsb->tsa.ddpc.rc);
  5063. for (sl = 0; sl < 2; sl++) {
  5064. len += sprintf(page + len, PRINTK_HEADER
  5065. " tsb->tsa.ddpc.rcq %2d-%2d: ",
  5066. (8 * sl), ((8 * sl) + 7));
  5067. rcq = tsb->tsa.ddpc.rcq;
  5068. for (sct = 0; sct < 8; sct++) {
  5069. len += sprintf(page + len, " %02x",
  5070. rcq[8 * sl + sct]);
  5071. }
  5072. len += sprintf(page + len, "\n");
  5073. }
  5074. sense = tsb->tsa.ddpc.sense;
  5075. break;
  5076. case 3: /* tsa_intrg */
  5077. len += sprintf(page + len, PRINTK_HEADER
  5078. " tsb->tsa.intrg.: not supported yet\n");
  5079. break;
  5080. }
  5081. if (sense) {
  5082. for (sl = 0; sl < 4; sl++) {
  5083. len += sprintf(page + len, PRINTK_HEADER
  5084. " Sense(hex) %2d-%2d:",
  5085. (8 * sl), ((8 * sl) + 7));
  5086. for (sct = 0; sct < 8; sct++) {
  5087. len += sprintf(page + len, " %02x",
  5088. sense[8 * sl + sct]);
  5089. }
  5090. len += sprintf(page + len, "\n");
  5091. }
  5092. if (sense[27] & DASD_SENSE_BIT_0) {
  5093. /* 24 Byte Sense Data */
  5094. sprintf(page + len, PRINTK_HEADER
  5095. " 24 Byte: %x MSG %x, "
  5096. "%s MSGb to SYSOP\n",
  5097. sense[7] >> 4, sense[7] & 0x0f,
  5098. sense[1] & 0x10 ? "" : "no");
  5099. } else {
  5100. /* 32 Byte Sense Data */
  5101. sprintf(page + len, PRINTK_HEADER
  5102. " 32 Byte: Format: %x "
  5103. "Exception class %x\n",
  5104. sense[6] & 0x0f, sense[22] >> 4);
  5105. }
  5106. } else {
  5107. sprintf(page + len, PRINTK_HEADER
  5108. " SORRY - NO VALID SENSE AVAILABLE\n");
  5109. }
  5110. } else {
  5111. sprintf(page + len, PRINTK_HEADER
  5112. " SORRY - NO TSB DATA AVAILABLE\n");
  5113. }
  5114. printk(KERN_ERR "%s", page);
  5115. free_page((unsigned long) page);
  5116. }
  5117. static void dasd_eckd_dump_sense(struct dasd_device *device,
  5118. struct dasd_ccw_req *req, struct irb *irb)
  5119. {
  5120. u8 *sense = dasd_get_sense(irb);
  5121. if (scsw_is_tm(&irb->scsw)) {
  5122. /*
  5123. * In some cases the 'File Protected' or 'Incorrect Length'
  5124. * error might be expected and log messages shouldn't be written
  5125. * then. Check if the according suppress bit is set.
  5126. */
  5127. if (sense && (sense[1] & SNS1_FILE_PROTECTED) &&
  5128. test_bit(DASD_CQR_SUPPRESS_FP, &req->flags))
  5129. return;
  5130. if (scsw_cstat(&irb->scsw) == 0x40 &&
  5131. test_bit(DASD_CQR_SUPPRESS_IL, &req->flags))
  5132. return;
  5133. dasd_eckd_dump_sense_tcw(device, req, irb);
  5134. } else {
  5135. /*
  5136. * In some cases the 'Command Reject' or 'No Record Found'
  5137. * error might be expected and log messages shouldn't be
  5138. * written then. Check if the according suppress bit is set.
  5139. */
  5140. if (sense && sense[0] & SNS0_CMD_REJECT &&
  5141. test_bit(DASD_CQR_SUPPRESS_CR, &req->flags))
  5142. return;
  5143. if (sense && sense[1] & SNS1_NO_REC_FOUND &&
  5144. test_bit(DASD_CQR_SUPPRESS_NRF, &req->flags))
  5145. return;
  5146. dasd_eckd_dump_sense_ccw(device, req, irb);
  5147. }
  5148. }
  5149. static int dasd_eckd_pm_freeze(struct dasd_device *device)
  5150. {
  5151. /*
  5152. * the device should be disconnected from our LCU structure
  5153. * on restore we will reconnect it and reread LCU specific
  5154. * information like PAV support that might have changed
  5155. */
  5156. dasd_alias_remove_device(device);
  5157. dasd_alias_disconnect_device_from_lcu(device);
  5158. return 0;
  5159. }
  5160. static int dasd_eckd_restore_device(struct dasd_device *device)
  5161. {
  5162. struct dasd_eckd_private *private = device->private;
  5163. struct dasd_eckd_characteristics temp_rdc_data;
  5164. int rc;
  5165. struct dasd_uid temp_uid;
  5166. unsigned long flags;
  5167. unsigned long cqr_flags = 0;
  5168. /* Read Configuration Data */
  5169. rc = dasd_eckd_read_conf(device);
  5170. if (rc) {
  5171. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  5172. "Read configuration data failed, rc=%d", rc);
  5173. goto out_err;
  5174. }
  5175. dasd_eckd_get_uid(device, &temp_uid);
  5176. /* Generate device unique id */
  5177. rc = dasd_eckd_generate_uid(device);
  5178. spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
  5179. if (memcmp(&private->uid, &temp_uid, sizeof(struct dasd_uid)) != 0)
  5180. dev_err(&device->cdev->dev, "The UID of the DASD has "
  5181. "changed\n");
  5182. spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
  5183. if (rc)
  5184. goto out_err;
  5185. /* register lcu with alias handling, enable PAV if this is a new lcu */
  5186. rc = dasd_alias_make_device_known_to_lcu(device);
  5187. if (rc)
  5188. goto out_err;
  5189. set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr_flags);
  5190. dasd_eckd_validate_server(device, cqr_flags);
  5191. /* RE-Read Configuration Data */
  5192. rc = dasd_eckd_read_conf(device);
  5193. if (rc) {
  5194. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  5195. "Read configuration data failed, rc=%d", rc);
  5196. goto out_err2;
  5197. }
  5198. /* Read Feature Codes */
  5199. dasd_eckd_read_features(device);
  5200. /* Read Volume Information */
  5201. dasd_eckd_read_vol_info(device);
  5202. /* Read Extent Pool Information */
  5203. dasd_eckd_read_ext_pool_info(device);
  5204. /* Read Device Characteristics */
  5205. rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
  5206. &temp_rdc_data, 64);
  5207. if (rc) {
  5208. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  5209. "Read device characteristic failed, rc=%d", rc);
  5210. goto out_err2;
  5211. }
  5212. spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
  5213. memcpy(&private->rdc_data, &temp_rdc_data, sizeof(temp_rdc_data));
  5214. spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
  5215. /* add device to alias management */
  5216. dasd_alias_add_device(device);
  5217. return 0;
  5218. out_err2:
  5219. dasd_alias_disconnect_device_from_lcu(device);
  5220. out_err:
  5221. return -1;
  5222. }
  5223. static int dasd_eckd_reload_device(struct dasd_device *device)
  5224. {
  5225. struct dasd_eckd_private *private = device->private;
  5226. int rc, old_base;
  5227. char print_uid[60];
  5228. struct dasd_uid uid;
  5229. unsigned long flags;
  5230. /*
  5231. * remove device from alias handling to prevent new requests
  5232. * from being scheduled on the wrong alias device
  5233. */
  5234. dasd_alias_remove_device(device);
  5235. spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
  5236. old_base = private->uid.base_unit_addr;
  5237. spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
  5238. /* Read Configuration Data */
  5239. rc = dasd_eckd_read_conf(device);
  5240. if (rc)
  5241. goto out_err;
  5242. rc = dasd_eckd_generate_uid(device);
  5243. if (rc)
  5244. goto out_err;
  5245. /*
  5246. * update unit address configuration and
  5247. * add device to alias management
  5248. */
  5249. dasd_alias_update_add_device(device);
  5250. dasd_eckd_get_uid(device, &uid);
  5251. if (old_base != uid.base_unit_addr) {
  5252. if (strlen(uid.vduit) > 0)
  5253. snprintf(print_uid, sizeof(print_uid),
  5254. "%s.%s.%04x.%02x.%s", uid.vendor, uid.serial,
  5255. uid.ssid, uid.base_unit_addr, uid.vduit);
  5256. else
  5257. snprintf(print_uid, sizeof(print_uid),
  5258. "%s.%s.%04x.%02x", uid.vendor, uid.serial,
  5259. uid.ssid, uid.base_unit_addr);
  5260. dev_info(&device->cdev->dev,
  5261. "An Alias device was reassigned to a new base device "
  5262. "with UID: %s\n", print_uid);
  5263. }
  5264. return 0;
  5265. out_err:
  5266. return -1;
  5267. }
  5268. static int dasd_eckd_read_message_buffer(struct dasd_device *device,
  5269. struct dasd_rssd_messages *messages,
  5270. __u8 lpum)
  5271. {
  5272. struct dasd_rssd_messages *message_buf;
  5273. struct dasd_psf_prssd_data *prssdp;
  5274. struct dasd_ccw_req *cqr;
  5275. struct ccw1 *ccw;
  5276. int rc;
  5277. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
  5278. (sizeof(struct dasd_psf_prssd_data) +
  5279. sizeof(struct dasd_rssd_messages)),
  5280. device, NULL);
  5281. if (IS_ERR(cqr)) {
  5282. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  5283. "Could not allocate read message buffer request");
  5284. return PTR_ERR(cqr);
  5285. }
  5286. cqr->lpm = lpum;
  5287. retry:
  5288. cqr->startdev = device;
  5289. cqr->memdev = device;
  5290. cqr->block = NULL;
  5291. cqr->expires = 10 * HZ;
  5292. set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags);
  5293. /* dasd_sleep_on_immediatly does not do complex error
  5294. * recovery so clear erp flag and set retry counter to
  5295. * do basic erp */
  5296. clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  5297. cqr->retries = 256;
  5298. /* Prepare for Read Subsystem Data */
  5299. prssdp = (struct dasd_psf_prssd_data *) cqr->data;
  5300. memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
  5301. prssdp->order = PSF_ORDER_PRSSD;
  5302. prssdp->suborder = 0x03; /* Message Buffer */
  5303. /* all other bytes of prssdp must be zero */
  5304. ccw = cqr->cpaddr;
  5305. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  5306. ccw->count = sizeof(struct dasd_psf_prssd_data);
  5307. ccw->flags |= CCW_FLAG_CC;
  5308. ccw->flags |= CCW_FLAG_SLI;
  5309. ccw->cda = (__u32)(addr_t) prssdp;
  5310. /* Read Subsystem Data - message buffer */
  5311. message_buf = (struct dasd_rssd_messages *) (prssdp + 1);
  5312. memset(message_buf, 0, sizeof(struct dasd_rssd_messages));
  5313. ccw++;
  5314. ccw->cmd_code = DASD_ECKD_CCW_RSSD;
  5315. ccw->count = sizeof(struct dasd_rssd_messages);
  5316. ccw->flags |= CCW_FLAG_SLI;
  5317. ccw->cda = (__u32)(addr_t) message_buf;
  5318. cqr->buildclk = get_tod_clock();
  5319. cqr->status = DASD_CQR_FILLED;
  5320. rc = dasd_sleep_on_immediatly(cqr);
  5321. if (rc == 0) {
  5322. prssdp = (struct dasd_psf_prssd_data *) cqr->data;
  5323. message_buf = (struct dasd_rssd_messages *)
  5324. (prssdp + 1);
  5325. memcpy(messages, message_buf,
  5326. sizeof(struct dasd_rssd_messages));
  5327. } else if (cqr->lpm) {
  5328. /*
  5329. * on z/VM we might not be able to do I/O on the requested path
  5330. * but instead we get the required information on any path
  5331. * so retry with open path mask
  5332. */
  5333. cqr->lpm = 0;
  5334. goto retry;
  5335. } else
  5336. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  5337. "Reading messages failed with rc=%d\n"
  5338. , rc);
  5339. dasd_sfree_request(cqr, cqr->memdev);
  5340. return rc;
  5341. }
  5342. static int dasd_eckd_query_host_access(struct dasd_device *device,
  5343. struct dasd_psf_query_host_access *data)
  5344. {
  5345. struct dasd_eckd_private *private = device->private;
  5346. struct dasd_psf_query_host_access *host_access;
  5347. struct dasd_psf_prssd_data *prssdp;
  5348. struct dasd_ccw_req *cqr;
  5349. struct ccw1 *ccw;
  5350. int rc;
  5351. /* not available for HYPER PAV alias devices */
  5352. if (!device->block && private->lcu->pav == HYPER_PAV)
  5353. return -EOPNOTSUPP;
  5354. /* may not be supported by the storage server */
  5355. if (!(private->features.feature[14] & 0x80))
  5356. return -EOPNOTSUPP;
  5357. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
  5358. sizeof(struct dasd_psf_prssd_data) + 1,
  5359. device, NULL);
  5360. if (IS_ERR(cqr)) {
  5361. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  5362. "Could not allocate read message buffer request");
  5363. return PTR_ERR(cqr);
  5364. }
  5365. host_access = kzalloc(sizeof(*host_access), GFP_KERNEL | GFP_DMA);
  5366. if (!host_access) {
  5367. dasd_sfree_request(cqr, device);
  5368. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  5369. "Could not allocate host_access buffer");
  5370. return -ENOMEM;
  5371. }
  5372. cqr->startdev = device;
  5373. cqr->memdev = device;
  5374. cqr->block = NULL;
  5375. cqr->retries = 256;
  5376. cqr->expires = 10 * HZ;
  5377. /* Prepare for Read Subsystem Data */
  5378. prssdp = (struct dasd_psf_prssd_data *) cqr->data;
  5379. memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
  5380. prssdp->order = PSF_ORDER_PRSSD;
  5381. prssdp->suborder = PSF_SUBORDER_QHA; /* query host access */
  5382. /* LSS and Volume that will be queried */
  5383. prssdp->lss = private->ned->ID;
  5384. prssdp->volume = private->ned->unit_addr;
  5385. /* all other bytes of prssdp must be zero */
  5386. ccw = cqr->cpaddr;
  5387. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  5388. ccw->count = sizeof(struct dasd_psf_prssd_data);
  5389. ccw->flags |= CCW_FLAG_CC;
  5390. ccw->flags |= CCW_FLAG_SLI;
  5391. ccw->cda = (__u32)(addr_t) prssdp;
  5392. /* Read Subsystem Data - query host access */
  5393. ccw++;
  5394. ccw->cmd_code = DASD_ECKD_CCW_RSSD;
  5395. ccw->count = sizeof(struct dasd_psf_query_host_access);
  5396. ccw->flags |= CCW_FLAG_SLI;
  5397. ccw->cda = (__u32)(addr_t) host_access;
  5398. cqr->buildclk = get_tod_clock();
  5399. cqr->status = DASD_CQR_FILLED;
  5400. /* the command might not be supported, suppress error message */
  5401. __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags);
  5402. rc = dasd_sleep_on_interruptible(cqr);
  5403. if (rc == 0) {
  5404. *data = *host_access;
  5405. } else {
  5406. DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
  5407. "Reading host access data failed with rc=%d\n",
  5408. rc);
  5409. rc = -EOPNOTSUPP;
  5410. }
  5411. dasd_sfree_request(cqr, cqr->memdev);
  5412. kfree(host_access);
  5413. return rc;
  5414. }
  5415. /*
  5416. * return number of grouped devices
  5417. */
  5418. static int dasd_eckd_host_access_count(struct dasd_device *device)
  5419. {
  5420. struct dasd_psf_query_host_access *access;
  5421. struct dasd_ckd_path_group_entry *entry;
  5422. struct dasd_ckd_host_information *info;
  5423. int count = 0;
  5424. int rc, i;
  5425. access = kzalloc(sizeof(*access), GFP_NOIO);
  5426. if (!access) {
  5427. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  5428. "Could not allocate access buffer");
  5429. return -ENOMEM;
  5430. }
  5431. rc = dasd_eckd_query_host_access(device, access);
  5432. if (rc) {
  5433. kfree(access);
  5434. return rc;
  5435. }
  5436. info = (struct dasd_ckd_host_information *)
  5437. access->host_access_information;
  5438. for (i = 0; i < info->entry_count; i++) {
  5439. entry = (struct dasd_ckd_path_group_entry *)
  5440. (info->entry + i * info->entry_size);
  5441. if (entry->status_flags & DASD_ECKD_PG_GROUPED)
  5442. count++;
  5443. }
  5444. kfree(access);
  5445. return count;
  5446. }
  5447. /*
  5448. * write host access information to a sequential file
  5449. */
  5450. static int dasd_hosts_print(struct dasd_device *device, struct seq_file *m)
  5451. {
  5452. struct dasd_psf_query_host_access *access;
  5453. struct dasd_ckd_path_group_entry *entry;
  5454. struct dasd_ckd_host_information *info;
  5455. char sysplex[9] = "";
  5456. int rc, i;
  5457. access = kzalloc(sizeof(*access), GFP_NOIO);
  5458. if (!access) {
  5459. DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
  5460. "Could not allocate access buffer");
  5461. return -ENOMEM;
  5462. }
  5463. rc = dasd_eckd_query_host_access(device, access);
  5464. if (rc) {
  5465. kfree(access);
  5466. return rc;
  5467. }
  5468. info = (struct dasd_ckd_host_information *)
  5469. access->host_access_information;
  5470. for (i = 0; i < info->entry_count; i++) {
  5471. entry = (struct dasd_ckd_path_group_entry *)
  5472. (info->entry + i * info->entry_size);
  5473. /* PGID */
  5474. seq_printf(m, "pgid %*phN\n", 11, entry->pgid);
  5475. /* FLAGS */
  5476. seq_printf(m, "status_flags %02x\n", entry->status_flags);
  5477. /* SYSPLEX NAME */
  5478. memcpy(&sysplex, &entry->sysplex_name, sizeof(sysplex) - 1);
  5479. EBCASC(sysplex, sizeof(sysplex));
  5480. seq_printf(m, "sysplex_name %8s\n", sysplex);
  5481. /* SUPPORTED CYLINDER */
  5482. seq_printf(m, "supported_cylinder %d\n", entry->cylinder);
  5483. /* TIMESTAMP */
  5484. seq_printf(m, "timestamp %lu\n", (unsigned long)
  5485. entry->timestamp);
  5486. }
  5487. kfree(access);
  5488. return 0;
  5489. }
  5490. /*
  5491. * Perform Subsystem Function - CUIR response
  5492. */
  5493. static int
  5494. dasd_eckd_psf_cuir_response(struct dasd_device *device, int response,
  5495. __u32 message_id, __u8 lpum)
  5496. {
  5497. struct dasd_psf_cuir_response *psf_cuir;
  5498. int pos = pathmask_to_pos(lpum);
  5499. struct dasd_ccw_req *cqr;
  5500. struct ccw1 *ccw;
  5501. int rc;
  5502. cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ ,
  5503. sizeof(struct dasd_psf_cuir_response),
  5504. device, NULL);
  5505. if (IS_ERR(cqr)) {
  5506. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  5507. "Could not allocate PSF-CUIR request");
  5508. return PTR_ERR(cqr);
  5509. }
  5510. psf_cuir = (struct dasd_psf_cuir_response *)cqr->data;
  5511. psf_cuir->order = PSF_ORDER_CUIR_RESPONSE;
  5512. psf_cuir->cc = response;
  5513. psf_cuir->chpid = device->path[pos].chpid;
  5514. psf_cuir->message_id = message_id;
  5515. psf_cuir->cssid = device->path[pos].cssid;
  5516. psf_cuir->ssid = device->path[pos].ssid;
  5517. ccw = cqr->cpaddr;
  5518. ccw->cmd_code = DASD_ECKD_CCW_PSF;
  5519. ccw->cda = (__u32)(addr_t)psf_cuir;
  5520. ccw->flags = CCW_FLAG_SLI;
  5521. ccw->count = sizeof(struct dasd_psf_cuir_response);
  5522. cqr->startdev = device;
  5523. cqr->memdev = device;
  5524. cqr->block = NULL;
  5525. cqr->retries = 256;
  5526. cqr->expires = 10*HZ;
  5527. cqr->buildclk = get_tod_clock();
  5528. cqr->status = DASD_CQR_FILLED;
  5529. set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags);
  5530. rc = dasd_sleep_on(cqr);
  5531. dasd_sfree_request(cqr, cqr->memdev);
  5532. return rc;
  5533. }
  5534. /*
  5535. * return configuration data that is referenced by record selector
  5536. * if a record selector is specified or per default return the
  5537. * conf_data pointer for the path specified by lpum
  5538. */
  5539. static struct dasd_conf_data *dasd_eckd_get_ref_conf(struct dasd_device *device,
  5540. __u8 lpum,
  5541. struct dasd_cuir_message *cuir)
  5542. {
  5543. struct dasd_conf_data *conf_data;
  5544. int path, pos;
  5545. if (cuir->record_selector == 0)
  5546. goto out;
  5547. for (path = 0x80, pos = 0; path; path >>= 1, pos++) {
  5548. conf_data = device->path[pos].conf_data;
  5549. if (conf_data->gneq.record_selector ==
  5550. cuir->record_selector)
  5551. return conf_data;
  5552. }
  5553. out:
  5554. return device->path[pathmask_to_pos(lpum)].conf_data;
  5555. }
  5556. /*
  5557. * This function determines the scope of a reconfiguration request by
  5558. * analysing the path and device selection data provided in the CUIR request.
  5559. * Returns a path mask containing CUIR affected paths for the give device.
  5560. *
  5561. * If the CUIR request does not contain the required information return the
  5562. * path mask of the path the attention message for the CUIR request was reveived
  5563. * on.
  5564. */
  5565. static int dasd_eckd_cuir_scope(struct dasd_device *device, __u8 lpum,
  5566. struct dasd_cuir_message *cuir)
  5567. {
  5568. struct dasd_conf_data *ref_conf_data;
  5569. unsigned long bitmask = 0, mask = 0;
  5570. struct dasd_conf_data *conf_data;
  5571. unsigned int pos, path;
  5572. char *ref_gneq, *gneq;
  5573. char *ref_ned, *ned;
  5574. int tbcpm = 0;
  5575. /* if CUIR request does not specify the scope use the path
  5576. the attention message was presented on */
  5577. if (!cuir->ned_map ||
  5578. !(cuir->neq_map[0] | cuir->neq_map[1] | cuir->neq_map[2]))
  5579. return lpum;
  5580. /* get reference conf data */
  5581. ref_conf_data = dasd_eckd_get_ref_conf(device, lpum, cuir);
  5582. /* reference ned is determined by ned_map field */
  5583. pos = 8 - ffs(cuir->ned_map);
  5584. ref_ned = (char *)&ref_conf_data->neds[pos];
  5585. ref_gneq = (char *)&ref_conf_data->gneq;
  5586. /* transfer 24 bit neq_map to mask */
  5587. mask = cuir->neq_map[2];
  5588. mask |= cuir->neq_map[1] << 8;
  5589. mask |= cuir->neq_map[0] << 16;
  5590. for (path = 0; path < 8; path++) {
  5591. /* initialise data per path */
  5592. bitmask = mask;
  5593. conf_data = device->path[path].conf_data;
  5594. pos = 8 - ffs(cuir->ned_map);
  5595. ned = (char *) &conf_data->neds[pos];
  5596. /* compare reference ned and per path ned */
  5597. if (memcmp(ref_ned, ned, sizeof(*ned)) != 0)
  5598. continue;
  5599. gneq = (char *)&conf_data->gneq;
  5600. /* compare reference gneq and per_path gneq under
  5601. 24 bit mask where mask bit 0 equals byte 7 of
  5602. the gneq and mask bit 24 equals byte 31 */
  5603. while (bitmask) {
  5604. pos = ffs(bitmask) - 1;
  5605. if (memcmp(&ref_gneq[31 - pos], &gneq[31 - pos], 1)
  5606. != 0)
  5607. break;
  5608. clear_bit(pos, &bitmask);
  5609. }
  5610. if (bitmask)
  5611. continue;
  5612. /* device and path match the reference values
  5613. add path to CUIR scope */
  5614. tbcpm |= 0x80 >> path;
  5615. }
  5616. return tbcpm;
  5617. }
  5618. static void dasd_eckd_cuir_notify_user(struct dasd_device *device,
  5619. unsigned long paths, int action)
  5620. {
  5621. int pos;
  5622. while (paths) {
  5623. /* get position of bit in mask */
  5624. pos = 8 - ffs(paths);
  5625. /* get channel path descriptor from this position */
  5626. if (action == CUIR_QUIESCE)
  5627. pr_warn("Service on the storage server caused path %x.%02x to go offline",
  5628. device->path[pos].cssid,
  5629. device->path[pos].chpid);
  5630. else if (action == CUIR_RESUME)
  5631. pr_info("Path %x.%02x is back online after service on the storage server",
  5632. device->path[pos].cssid,
  5633. device->path[pos].chpid);
  5634. clear_bit(7 - pos, &paths);
  5635. }
  5636. }
  5637. static int dasd_eckd_cuir_remove_path(struct dasd_device *device, __u8 lpum,
  5638. struct dasd_cuir_message *cuir)
  5639. {
  5640. unsigned long tbcpm;
  5641. tbcpm = dasd_eckd_cuir_scope(device, lpum, cuir);
  5642. /* nothing to do if path is not in use */
  5643. if (!(dasd_path_get_opm(device) & tbcpm))
  5644. return 0;
  5645. if (!(dasd_path_get_opm(device) & ~tbcpm)) {
  5646. /* no path would be left if the CUIR action is taken
  5647. return error */
  5648. return -EINVAL;
  5649. }
  5650. /* remove device from operational path mask */
  5651. dasd_path_remove_opm(device, tbcpm);
  5652. dasd_path_add_cuirpm(device, tbcpm);
  5653. return tbcpm;
  5654. }
  5655. /*
  5656. * walk through all devices and build a path mask to quiesce them
  5657. * return an error if the last path to a device would be removed
  5658. *
  5659. * if only part of the devices are quiesced and an error
  5660. * occurs no onlining necessary, the storage server will
  5661. * notify the already set offline devices again
  5662. */
  5663. static int dasd_eckd_cuir_quiesce(struct dasd_device *device, __u8 lpum,
  5664. struct dasd_cuir_message *cuir)
  5665. {
  5666. struct dasd_eckd_private *private = device->private;
  5667. struct alias_pav_group *pavgroup, *tempgroup;
  5668. struct dasd_device *dev, *n;
  5669. unsigned long paths = 0;
  5670. unsigned long flags;
  5671. int tbcpm;
  5672. /* active devices */
  5673. list_for_each_entry_safe(dev, n, &private->lcu->active_devices,
  5674. alias_list) {
  5675. spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags);
  5676. tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir);
  5677. spin_unlock_irqrestore(get_ccwdev_lock(dev->cdev), flags);
  5678. if (tbcpm < 0)
  5679. goto out_err;
  5680. paths |= tbcpm;
  5681. }
  5682. /* inactive devices */
  5683. list_for_each_entry_safe(dev, n, &private->lcu->inactive_devices,
  5684. alias_list) {
  5685. spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags);
  5686. tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir);
  5687. spin_unlock_irqrestore(get_ccwdev_lock(dev->cdev), flags);
  5688. if (tbcpm < 0)
  5689. goto out_err;
  5690. paths |= tbcpm;
  5691. }
  5692. /* devices in PAV groups */
  5693. list_for_each_entry_safe(pavgroup, tempgroup,
  5694. &private->lcu->grouplist, group) {
  5695. list_for_each_entry_safe(dev, n, &pavgroup->baselist,
  5696. alias_list) {
  5697. spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags);
  5698. tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir);
  5699. spin_unlock_irqrestore(
  5700. get_ccwdev_lock(dev->cdev), flags);
  5701. if (tbcpm < 0)
  5702. goto out_err;
  5703. paths |= tbcpm;
  5704. }
  5705. list_for_each_entry_safe(dev, n, &pavgroup->aliaslist,
  5706. alias_list) {
  5707. spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags);
  5708. tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir);
  5709. spin_unlock_irqrestore(
  5710. get_ccwdev_lock(dev->cdev), flags);
  5711. if (tbcpm < 0)
  5712. goto out_err;
  5713. paths |= tbcpm;
  5714. }
  5715. }
  5716. /* notify user about all paths affected by CUIR action */
  5717. dasd_eckd_cuir_notify_user(device, paths, CUIR_QUIESCE);
  5718. return 0;
  5719. out_err:
  5720. return tbcpm;
  5721. }
  5722. static int dasd_eckd_cuir_resume(struct dasd_device *device, __u8 lpum,
  5723. struct dasd_cuir_message *cuir)
  5724. {
  5725. struct dasd_eckd_private *private = device->private;
  5726. struct alias_pav_group *pavgroup, *tempgroup;
  5727. struct dasd_device *dev, *n;
  5728. unsigned long paths = 0;
  5729. int tbcpm;
  5730. /*
  5731. * the path may have been added through a generic path event before
  5732. * only trigger path verification if the path is not already in use
  5733. */
  5734. list_for_each_entry_safe(dev, n,
  5735. &private->lcu->active_devices,
  5736. alias_list) {
  5737. tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir);
  5738. paths |= tbcpm;
  5739. if (!(dasd_path_get_opm(dev) & tbcpm)) {
  5740. dasd_path_add_tbvpm(dev, tbcpm);
  5741. dasd_schedule_device_bh(dev);
  5742. }
  5743. }
  5744. list_for_each_entry_safe(dev, n,
  5745. &private->lcu->inactive_devices,
  5746. alias_list) {
  5747. tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir);
  5748. paths |= tbcpm;
  5749. if (!(dasd_path_get_opm(dev) & tbcpm)) {
  5750. dasd_path_add_tbvpm(dev, tbcpm);
  5751. dasd_schedule_device_bh(dev);
  5752. }
  5753. }
  5754. /* devices in PAV groups */
  5755. list_for_each_entry_safe(pavgroup, tempgroup,
  5756. &private->lcu->grouplist,
  5757. group) {
  5758. list_for_each_entry_safe(dev, n,
  5759. &pavgroup->baselist,
  5760. alias_list) {
  5761. tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir);
  5762. paths |= tbcpm;
  5763. if (!(dasd_path_get_opm(dev) & tbcpm)) {
  5764. dasd_path_add_tbvpm(dev, tbcpm);
  5765. dasd_schedule_device_bh(dev);
  5766. }
  5767. }
  5768. list_for_each_entry_safe(dev, n,
  5769. &pavgroup->aliaslist,
  5770. alias_list) {
  5771. tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir);
  5772. paths |= tbcpm;
  5773. if (!(dasd_path_get_opm(dev) & tbcpm)) {
  5774. dasd_path_add_tbvpm(dev, tbcpm);
  5775. dasd_schedule_device_bh(dev);
  5776. }
  5777. }
  5778. }
  5779. /* notify user about all paths affected by CUIR action */
  5780. dasd_eckd_cuir_notify_user(device, paths, CUIR_RESUME);
  5781. return 0;
  5782. }
  5783. static void dasd_eckd_handle_cuir(struct dasd_device *device, void *messages,
  5784. __u8 lpum)
  5785. {
  5786. struct dasd_cuir_message *cuir = messages;
  5787. int response;
  5788. DBF_DEV_EVENT(DBF_WARNING, device,
  5789. "CUIR request: %016llx %016llx %016llx %08x",
  5790. ((u64 *)cuir)[0], ((u64 *)cuir)[1], ((u64 *)cuir)[2],
  5791. ((u32 *)cuir)[3]);
  5792. if (cuir->code == CUIR_QUIESCE) {
  5793. /* quiesce */
  5794. if (dasd_eckd_cuir_quiesce(device, lpum, cuir))
  5795. response = PSF_CUIR_LAST_PATH;
  5796. else
  5797. response = PSF_CUIR_COMPLETED;
  5798. } else if (cuir->code == CUIR_RESUME) {
  5799. /* resume */
  5800. dasd_eckd_cuir_resume(device, lpum, cuir);
  5801. response = PSF_CUIR_COMPLETED;
  5802. } else
  5803. response = PSF_CUIR_NOT_SUPPORTED;
  5804. dasd_eckd_psf_cuir_response(device, response,
  5805. cuir->message_id, lpum);
  5806. DBF_DEV_EVENT(DBF_WARNING, device,
  5807. "CUIR response: %d on message ID %08x", response,
  5808. cuir->message_id);
  5809. /* to make sure there is no attention left schedule work again */
  5810. device->discipline->check_attention(device, lpum);
  5811. }
  5812. static void dasd_eckd_oos_resume(struct dasd_device *device)
  5813. {
  5814. struct dasd_eckd_private *private = device->private;
  5815. struct alias_pav_group *pavgroup, *tempgroup;
  5816. struct dasd_device *dev, *n;
  5817. unsigned long flags;
  5818. spin_lock_irqsave(&private->lcu->lock, flags);
  5819. list_for_each_entry_safe(dev, n, &private->lcu->active_devices,
  5820. alias_list) {
  5821. if (dev->stopped & DASD_STOPPED_NOSPC)
  5822. dasd_generic_space_avail(dev);
  5823. }
  5824. list_for_each_entry_safe(dev, n, &private->lcu->inactive_devices,
  5825. alias_list) {
  5826. if (dev->stopped & DASD_STOPPED_NOSPC)
  5827. dasd_generic_space_avail(dev);
  5828. }
  5829. /* devices in PAV groups */
  5830. list_for_each_entry_safe(pavgroup, tempgroup,
  5831. &private->lcu->grouplist,
  5832. group) {
  5833. list_for_each_entry_safe(dev, n, &pavgroup->baselist,
  5834. alias_list) {
  5835. if (dev->stopped & DASD_STOPPED_NOSPC)
  5836. dasd_generic_space_avail(dev);
  5837. }
  5838. list_for_each_entry_safe(dev, n, &pavgroup->aliaslist,
  5839. alias_list) {
  5840. if (dev->stopped & DASD_STOPPED_NOSPC)
  5841. dasd_generic_space_avail(dev);
  5842. }
  5843. }
  5844. spin_unlock_irqrestore(&private->lcu->lock, flags);
  5845. }
  5846. static void dasd_eckd_handle_oos(struct dasd_device *device, void *messages,
  5847. __u8 lpum)
  5848. {
  5849. struct dasd_oos_message *oos = messages;
  5850. switch (oos->code) {
  5851. case REPO_WARN:
  5852. case POOL_WARN:
  5853. dev_warn(&device->cdev->dev,
  5854. "Extent pool usage has reached a critical value\n");
  5855. dasd_eckd_oos_resume(device);
  5856. break;
  5857. case REPO_EXHAUST:
  5858. case POOL_EXHAUST:
  5859. dev_warn(&device->cdev->dev,
  5860. "Extent pool is exhausted\n");
  5861. break;
  5862. case REPO_RELIEVE:
  5863. case POOL_RELIEVE:
  5864. dev_info(&device->cdev->dev,
  5865. "Extent pool physical space constraint has been relieved\n");
  5866. break;
  5867. }
  5868. /* In any case, update related data */
  5869. dasd_eckd_read_ext_pool_info(device);
  5870. /* to make sure there is no attention left schedule work again */
  5871. device->discipline->check_attention(device, lpum);
  5872. }
  5873. static void dasd_eckd_check_attention_work(struct work_struct *work)
  5874. {
  5875. struct check_attention_work_data *data;
  5876. struct dasd_rssd_messages *messages;
  5877. struct dasd_device *device;
  5878. int rc;
  5879. data = container_of(work, struct check_attention_work_data, worker);
  5880. device = data->device;
  5881. messages = kzalloc(sizeof(*messages), GFP_KERNEL);
  5882. if (!messages) {
  5883. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  5884. "Could not allocate attention message buffer");
  5885. goto out;
  5886. }
  5887. rc = dasd_eckd_read_message_buffer(device, messages, data->lpum);
  5888. if (rc)
  5889. goto out;
  5890. if (messages->length == ATTENTION_LENGTH_CUIR &&
  5891. messages->format == ATTENTION_FORMAT_CUIR)
  5892. dasd_eckd_handle_cuir(device, messages, data->lpum);
  5893. if (messages->length == ATTENTION_LENGTH_OOS &&
  5894. messages->format == ATTENTION_FORMAT_OOS)
  5895. dasd_eckd_handle_oos(device, messages, data->lpum);
  5896. out:
  5897. dasd_put_device(device);
  5898. kfree(messages);
  5899. kfree(data);
  5900. }
  5901. static int dasd_eckd_check_attention(struct dasd_device *device, __u8 lpum)
  5902. {
  5903. struct check_attention_work_data *data;
  5904. data = kzalloc(sizeof(*data), GFP_ATOMIC);
  5905. if (!data)
  5906. return -ENOMEM;
  5907. INIT_WORK(&data->worker, dasd_eckd_check_attention_work);
  5908. dasd_get_device(device);
  5909. data->device = device;
  5910. data->lpum = lpum;
  5911. schedule_work(&data->worker);
  5912. return 0;
  5913. }
  5914. static int dasd_eckd_disable_hpf_path(struct dasd_device *device, __u8 lpum)
  5915. {
  5916. if (~lpum & dasd_path_get_opm(device)) {
  5917. dasd_path_add_nohpfpm(device, lpum);
  5918. dasd_path_remove_opm(device, lpum);
  5919. dev_err(&device->cdev->dev,
  5920. "Channel path %02X lost HPF functionality and is disabled\n",
  5921. lpum);
  5922. return 1;
  5923. }
  5924. return 0;
  5925. }
  5926. static void dasd_eckd_disable_hpf_device(struct dasd_device *device)
  5927. {
  5928. struct dasd_eckd_private *private = device->private;
  5929. dev_err(&device->cdev->dev,
  5930. "High Performance FICON disabled\n");
  5931. private->fcx_max_data = 0;
  5932. }
  5933. static int dasd_eckd_hpf_enabled(struct dasd_device *device)
  5934. {
  5935. struct dasd_eckd_private *private = device->private;
  5936. return private->fcx_max_data ? 1 : 0;
  5937. }
  5938. static void dasd_eckd_handle_hpf_error(struct dasd_device *device,
  5939. struct irb *irb)
  5940. {
  5941. struct dasd_eckd_private *private = device->private;
  5942. if (!private->fcx_max_data) {
  5943. /* sanity check for no HPF, the error makes no sense */
  5944. DBF_DEV_EVENT(DBF_WARNING, device, "%s",
  5945. "Trying to disable HPF for a non HPF device");
  5946. return;
  5947. }
  5948. if (irb->scsw.tm.sesq == SCSW_SESQ_DEV_NOFCX) {
  5949. dasd_eckd_disable_hpf_device(device);
  5950. } else if (irb->scsw.tm.sesq == SCSW_SESQ_PATH_NOFCX) {
  5951. if (dasd_eckd_disable_hpf_path(device, irb->esw.esw1.lpum))
  5952. return;
  5953. dasd_eckd_disable_hpf_device(device);
  5954. dasd_path_set_tbvpm(device,
  5955. dasd_path_get_hpfpm(device));
  5956. }
  5957. /*
  5958. * prevent that any new I/O ist started on the device and schedule a
  5959. * requeue of existing requests
  5960. */
  5961. dasd_device_set_stop_bits(device, DASD_STOPPED_NOT_ACC);
  5962. dasd_schedule_requeue(device);
  5963. }
  5964. /*
  5965. * Initialize block layer request queue.
  5966. */
  5967. static void dasd_eckd_setup_blk_queue(struct dasd_block *block)
  5968. {
  5969. unsigned int logical_block_size = block->bp_block;
  5970. struct request_queue *q = block->request_queue;
  5971. struct dasd_device *device = block->base;
  5972. int max;
  5973. if (device->features & DASD_FEATURE_USERAW) {
  5974. /*
  5975. * the max_blocks value for raw_track access is 256
  5976. * it is higher than the native ECKD value because we
  5977. * only need one ccw per track
  5978. * so the max_hw_sectors are
  5979. * 2048 x 512B = 1024kB = 16 tracks
  5980. */
  5981. max = DASD_ECKD_MAX_BLOCKS_RAW << block->s2b_shift;
  5982. } else {
  5983. max = DASD_ECKD_MAX_BLOCKS << block->s2b_shift;
  5984. }
  5985. blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
  5986. q->limits.max_dev_sectors = max;
  5987. blk_queue_logical_block_size(q, logical_block_size);
  5988. blk_queue_max_hw_sectors(q, max);
  5989. blk_queue_max_segments(q, USHRT_MAX);
  5990. /* With page sized segments each segment can be translated into one idaw/tidaw */
  5991. blk_queue_max_segment_size(q, PAGE_SIZE);
  5992. blk_queue_segment_boundary(q, PAGE_SIZE - 1);
  5993. }
  5994. static struct ccw_driver dasd_eckd_driver = {
  5995. .driver = {
  5996. .name = "dasd-eckd",
  5997. .owner = THIS_MODULE,
  5998. },
  5999. .ids = dasd_eckd_ids,
  6000. .probe = dasd_eckd_probe,
  6001. .remove = dasd_generic_remove,
  6002. .set_offline = dasd_generic_set_offline,
  6003. .set_online = dasd_eckd_set_online,
  6004. .notify = dasd_generic_notify,
  6005. .path_event = dasd_generic_path_event,
  6006. .shutdown = dasd_generic_shutdown,
  6007. .freeze = dasd_generic_pm_freeze,
  6008. .thaw = dasd_generic_restore_device,
  6009. .restore = dasd_generic_restore_device,
  6010. .uc_handler = dasd_generic_uc_handler,
  6011. .int_class = IRQIO_DAS,
  6012. };
  6013. static struct dasd_discipline dasd_eckd_discipline = {
  6014. .owner = THIS_MODULE,
  6015. .name = "ECKD",
  6016. .ebcname = "ECKD",
  6017. .check_device = dasd_eckd_check_characteristics,
  6018. .uncheck_device = dasd_eckd_uncheck_device,
  6019. .do_analysis = dasd_eckd_do_analysis,
  6020. .verify_path = dasd_eckd_verify_path,
  6021. .basic_to_ready = dasd_eckd_basic_to_ready,
  6022. .online_to_ready = dasd_eckd_online_to_ready,
  6023. .basic_to_known = dasd_eckd_basic_to_known,
  6024. .setup_blk_queue = dasd_eckd_setup_blk_queue,
  6025. .fill_geometry = dasd_eckd_fill_geometry,
  6026. .start_IO = dasd_start_IO,
  6027. .term_IO = dasd_term_IO,
  6028. .handle_terminated_request = dasd_eckd_handle_terminated_request,
  6029. .format_device = dasd_eckd_format_device,
  6030. .check_device_format = dasd_eckd_check_device_format,
  6031. .erp_action = dasd_eckd_erp_action,
  6032. .erp_postaction = dasd_eckd_erp_postaction,
  6033. .check_for_device_change = dasd_eckd_check_for_device_change,
  6034. .build_cp = dasd_eckd_build_alias_cp,
  6035. .free_cp = dasd_eckd_free_alias_cp,
  6036. .dump_sense = dasd_eckd_dump_sense,
  6037. .dump_sense_dbf = dasd_eckd_dump_sense_dbf,
  6038. .fill_info = dasd_eckd_fill_info,
  6039. .ioctl = dasd_eckd_ioctl,
  6040. .freeze = dasd_eckd_pm_freeze,
  6041. .restore = dasd_eckd_restore_device,
  6042. .reload = dasd_eckd_reload_device,
  6043. .get_uid = dasd_eckd_get_uid,
  6044. .kick_validate = dasd_eckd_kick_validate_server,
  6045. .check_attention = dasd_eckd_check_attention,
  6046. .host_access_count = dasd_eckd_host_access_count,
  6047. .hosts_print = dasd_hosts_print,
  6048. .handle_hpf_error = dasd_eckd_handle_hpf_error,
  6049. .disable_hpf = dasd_eckd_disable_hpf_device,
  6050. .hpf_enabled = dasd_eckd_hpf_enabled,
  6051. .reset_path = dasd_eckd_reset_path,
  6052. .is_ese = dasd_eckd_is_ese,
  6053. .space_allocated = dasd_eckd_space_allocated,
  6054. .space_configured = dasd_eckd_space_configured,
  6055. .logical_capacity = dasd_eckd_logical_capacity,
  6056. .release_space = dasd_eckd_release_space,
  6057. .ext_pool_id = dasd_eckd_ext_pool_id,
  6058. .ext_size = dasd_eckd_ext_size,
  6059. .ext_pool_cap_at_warnlevel = dasd_eckd_ext_pool_cap_at_warnlevel,
  6060. .ext_pool_warn_thrshld = dasd_eckd_ext_pool_warn_thrshld,
  6061. .ext_pool_oos = dasd_eckd_ext_pool_oos,
  6062. .ext_pool_exhaust = dasd_eckd_ext_pool_exhaust,
  6063. .ese_format = dasd_eckd_ese_format,
  6064. .ese_read = dasd_eckd_ese_read,
  6065. };
  6066. static int __init
  6067. dasd_eckd_init(void)
  6068. {
  6069. int ret;
  6070. ASCEBC(dasd_eckd_discipline.ebcname, 4);
  6071. dasd_reserve_req = kmalloc(sizeof(*dasd_reserve_req),
  6072. GFP_KERNEL | GFP_DMA);
  6073. if (!dasd_reserve_req)
  6074. return -ENOMEM;
  6075. dasd_vol_info_req = kmalloc(sizeof(*dasd_vol_info_req),
  6076. GFP_KERNEL | GFP_DMA);
  6077. if (!dasd_vol_info_req)
  6078. return -ENOMEM;
  6079. path_verification_worker = kmalloc(sizeof(*path_verification_worker),
  6080. GFP_KERNEL | GFP_DMA);
  6081. if (!path_verification_worker) {
  6082. kfree(dasd_reserve_req);
  6083. kfree(dasd_vol_info_req);
  6084. return -ENOMEM;
  6085. }
  6086. rawpadpage = (void *)__get_free_page(GFP_KERNEL);
  6087. if (!rawpadpage) {
  6088. kfree(path_verification_worker);
  6089. kfree(dasd_reserve_req);
  6090. kfree(dasd_vol_info_req);
  6091. return -ENOMEM;
  6092. }
  6093. ret = ccw_driver_register(&dasd_eckd_driver);
  6094. if (!ret)
  6095. wait_for_device_probe();
  6096. else {
  6097. kfree(path_verification_worker);
  6098. kfree(dasd_reserve_req);
  6099. kfree(dasd_vol_info_req);
  6100. free_page((unsigned long)rawpadpage);
  6101. }
  6102. return ret;
  6103. }
  6104. static void __exit
  6105. dasd_eckd_cleanup(void)
  6106. {
  6107. ccw_driver_unregister(&dasd_eckd_driver);
  6108. kfree(path_verification_worker);
  6109. kfree(dasd_reserve_req);
  6110. free_page((unsigned long)rawpadpage);
  6111. }
  6112. module_init(dasd_eckd_init);
  6113. module_exit(dasd_eckd_cleanup);