pmcraid.c 169 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145
  1. /*
  2. * pmcraid.c -- driver for PMC Sierra MaxRAID controller adapters
  3. *
  4. * Written By: Anil Ravindranath<anil_ravindranath@pmc-sierra.com>
  5. * PMC-Sierra Inc
  6. *
  7. * Copyright (C) 2008, 2009 PMC Sierra Inc
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License as published by
  11. * the Free Software Foundation; either version 2 of the License, or
  12. * (at your option) any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. * GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
  22. * USA
  23. *
  24. */
  25. #include <linux/fs.h>
  26. #include <linux/init.h>
  27. #include <linux/types.h>
  28. #include <linux/errno.h>
  29. #include <linux/kernel.h>
  30. #include <linux/ioport.h>
  31. #include <linux/delay.h>
  32. #include <linux/pci.h>
  33. #include <linux/wait.h>
  34. #include <linux/spinlock.h>
  35. #include <linux/sched.h>
  36. #include <linux/interrupt.h>
  37. #include <linux/blkdev.h>
  38. #include <linux/firmware.h>
  39. #include <linux/module.h>
  40. #include <linux/moduleparam.h>
  41. #include <linux/hdreg.h>
  42. #include <linux/io.h>
  43. #include <linux/slab.h>
  44. #include <asm/irq.h>
  45. #include <asm/processor.h>
  46. #include <linux/libata.h>
  47. #include <linux/mutex.h>
  48. #include <scsi/scsi.h>
  49. #include <scsi/scsi_host.h>
  50. #include <scsi/scsi_device.h>
  51. #include <scsi/scsi_tcq.h>
  52. #include <scsi/scsi_eh.h>
  53. #include <scsi/scsi_cmnd.h>
  54. #include <scsi/scsicam.h>
  55. #include "pmcraid.h"
  56. /*
  57. * Module configuration parameters
  58. */
  59. static unsigned int pmcraid_debug_log;
  60. static unsigned int pmcraid_disable_aen;
  61. static unsigned int pmcraid_log_level = IOASC_LOG_LEVEL_MUST;
  62. static unsigned int pmcraid_enable_msix;
  63. /*
  64. * Data structures to support multiple adapters by the LLD.
  65. * pmcraid_adapter_count - count of configured adapters
  66. */
  67. static atomic_t pmcraid_adapter_count = ATOMIC_INIT(0);
  68. /*
  69. * Supporting user-level control interface through IOCTL commands.
  70. * pmcraid_major - major number to use
  71. * pmcraid_minor - minor number(s) to use
  72. */
  73. static unsigned int pmcraid_major;
  74. static struct class *pmcraid_class;
  75. DECLARE_BITMAP(pmcraid_minor, PMCRAID_MAX_ADAPTERS);
  76. /*
  77. * Module parameters
  78. */
  79. MODULE_AUTHOR("Anil Ravindranath<anil_ravindranath@pmc-sierra.com>");
  80. MODULE_DESCRIPTION("PMC Sierra MaxRAID Controller Driver");
  81. MODULE_LICENSE("GPL");
  82. MODULE_VERSION(PMCRAID_DRIVER_VERSION);
  83. module_param_named(log_level, pmcraid_log_level, uint, (S_IRUGO | S_IWUSR));
  84. MODULE_PARM_DESC(log_level,
  85. "Enables firmware error code logging, default :1 high-severity"
  86. " errors, 2: all errors including high-severity errors,"
  87. " 0: disables logging");
  88. module_param_named(debug, pmcraid_debug_log, uint, (S_IRUGO | S_IWUSR));
  89. MODULE_PARM_DESC(debug,
  90. "Enable driver verbose message logging. Set 1 to enable."
  91. "(default: 0)");
  92. module_param_named(disable_aen, pmcraid_disable_aen, uint, (S_IRUGO | S_IWUSR));
  93. MODULE_PARM_DESC(disable_aen,
  94. "Disable driver aen notifications to apps. Set 1 to disable."
  95. "(default: 0)");
  96. /* chip specific constants for PMC MaxRAID controllers (same for
  97. * 0x5220 and 0x8010
  98. */
  99. static struct pmcraid_chip_details pmcraid_chip_cfg[] = {
  100. {
  101. .ioastatus = 0x0,
  102. .ioarrin = 0x00040,
  103. .mailbox = 0x7FC30,
  104. .global_intr_mask = 0x00034,
  105. .ioa_host_intr = 0x0009C,
  106. .ioa_host_intr_clr = 0x000A0,
  107. .ioa_host_msix_intr = 0x7FC40,
  108. .ioa_host_mask = 0x7FC28,
  109. .ioa_host_mask_clr = 0x7FC28,
  110. .host_ioa_intr = 0x00020,
  111. .host_ioa_intr_clr = 0x00020,
  112. .transop_timeout = 300
  113. }
  114. };
  115. /*
  116. * PCI device ids supported by pmcraid driver
  117. */
  118. static struct pci_device_id pmcraid_pci_table[] = {
  119. { PCI_DEVICE(PCI_VENDOR_ID_PMC, PCI_DEVICE_ID_PMC_MAXRAID),
  120. 0, 0, (kernel_ulong_t)&pmcraid_chip_cfg[0]
  121. },
  122. {}
  123. };
  124. MODULE_DEVICE_TABLE(pci, pmcraid_pci_table);
  125. /**
  126. * pmcraid_slave_alloc - Prepare for commands to a device
  127. * @scsi_dev: scsi device struct
  128. *
  129. * This function is called by mid-layer prior to sending any command to the new
  130. * device. Stores resource entry details of the device in scsi_device struct.
  131. * Queuecommand uses the resource handle and other details to fill up IOARCB
  132. * while sending commands to the device.
  133. *
  134. * Return value:
  135. * 0 on success / -ENXIO if device does not exist
  136. */
  137. static int pmcraid_slave_alloc(struct scsi_device *scsi_dev)
  138. {
  139. struct pmcraid_resource_entry *temp, *res = NULL;
  140. struct pmcraid_instance *pinstance;
  141. u8 target, bus, lun;
  142. unsigned long lock_flags;
  143. int rc = -ENXIO;
  144. u16 fw_version;
  145. pinstance = shost_priv(scsi_dev->host);
  146. fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
  147. /* Driver exposes VSET and GSCSI resources only; all other device types
  148. * are not exposed. Resource list is synchronized using resource lock
  149. * so any traversal or modifications to the list should be done inside
  150. * this lock
  151. */
  152. spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
  153. list_for_each_entry(temp, &pinstance->used_res_q, queue) {
  154. /* do not expose VSETs with order-ids > MAX_VSET_TARGETS */
  155. if (RES_IS_VSET(temp->cfg_entry)) {
  156. if (fw_version <= PMCRAID_FW_VERSION_1)
  157. target = temp->cfg_entry.unique_flags1;
  158. else
  159. target = temp->cfg_entry.array_id & 0xFF;
  160. if (target > PMCRAID_MAX_VSET_TARGETS)
  161. continue;
  162. bus = PMCRAID_VSET_BUS_ID;
  163. lun = 0;
  164. } else if (RES_IS_GSCSI(temp->cfg_entry)) {
  165. target = RES_TARGET(temp->cfg_entry.resource_address);
  166. bus = PMCRAID_PHYS_BUS_ID;
  167. lun = RES_LUN(temp->cfg_entry.resource_address);
  168. } else {
  169. continue;
  170. }
  171. if (bus == scsi_dev->channel &&
  172. target == scsi_dev->id &&
  173. lun == scsi_dev->lun) {
  174. res = temp;
  175. break;
  176. }
  177. }
  178. if (res) {
  179. res->scsi_dev = scsi_dev;
  180. scsi_dev->hostdata = res;
  181. res->change_detected = 0;
  182. atomic_set(&res->read_failures, 0);
  183. atomic_set(&res->write_failures, 0);
  184. rc = 0;
  185. }
  186. spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
  187. return rc;
  188. }
  189. /**
  190. * pmcraid_slave_configure - Configures a SCSI device
  191. * @scsi_dev: scsi device struct
  192. *
  193. * This function is executed by SCSI mid layer just after a device is first
  194. * scanned (i.e. it has responded to an INQUIRY). For VSET resources, the
  195. * timeout value (default 30s) will be over-written to a higher value (60s)
  196. * and max_sectors value will be over-written to 512. It also sets queue depth
  197. * to host->cmd_per_lun value
  198. *
  199. * Return value:
  200. * 0 on success
  201. */
  202. static int pmcraid_slave_configure(struct scsi_device *scsi_dev)
  203. {
  204. struct pmcraid_resource_entry *res = scsi_dev->hostdata;
  205. if (!res)
  206. return 0;
  207. /* LLD exposes VSETs and Enclosure devices only */
  208. if (RES_IS_GSCSI(res->cfg_entry) &&
  209. scsi_dev->type != TYPE_ENCLOSURE)
  210. return -ENXIO;
  211. pmcraid_info("configuring %x:%x:%x:%x\n",
  212. scsi_dev->host->unique_id,
  213. scsi_dev->channel,
  214. scsi_dev->id,
  215. scsi_dev->lun);
  216. if (RES_IS_GSCSI(res->cfg_entry)) {
  217. scsi_dev->allow_restart = 1;
  218. } else if (RES_IS_VSET(res->cfg_entry)) {
  219. scsi_dev->allow_restart = 1;
  220. blk_queue_rq_timeout(scsi_dev->request_queue,
  221. PMCRAID_VSET_IO_TIMEOUT);
  222. blk_queue_max_hw_sectors(scsi_dev->request_queue,
  223. PMCRAID_VSET_MAX_SECTORS);
  224. }
  225. if (scsi_dev->tagged_supported &&
  226. (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry))) {
  227. scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
  228. scsi_adjust_queue_depth(scsi_dev, MSG_SIMPLE_TAG,
  229. scsi_dev->host->cmd_per_lun);
  230. } else {
  231. scsi_adjust_queue_depth(scsi_dev, 0,
  232. scsi_dev->host->cmd_per_lun);
  233. }
  234. return 0;
  235. }
  236. /**
  237. * pmcraid_slave_destroy - Unconfigure a SCSI device before removing it
  238. *
  239. * @scsi_dev: scsi device struct
  240. *
  241. * This is called by mid-layer before removing a device. Pointer assignments
  242. * done in pmcraid_slave_alloc will be reset to NULL here.
  243. *
  244. * Return value
  245. * none
  246. */
  247. static void pmcraid_slave_destroy(struct scsi_device *scsi_dev)
  248. {
  249. struct pmcraid_resource_entry *res;
  250. res = (struct pmcraid_resource_entry *)scsi_dev->hostdata;
  251. if (res)
  252. res->scsi_dev = NULL;
  253. scsi_dev->hostdata = NULL;
  254. }
  255. /**
  256. * pmcraid_change_queue_depth - Change the device's queue depth
  257. * @scsi_dev: scsi device struct
  258. * @depth: depth to set
  259. * @reason: calling context
  260. *
  261. * Return value
  262. * actual depth set
  263. */
  264. static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth,
  265. int reason)
  266. {
  267. if (reason != SCSI_QDEPTH_DEFAULT)
  268. return -EOPNOTSUPP;
  269. if (depth > PMCRAID_MAX_CMD_PER_LUN)
  270. depth = PMCRAID_MAX_CMD_PER_LUN;
  271. scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev), depth);
  272. return scsi_dev->queue_depth;
  273. }
  274. /**
  275. * pmcraid_change_queue_type - Change the device's queue type
  276. * @scsi_dev: scsi device struct
  277. * @tag: type of tags to use
  278. *
  279. * Return value:
  280. * actual queue type set
  281. */
  282. static int pmcraid_change_queue_type(struct scsi_device *scsi_dev, int tag)
  283. {
  284. struct pmcraid_resource_entry *res;
  285. res = (struct pmcraid_resource_entry *)scsi_dev->hostdata;
  286. if ((res) && scsi_dev->tagged_supported &&
  287. (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry))) {
  288. scsi_set_tag_type(scsi_dev, tag);
  289. if (tag)
  290. scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
  291. else
  292. scsi_deactivate_tcq(scsi_dev, scsi_dev->queue_depth);
  293. } else
  294. tag = 0;
  295. return tag;
  296. }
  297. /**
  298. * pmcraid_init_cmdblk - initializes a command block
  299. *
  300. * @cmd: pointer to struct pmcraid_cmd to be initialized
  301. * @index: if >=0 first time initialization; otherwise reinitialization
  302. *
  303. * Return Value
  304. * None
  305. */
  306. void pmcraid_init_cmdblk(struct pmcraid_cmd *cmd, int index)
  307. {
  308. struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);
  309. dma_addr_t dma_addr = cmd->ioa_cb_bus_addr;
  310. if (index >= 0) {
  311. /* first time initialization (called from probe) */
  312. u32 ioasa_offset =
  313. offsetof(struct pmcraid_control_block, ioasa);
  314. cmd->index = index;
  315. ioarcb->response_handle = cpu_to_le32(index << 2);
  316. ioarcb->ioarcb_bus_addr = cpu_to_le64(dma_addr);
  317. ioarcb->ioasa_bus_addr = cpu_to_le64(dma_addr + ioasa_offset);
  318. ioarcb->ioasa_len = cpu_to_le16(sizeof(struct pmcraid_ioasa));
  319. } else {
  320. /* re-initialization of various lengths, called once command is
  321. * processed by IOA
  322. */
  323. memset(&cmd->ioa_cb->ioarcb.cdb, 0, PMCRAID_MAX_CDB_LEN);
  324. ioarcb->hrrq_id = 0;
  325. ioarcb->request_flags0 = 0;
  326. ioarcb->request_flags1 = 0;
  327. ioarcb->cmd_timeout = 0;
  328. ioarcb->ioarcb_bus_addr &= (~0x1FULL);
  329. ioarcb->ioadl_bus_addr = 0;
  330. ioarcb->ioadl_length = 0;
  331. ioarcb->data_transfer_length = 0;
  332. ioarcb->add_cmd_param_length = 0;
  333. ioarcb->add_cmd_param_offset = 0;
  334. cmd->ioa_cb->ioasa.ioasc = 0;
  335. cmd->ioa_cb->ioasa.residual_data_length = 0;
  336. cmd->time_left = 0;
  337. }
  338. cmd->cmd_done = NULL;
  339. cmd->scsi_cmd = NULL;
  340. cmd->release = 0;
  341. cmd->completion_req = 0;
  342. cmd->sense_buffer = 0;
  343. cmd->sense_buffer_dma = 0;
  344. cmd->dma_handle = 0;
  345. init_timer(&cmd->timer);
  346. }
  347. /**
  348. * pmcraid_reinit_cmdblk - reinitialize a command block
  349. *
  350. * @cmd: pointer to struct pmcraid_cmd to be reinitialized
  351. *
  352. * Return Value
  353. * None
  354. */
  355. static void pmcraid_reinit_cmdblk(struct pmcraid_cmd *cmd)
  356. {
  357. pmcraid_init_cmdblk(cmd, -1);
  358. }
  359. /**
  360. * pmcraid_get_free_cmd - get a free cmd block from command block pool
  361. * @pinstance: adapter instance structure
  362. *
  363. * Return Value:
  364. * returns pointer to cmd block or NULL if no blocks are available
  365. */
  366. static struct pmcraid_cmd *pmcraid_get_free_cmd(
  367. struct pmcraid_instance *pinstance
  368. )
  369. {
  370. struct pmcraid_cmd *cmd = NULL;
  371. unsigned long lock_flags;
  372. /* free cmd block list is protected by free_pool_lock */
  373. spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);
  374. if (!list_empty(&pinstance->free_cmd_pool)) {
  375. cmd = list_entry(pinstance->free_cmd_pool.next,
  376. struct pmcraid_cmd, free_list);
  377. list_del(&cmd->free_list);
  378. }
  379. spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);
  380. /* Initialize the command block before giving it the caller */
  381. if (cmd != NULL)
  382. pmcraid_reinit_cmdblk(cmd);
  383. return cmd;
  384. }
  385. /**
  386. * pmcraid_return_cmd - return a completed command block back into free pool
  387. * @cmd: pointer to the command block
  388. *
  389. * Return Value:
  390. * nothing
  391. */
  392. void pmcraid_return_cmd(struct pmcraid_cmd *cmd)
  393. {
  394. struct pmcraid_instance *pinstance = cmd->drv_inst;
  395. unsigned long lock_flags;
  396. spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);
  397. list_add_tail(&cmd->free_list, &pinstance->free_cmd_pool);
  398. spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);
  399. }
  400. /**
  401. * pmcraid_read_interrupts - reads IOA interrupts
  402. *
  403. * @pinstance: pointer to adapter instance structure
  404. *
  405. * Return value
  406. * interrupts read from IOA
  407. */
  408. static u32 pmcraid_read_interrupts(struct pmcraid_instance *pinstance)
  409. {
  410. return (pinstance->interrupt_mode) ?
  411. ioread32(pinstance->int_regs.ioa_host_msix_interrupt_reg) :
  412. ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
  413. }
  414. /**
  415. * pmcraid_disable_interrupts - Masks and clears all specified interrupts
  416. *
  417. * @pinstance: pointer to per adapter instance structure
  418. * @intrs: interrupts to disable
  419. *
  420. * Return Value
  421. * None
  422. */
  423. static void pmcraid_disable_interrupts(
  424. struct pmcraid_instance *pinstance,
  425. u32 intrs
  426. )
  427. {
  428. u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);
  429. u32 nmask = gmask | GLOBAL_INTERRUPT_MASK;
  430. iowrite32(intrs, pinstance->int_regs.ioa_host_interrupt_clr_reg);
  431. iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);
  432. ioread32(pinstance->int_regs.global_interrupt_mask_reg);
  433. if (!pinstance->interrupt_mode) {
  434. iowrite32(intrs,
  435. pinstance->int_regs.ioa_host_interrupt_mask_reg);
  436. ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
  437. }
  438. }
  439. /**
  440. * pmcraid_enable_interrupts - Enables specified interrupts
  441. *
  442. * @pinstance: pointer to per adapter instance structure
  443. * @intr: interrupts to enable
  444. *
  445. * Return Value
  446. * None
  447. */
  448. static void pmcraid_enable_interrupts(
  449. struct pmcraid_instance *pinstance,
  450. u32 intrs
  451. )
  452. {
  453. u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);
  454. u32 nmask = gmask & (~GLOBAL_INTERRUPT_MASK);
  455. iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);
  456. if (!pinstance->interrupt_mode) {
  457. iowrite32(~intrs,
  458. pinstance->int_regs.ioa_host_interrupt_mask_reg);
  459. ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
  460. }
  461. pmcraid_info("enabled interrupts global mask = %x intr_mask = %x\n",
  462. ioread32(pinstance->int_regs.global_interrupt_mask_reg),
  463. ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg));
  464. }
  465. /**
  466. * pmcraid_clr_trans_op - clear trans to op interrupt
  467. *
  468. * @pinstance: pointer to per adapter instance structure
  469. *
  470. * Return Value
  471. * None
  472. */
  473. static void pmcraid_clr_trans_op(
  474. struct pmcraid_instance *pinstance
  475. )
  476. {
  477. unsigned long lock_flags;
  478. if (!pinstance->interrupt_mode) {
  479. iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
  480. pinstance->int_regs.ioa_host_interrupt_mask_reg);
  481. ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
  482. iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
  483. pinstance->int_regs.ioa_host_interrupt_clr_reg);
  484. ioread32(pinstance->int_regs.ioa_host_interrupt_clr_reg);
  485. }
  486. if (pinstance->reset_cmd != NULL) {
  487. del_timer(&pinstance->reset_cmd->timer);
  488. spin_lock_irqsave(
  489. pinstance->host->host_lock, lock_flags);
  490. pinstance->reset_cmd->cmd_done(pinstance->reset_cmd);
  491. spin_unlock_irqrestore(
  492. pinstance->host->host_lock, lock_flags);
  493. }
  494. }
  495. /**
  496. * pmcraid_reset_type - Determine the required reset type
  497. * @pinstance: pointer to adapter instance structure
  498. *
  499. * IOA requires hard reset if any of the following conditions is true.
  500. * 1. If HRRQ valid interrupt is not masked
  501. * 2. IOA reset alert doorbell is set
  502. * 3. If there are any error interrupts
  503. */
  504. static void pmcraid_reset_type(struct pmcraid_instance *pinstance)
  505. {
  506. u32 mask;
  507. u32 intrs;
  508. u32 alerts;
  509. mask = ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
  510. intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
  511. alerts = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
  512. if ((mask & INTRS_HRRQ_VALID) == 0 ||
  513. (alerts & DOORBELL_IOA_RESET_ALERT) ||
  514. (intrs & PMCRAID_ERROR_INTERRUPTS)) {
  515. pmcraid_info("IOA requires hard reset\n");
  516. pinstance->ioa_hard_reset = 1;
  517. }
  518. /* If unit check is active, trigger the dump */
  519. if (intrs & INTRS_IOA_UNIT_CHECK)
  520. pinstance->ioa_unit_check = 1;
  521. }
  522. /**
  523. * pmcraid_bist_done - completion function for PCI BIST
  524. * @cmd: pointer to reset command
  525. * Return Value
  526. * none
  527. */
  528. static void pmcraid_ioa_reset(struct pmcraid_cmd *);
  529. static void pmcraid_bist_done(struct pmcraid_cmd *cmd)
  530. {
  531. struct pmcraid_instance *pinstance = cmd->drv_inst;
  532. unsigned long lock_flags;
  533. int rc;
  534. u16 pci_reg;
  535. rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);
  536. /* If PCI config space can't be accessed wait for another two secs */
  537. if ((rc != PCIBIOS_SUCCESSFUL || (!(pci_reg & PCI_COMMAND_MEMORY))) &&
  538. cmd->time_left > 0) {
  539. pmcraid_info("BIST not complete, waiting another 2 secs\n");
  540. cmd->timer.expires = jiffies + cmd->time_left;
  541. cmd->time_left = 0;
  542. cmd->timer.data = (unsigned long)cmd;
  543. cmd->timer.function =
  544. (void (*)(unsigned long))pmcraid_bist_done;
  545. add_timer(&cmd->timer);
  546. } else {
  547. cmd->time_left = 0;
  548. pmcraid_info("BIST is complete, proceeding with reset\n");
  549. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  550. pmcraid_ioa_reset(cmd);
  551. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  552. }
  553. }
  554. /**
  555. * pmcraid_start_bist - starts BIST
  556. * @cmd: pointer to reset cmd
  557. * Return Value
  558. * none
  559. */
  560. static void pmcraid_start_bist(struct pmcraid_cmd *cmd)
  561. {
  562. struct pmcraid_instance *pinstance = cmd->drv_inst;
  563. u32 doorbells, intrs;
  564. /* proceed with bist and wait for 2 seconds */
  565. iowrite32(DOORBELL_IOA_START_BIST,
  566. pinstance->int_regs.host_ioa_interrupt_reg);
  567. doorbells = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
  568. intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
  569. pmcraid_info("doorbells after start bist: %x intrs: %x\n",
  570. doorbells, intrs);
  571. cmd->time_left = msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);
  572. cmd->timer.data = (unsigned long)cmd;
  573. cmd->timer.expires = jiffies + msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);
  574. cmd->timer.function = (void (*)(unsigned long))pmcraid_bist_done;
  575. add_timer(&cmd->timer);
  576. }
  577. /**
  578. * pmcraid_reset_alert_done - completion routine for reset_alert
  579. * @cmd: pointer to command block used in reset sequence
  580. * Return value
  581. * None
  582. */
  583. static void pmcraid_reset_alert_done(struct pmcraid_cmd *cmd)
  584. {
  585. struct pmcraid_instance *pinstance = cmd->drv_inst;
  586. u32 status = ioread32(pinstance->ioa_status);
  587. unsigned long lock_flags;
  588. /* if the critical operation in progress bit is set or the wait times
  589. * out, invoke reset engine to proceed with hard reset. If there is
  590. * some more time to wait, restart the timer
  591. */
  592. if (((status & INTRS_CRITICAL_OP_IN_PROGRESS) == 0) ||
  593. cmd->time_left <= 0) {
  594. pmcraid_info("critical op is reset proceeding with reset\n");
  595. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  596. pmcraid_ioa_reset(cmd);
  597. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  598. } else {
  599. pmcraid_info("critical op is not yet reset waiting again\n");
  600. /* restart timer if some more time is available to wait */
  601. cmd->time_left -= PMCRAID_CHECK_FOR_RESET_TIMEOUT;
  602. cmd->timer.data = (unsigned long)cmd;
  603. cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;
  604. cmd->timer.function =
  605. (void (*)(unsigned long))pmcraid_reset_alert_done;
  606. add_timer(&cmd->timer);
  607. }
  608. }
  609. /**
  610. * pmcraid_reset_alert - alerts IOA for a possible reset
  611. * @cmd : command block to be used for reset sequence.
  612. *
  613. * Return Value
  614. * returns 0 if pci config-space is accessible and RESET_DOORBELL is
  615. * successfully written to IOA. Returns non-zero in case pci_config_space
  616. * is not accessible
  617. */
  618. static void pmcraid_notify_ioastate(struct pmcraid_instance *, u32);
  619. static void pmcraid_reset_alert(struct pmcraid_cmd *cmd)
  620. {
  621. struct pmcraid_instance *pinstance = cmd->drv_inst;
  622. u32 doorbells;
  623. int rc;
  624. u16 pci_reg;
  625. /* If we are able to access IOA PCI config space, alert IOA that we are
  626. * going to reset it soon. This enables IOA to preserv persistent error
  627. * data if any. In case memory space is not accessible, proceed with
  628. * BIST or slot_reset
  629. */
  630. rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);
  631. if ((rc == PCIBIOS_SUCCESSFUL) && (pci_reg & PCI_COMMAND_MEMORY)) {
  632. /* wait for IOA permission i.e until CRITICAL_OPERATION bit is
  633. * reset IOA doesn't generate any interrupts when CRITICAL
  634. * OPERATION bit is reset. A timer is started to wait for this
  635. * bit to be reset.
  636. */
  637. cmd->time_left = PMCRAID_RESET_TIMEOUT;
  638. cmd->timer.data = (unsigned long)cmd;
  639. cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;
  640. cmd->timer.function =
  641. (void (*)(unsigned long))pmcraid_reset_alert_done;
  642. add_timer(&cmd->timer);
  643. iowrite32(DOORBELL_IOA_RESET_ALERT,
  644. pinstance->int_regs.host_ioa_interrupt_reg);
  645. doorbells =
  646. ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
  647. pmcraid_info("doorbells after reset alert: %x\n", doorbells);
  648. } else {
  649. pmcraid_info("PCI config is not accessible starting BIST\n");
  650. pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;
  651. pmcraid_start_bist(cmd);
  652. }
  653. }
  654. /**
  655. * pmcraid_timeout_handler - Timeout handler for internally generated ops
  656. *
  657. * @cmd : pointer to command structure, that got timedout
  658. *
  659. * This function blocks host requests and initiates an adapter reset.
  660. *
  661. * Return value:
  662. * None
  663. */
  664. static void pmcraid_timeout_handler(struct pmcraid_cmd *cmd)
  665. {
  666. struct pmcraid_instance *pinstance = cmd->drv_inst;
  667. unsigned long lock_flags;
  668. dev_info(&pinstance->pdev->dev,
  669. "Adapter being reset due to cmd(CDB[0] = %x) timeout\n",
  670. cmd->ioa_cb->ioarcb.cdb[0]);
  671. /* Command timeouts result in hard reset sequence. The command that got
  672. * timed out may be the one used as part of reset sequence. In this
  673. * case restart reset sequence using the same command block even if
  674. * reset is in progress. Otherwise fail this command and get a free
  675. * command block to restart the reset sequence.
  676. */
  677. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  678. if (!pinstance->ioa_reset_in_progress) {
  679. pinstance->ioa_reset_attempts = 0;
  680. cmd = pmcraid_get_free_cmd(pinstance);
  681. /* If we are out of command blocks, just return here itself.
  682. * Some other command's timeout handler can do the reset job
  683. */
  684. if (cmd == NULL) {
  685. spin_unlock_irqrestore(pinstance->host->host_lock,
  686. lock_flags);
  687. pmcraid_err("no free cmnd block for timeout handler\n");
  688. return;
  689. }
  690. pinstance->reset_cmd = cmd;
  691. pinstance->ioa_reset_in_progress = 1;
  692. } else {
  693. pmcraid_info("reset is already in progress\n");
  694. if (pinstance->reset_cmd != cmd) {
  695. /* This command should have been given to IOA, this
  696. * command will be completed by fail_outstanding_cmds
  697. * anyway
  698. */
  699. pmcraid_err("cmd is pending but reset in progress\n");
  700. }
  701. /* If this command was being used as part of the reset
  702. * sequence, set cmd_done pointer to pmcraid_ioa_reset. This
  703. * causes fail_outstanding_commands not to return the command
  704. * block back to free pool
  705. */
  706. if (cmd == pinstance->reset_cmd)
  707. cmd->cmd_done = pmcraid_ioa_reset;
  708. }
  709. /* Notify apps of important IOA bringup/bringdown sequences */
  710. if (pinstance->scn.ioa_state != PMC_DEVICE_EVENT_RESET_START &&
  711. pinstance->scn.ioa_state != PMC_DEVICE_EVENT_SHUTDOWN_START)
  712. pmcraid_notify_ioastate(pinstance,
  713. PMC_DEVICE_EVENT_RESET_START);
  714. pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
  715. scsi_block_requests(pinstance->host);
  716. pmcraid_reset_alert(cmd);
  717. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  718. }
  719. /**
  720. * pmcraid_internal_done - completion routine for internally generated cmds
  721. *
  722. * @cmd: command that got response from IOA
  723. *
  724. * Return Value:
  725. * none
  726. */
  727. static void pmcraid_internal_done(struct pmcraid_cmd *cmd)
  728. {
  729. pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",
  730. cmd->ioa_cb->ioarcb.cdb[0],
  731. le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
  732. /* Some of the internal commands are sent with callers blocking for the
  733. * response. Same will be indicated as part of cmd->completion_req
  734. * field. Response path needs to wake up any waiters waiting for cmd
  735. * completion if this flag is set.
  736. */
  737. if (cmd->completion_req) {
  738. cmd->completion_req = 0;
  739. complete(&cmd->wait_for_completion);
  740. }
  741. /* most of the internal commands are completed by caller itself, so
  742. * no need to return the command block back to free pool until we are
  743. * required to do so (e.g once done with initialization).
  744. */
  745. if (cmd->release) {
  746. cmd->release = 0;
  747. pmcraid_return_cmd(cmd);
  748. }
  749. }
  750. /**
  751. * pmcraid_reinit_cfgtable_done - done function for cfg table reinitialization
  752. *
  753. * @cmd: command that got response from IOA
  754. *
  755. * This routine is called after driver re-reads configuration table due to a
  756. * lost CCN. It returns the command block back to free pool and schedules
  757. * worker thread to add/delete devices into the system.
  758. *
  759. * Return Value:
  760. * none
  761. */
  762. static void pmcraid_reinit_cfgtable_done(struct pmcraid_cmd *cmd)
  763. {
  764. pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",
  765. cmd->ioa_cb->ioarcb.cdb[0],
  766. le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
  767. if (cmd->release) {
  768. cmd->release = 0;
  769. pmcraid_return_cmd(cmd);
  770. }
  771. pmcraid_info("scheduling worker for config table reinitialization\n");
  772. schedule_work(&cmd->drv_inst->worker_q);
  773. }
  774. /**
  775. * pmcraid_erp_done - Process completion of SCSI error response from device
  776. * @cmd: pmcraid_command
  777. *
  778. * This function copies the sense buffer into the scsi_cmd struct and completes
  779. * scsi_cmd by calling scsi_done function.
  780. *
  781. * Return value:
  782. * none
  783. */
  784. static void pmcraid_erp_done(struct pmcraid_cmd *cmd)
  785. {
  786. struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
  787. struct pmcraid_instance *pinstance = cmd->drv_inst;
  788. u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
  789. if (PMCRAID_IOASC_SENSE_KEY(ioasc) > 0) {
  790. scsi_cmd->result |= (DID_ERROR << 16);
  791. scmd_printk(KERN_INFO, scsi_cmd,
  792. "command CDB[0] = %x failed with IOASC: 0x%08X\n",
  793. cmd->ioa_cb->ioarcb.cdb[0], ioasc);
  794. }
  795. /* if we had allocated sense buffers for request sense, copy the sense
  796. * release the buffers
  797. */
  798. if (cmd->sense_buffer != NULL) {
  799. memcpy(scsi_cmd->sense_buffer,
  800. cmd->sense_buffer,
  801. SCSI_SENSE_BUFFERSIZE);
  802. pci_free_consistent(pinstance->pdev,
  803. SCSI_SENSE_BUFFERSIZE,
  804. cmd->sense_buffer, cmd->sense_buffer_dma);
  805. cmd->sense_buffer = NULL;
  806. cmd->sense_buffer_dma = 0;
  807. }
  808. scsi_dma_unmap(scsi_cmd);
  809. pmcraid_return_cmd(cmd);
  810. scsi_cmd->scsi_done(scsi_cmd);
  811. }
  812. /**
  813. * pmcraid_fire_command - sends an IOA command to adapter
  814. *
  815. * This function adds the given block into pending command list
  816. * and returns without waiting
  817. *
  818. * @cmd : command to be sent to the device
  819. *
  820. * Return Value
  821. * None
  822. */
  823. static void _pmcraid_fire_command(struct pmcraid_cmd *cmd)
  824. {
  825. struct pmcraid_instance *pinstance = cmd->drv_inst;
  826. unsigned long lock_flags;
  827. /* Add this command block to pending cmd pool. We do this prior to
  828. * writting IOARCB to ioarrin because IOA might complete the command
  829. * by the time we are about to add it to the list. Response handler
  830. * (isr/tasklet) looks for cmd block in the pending pending list.
  831. */
  832. spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
  833. list_add_tail(&cmd->free_list, &pinstance->pending_cmd_pool);
  834. spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);
  835. atomic_inc(&pinstance->outstanding_cmds);
  836. /* driver writes lower 32-bit value of IOARCB address only */
  837. mb();
  838. iowrite32(le32_to_cpu(cmd->ioa_cb->ioarcb.ioarcb_bus_addr),
  839. pinstance->ioarrin);
  840. }
  841. /**
  842. * pmcraid_send_cmd - fires a command to IOA
  843. *
  844. * This function also sets up timeout function, and command completion
  845. * function
  846. *
  847. * @cmd: pointer to the command block to be fired to IOA
  848. * @cmd_done: command completion function, called once IOA responds
  849. * @timeout: timeout to wait for this command completion
  850. * @timeout_func: timeout handler
  851. *
  852. * Return value
  853. * none
  854. */
  855. static void pmcraid_send_cmd(
  856. struct pmcraid_cmd *cmd,
  857. void (*cmd_done) (struct pmcraid_cmd *),
  858. unsigned long timeout,
  859. void (*timeout_func) (struct pmcraid_cmd *)
  860. )
  861. {
  862. /* initialize done function */
  863. cmd->cmd_done = cmd_done;
  864. if (timeout_func) {
  865. /* setup timeout handler */
  866. cmd->timer.data = (unsigned long)cmd;
  867. cmd->timer.expires = jiffies + timeout;
  868. cmd->timer.function = (void (*)(unsigned long))timeout_func;
  869. add_timer(&cmd->timer);
  870. }
  871. /* fire the command to IOA */
  872. _pmcraid_fire_command(cmd);
  873. }
  874. /**
  875. * pmcraid_ioa_shutdown_done - completion function for IOA shutdown command
  876. * @cmd: pointer to the command block used for sending IOA shutdown command
  877. *
  878. * Return value
  879. * None
  880. */
  881. static void pmcraid_ioa_shutdown_done(struct pmcraid_cmd *cmd)
  882. {
  883. struct pmcraid_instance *pinstance = cmd->drv_inst;
  884. unsigned long lock_flags;
  885. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  886. pmcraid_ioa_reset(cmd);
  887. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  888. }
  889. /**
  890. * pmcraid_ioa_shutdown - sends SHUTDOWN command to ioa
  891. *
  892. * @cmd: pointer to the command block used as part of reset sequence
  893. *
  894. * Return Value
  895. * None
  896. */
  897. static void pmcraid_ioa_shutdown(struct pmcraid_cmd *cmd)
  898. {
  899. pmcraid_info("response for Cancel CCN CDB[0] = %x ioasc = %x\n",
  900. cmd->ioa_cb->ioarcb.cdb[0],
  901. le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
  902. /* Note that commands sent during reset require next command to be sent
  903. * to IOA. Hence reinit the done function as well as timeout function
  904. */
  905. pmcraid_reinit_cmdblk(cmd);
  906. cmd->ioa_cb->ioarcb.request_type = REQ_TYPE_IOACMD;
  907. cmd->ioa_cb->ioarcb.resource_handle =
  908. cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
  909. cmd->ioa_cb->ioarcb.cdb[0] = PMCRAID_IOA_SHUTDOWN;
  910. cmd->ioa_cb->ioarcb.cdb[1] = PMCRAID_SHUTDOWN_NORMAL;
  911. /* fire shutdown command to hardware. */
  912. pmcraid_info("firing normal shutdown command (%d) to IOA\n",
  913. le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle));
  914. pmcraid_notify_ioastate(cmd->drv_inst, PMC_DEVICE_EVENT_SHUTDOWN_START);
  915. pmcraid_send_cmd(cmd, pmcraid_ioa_shutdown_done,
  916. PMCRAID_SHUTDOWN_TIMEOUT,
  917. pmcraid_timeout_handler);
  918. }
  919. /**
  920. * pmcraid_get_fwversion_done - completion function for get_fwversion
  921. *
  922. * @cmd: pointer to command block used to send INQUIRY command
  923. *
  924. * Return Value
  925. * none
  926. */
  927. static void pmcraid_querycfg(struct pmcraid_cmd *);
  928. static void pmcraid_get_fwversion_done(struct pmcraid_cmd *cmd)
  929. {
  930. struct pmcraid_instance *pinstance = cmd->drv_inst;
  931. u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
  932. unsigned long lock_flags;
  933. /* configuration table entry size depends on firmware version. If fw
  934. * version is not known, it is not possible to interpret IOA config
  935. * table
  936. */
  937. if (ioasc) {
  938. pmcraid_err("IOA Inquiry failed with %x\n", ioasc);
  939. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  940. pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
  941. pmcraid_reset_alert(cmd);
  942. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  943. } else {
  944. pmcraid_querycfg(cmd);
  945. }
  946. }
  947. /**
  948. * pmcraid_get_fwversion - reads firmware version information
  949. *
  950. * @cmd: pointer to command block used to send INQUIRY command
  951. *
  952. * Return Value
  953. * none
  954. */
  955. static void pmcraid_get_fwversion(struct pmcraid_cmd *cmd)
  956. {
  957. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  958. struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
  959. struct pmcraid_instance *pinstance = cmd->drv_inst;
  960. u16 data_size = sizeof(struct pmcraid_inquiry_data);
  961. pmcraid_reinit_cmdblk(cmd);
  962. ioarcb->request_type = REQ_TYPE_SCSI;
  963. ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
  964. ioarcb->cdb[0] = INQUIRY;
  965. ioarcb->cdb[1] = 1;
  966. ioarcb->cdb[2] = 0xD0;
  967. ioarcb->cdb[3] = (data_size >> 8) & 0xFF;
  968. ioarcb->cdb[4] = data_size & 0xFF;
  969. /* Since entire inquiry data it can be part of IOARCB itself
  970. */
  971. ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
  972. offsetof(struct pmcraid_ioarcb,
  973. add_data.u.ioadl[0]));
  974. ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
  975. ioarcb->ioarcb_bus_addr &= ~(0x1FULL);
  976. ioarcb->request_flags0 |= NO_LINK_DESCS;
  977. ioarcb->data_transfer_length = cpu_to_le32(data_size);
  978. ioadl = &(ioarcb->add_data.u.ioadl[0]);
  979. ioadl->flags = IOADL_FLAGS_LAST_DESC;
  980. ioadl->address = cpu_to_le64(pinstance->inq_data_baddr);
  981. ioadl->data_len = cpu_to_le32(data_size);
  982. pmcraid_send_cmd(cmd, pmcraid_get_fwversion_done,
  983. PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
  984. }
  985. /**
  986. * pmcraid_identify_hrrq - registers host rrq buffers with IOA
  987. * @cmd: pointer to command block to be used for identify hrrq
  988. *
  989. * Return Value
  990. * none
  991. */
  992. static void pmcraid_identify_hrrq(struct pmcraid_cmd *cmd)
  993. {
  994. struct pmcraid_instance *pinstance = cmd->drv_inst;
  995. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  996. int index = cmd->hrrq_index;
  997. __be64 hrrq_addr = cpu_to_be64(pinstance->hrrq_start_bus_addr[index]);
  998. u32 hrrq_size = cpu_to_be32(sizeof(u32) * PMCRAID_MAX_CMD);
  999. void (*done_function)(struct pmcraid_cmd *);
  1000. pmcraid_reinit_cmdblk(cmd);
  1001. cmd->hrrq_index = index + 1;
  1002. if (cmd->hrrq_index < pinstance->num_hrrq) {
  1003. done_function = pmcraid_identify_hrrq;
  1004. } else {
  1005. cmd->hrrq_index = 0;
  1006. done_function = pmcraid_get_fwversion;
  1007. }
  1008. /* Initialize ioarcb */
  1009. ioarcb->request_type = REQ_TYPE_IOACMD;
  1010. ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
  1011. /* initialize the hrrq number where IOA will respond to this command */
  1012. ioarcb->hrrq_id = index;
  1013. ioarcb->cdb[0] = PMCRAID_IDENTIFY_HRRQ;
  1014. ioarcb->cdb[1] = index;
  1015. /* IOA expects 64-bit pci address to be written in B.E format
  1016. * (i.e cdb[2]=MSByte..cdb[9]=LSB.
  1017. */
  1018. pmcraid_info("HRRQ_IDENTIFY with hrrq:ioarcb:index => %llx:%llx:%x\n",
  1019. hrrq_addr, ioarcb->ioarcb_bus_addr, index);
  1020. memcpy(&(ioarcb->cdb[2]), &hrrq_addr, sizeof(hrrq_addr));
  1021. memcpy(&(ioarcb->cdb[10]), &hrrq_size, sizeof(hrrq_size));
  1022. /* Subsequent commands require HRRQ identification to be successful.
  1023. * Note that this gets called even during reset from SCSI mid-layer
  1024. * or tasklet
  1025. */
  1026. pmcraid_send_cmd(cmd, done_function,
  1027. PMCRAID_INTERNAL_TIMEOUT,
  1028. pmcraid_timeout_handler);
  1029. }
  1030. static void pmcraid_process_ccn(struct pmcraid_cmd *cmd);
  1031. static void pmcraid_process_ldn(struct pmcraid_cmd *cmd);
  1032. /**
  1033. * pmcraid_send_hcam_cmd - send an initialized command block(HCAM) to IOA
  1034. *
  1035. * @cmd: initialized command block pointer
  1036. *
  1037. * Return Value
  1038. * none
  1039. */
  1040. static void pmcraid_send_hcam_cmd(struct pmcraid_cmd *cmd)
  1041. {
  1042. if (cmd->ioa_cb->ioarcb.cdb[1] == PMCRAID_HCAM_CODE_CONFIG_CHANGE)
  1043. atomic_set(&(cmd->drv_inst->ccn.ignore), 0);
  1044. else
  1045. atomic_set(&(cmd->drv_inst->ldn.ignore), 0);
  1046. pmcraid_send_cmd(cmd, cmd->cmd_done, 0, NULL);
  1047. }
  1048. /**
  1049. * pmcraid_init_hcam - send an initialized command block(HCAM) to IOA
  1050. *
  1051. * @pinstance: pointer to adapter instance structure
  1052. * @type: HCAM type
  1053. *
  1054. * Return Value
  1055. * pointer to initialized pmcraid_cmd structure or NULL
  1056. */
  1057. static struct pmcraid_cmd *pmcraid_init_hcam
  1058. (
  1059. struct pmcraid_instance *pinstance,
  1060. u8 type
  1061. )
  1062. {
  1063. struct pmcraid_cmd *cmd;
  1064. struct pmcraid_ioarcb *ioarcb;
  1065. struct pmcraid_ioadl_desc *ioadl;
  1066. struct pmcraid_hostrcb *hcam;
  1067. void (*cmd_done) (struct pmcraid_cmd *);
  1068. dma_addr_t dma;
  1069. int rcb_size;
  1070. cmd = pmcraid_get_free_cmd(pinstance);
  1071. if (!cmd) {
  1072. pmcraid_err("no free command blocks for hcam\n");
  1073. return cmd;
  1074. }
  1075. if (type == PMCRAID_HCAM_CODE_CONFIG_CHANGE) {
  1076. rcb_size = sizeof(struct pmcraid_hcam_ccn_ext);
  1077. cmd_done = pmcraid_process_ccn;
  1078. dma = pinstance->ccn.baddr + PMCRAID_AEN_HDR_SIZE;
  1079. hcam = &pinstance->ccn;
  1080. } else {
  1081. rcb_size = sizeof(struct pmcraid_hcam_ldn);
  1082. cmd_done = pmcraid_process_ldn;
  1083. dma = pinstance->ldn.baddr + PMCRAID_AEN_HDR_SIZE;
  1084. hcam = &pinstance->ldn;
  1085. }
  1086. /* initialize command pointer used for HCAM registration */
  1087. hcam->cmd = cmd;
  1088. ioarcb = &cmd->ioa_cb->ioarcb;
  1089. ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
  1090. offsetof(struct pmcraid_ioarcb,
  1091. add_data.u.ioadl[0]));
  1092. ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
  1093. ioadl = ioarcb->add_data.u.ioadl;
  1094. /* Initialize ioarcb */
  1095. ioarcb->request_type = REQ_TYPE_HCAM;
  1096. ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
  1097. ioarcb->cdb[0] = PMCRAID_HOST_CONTROLLED_ASYNC;
  1098. ioarcb->cdb[1] = type;
  1099. ioarcb->cdb[7] = (rcb_size >> 8) & 0xFF;
  1100. ioarcb->cdb[8] = (rcb_size) & 0xFF;
  1101. ioarcb->data_transfer_length = cpu_to_le32(rcb_size);
  1102. ioadl[0].flags |= IOADL_FLAGS_READ_LAST;
  1103. ioadl[0].data_len = cpu_to_le32(rcb_size);
  1104. ioadl[0].address = cpu_to_le32(dma);
  1105. cmd->cmd_done = cmd_done;
  1106. return cmd;
  1107. }
  1108. /**
  1109. * pmcraid_send_hcam - Send an HCAM to IOA
  1110. * @pinstance: ioa config struct
  1111. * @type: HCAM type
  1112. *
  1113. * This function will send a Host Controlled Async command to IOA.
  1114. *
  1115. * Return value:
  1116. * none
  1117. */
  1118. static void pmcraid_send_hcam(struct pmcraid_instance *pinstance, u8 type)
  1119. {
  1120. struct pmcraid_cmd *cmd = pmcraid_init_hcam(pinstance, type);
  1121. pmcraid_send_hcam_cmd(cmd);
  1122. }
  1123. /**
  1124. * pmcraid_prepare_cancel_cmd - prepares a command block to abort another
  1125. *
  1126. * @cmd: pointer to cmd that is used as cancelling command
  1127. * @cmd_to_cancel: pointer to the command that needs to be cancelled
  1128. */
  1129. static void pmcraid_prepare_cancel_cmd(
  1130. struct pmcraid_cmd *cmd,
  1131. struct pmcraid_cmd *cmd_to_cancel
  1132. )
  1133. {
  1134. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  1135. __be64 ioarcb_addr = cmd_to_cancel->ioa_cb->ioarcb.ioarcb_bus_addr;
  1136. /* Get the resource handle to where the command to be aborted has been
  1137. * sent.
  1138. */
  1139. ioarcb->resource_handle = cmd_to_cancel->ioa_cb->ioarcb.resource_handle;
  1140. ioarcb->request_type = REQ_TYPE_IOACMD;
  1141. memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
  1142. ioarcb->cdb[0] = PMCRAID_ABORT_CMD;
  1143. /* IOARCB address of the command to be cancelled is given in
  1144. * cdb[2]..cdb[9] is Big-Endian format. Note that length bits in
  1145. * IOARCB address are not masked.
  1146. */
  1147. ioarcb_addr = cpu_to_be64(ioarcb_addr);
  1148. memcpy(&(ioarcb->cdb[2]), &ioarcb_addr, sizeof(ioarcb_addr));
  1149. }
  1150. /**
  1151. * pmcraid_cancel_hcam - sends ABORT task to abort a given HCAM
  1152. *
  1153. * @cmd: command to be used as cancelling command
  1154. * @type: HCAM type
  1155. * @cmd_done: op done function for the cancelling command
  1156. */
  1157. static void pmcraid_cancel_hcam(
  1158. struct pmcraid_cmd *cmd,
  1159. u8 type,
  1160. void (*cmd_done) (struct pmcraid_cmd *)
  1161. )
  1162. {
  1163. struct pmcraid_instance *pinstance;
  1164. struct pmcraid_hostrcb *hcam;
  1165. pinstance = cmd->drv_inst;
  1166. hcam = (type == PMCRAID_HCAM_CODE_LOG_DATA) ?
  1167. &pinstance->ldn : &pinstance->ccn;
  1168. /* prepare for cancelling previous hcam command. If the HCAM is
  1169. * currently not pending with IOA, we would have hcam->cmd as non-null
  1170. */
  1171. if (hcam->cmd == NULL)
  1172. return;
  1173. pmcraid_prepare_cancel_cmd(cmd, hcam->cmd);
  1174. /* writing to IOARRIN must be protected by host_lock, as mid-layer
  1175. * schedule queuecommand while we are doing this
  1176. */
  1177. pmcraid_send_cmd(cmd, cmd_done,
  1178. PMCRAID_INTERNAL_TIMEOUT,
  1179. pmcraid_timeout_handler);
  1180. }
  1181. /**
  1182. * pmcraid_cancel_ccn - cancel CCN HCAM already registered with IOA
  1183. *
  1184. * @cmd: command block to be used for cancelling the HCAM
  1185. */
  1186. static void pmcraid_cancel_ccn(struct pmcraid_cmd *cmd)
  1187. {
  1188. pmcraid_info("response for Cancel LDN CDB[0] = %x ioasc = %x\n",
  1189. cmd->ioa_cb->ioarcb.cdb[0],
  1190. le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
  1191. pmcraid_reinit_cmdblk(cmd);
  1192. pmcraid_cancel_hcam(cmd,
  1193. PMCRAID_HCAM_CODE_CONFIG_CHANGE,
  1194. pmcraid_ioa_shutdown);
  1195. }
  1196. /**
  1197. * pmcraid_cancel_ldn - cancel LDN HCAM already registered with IOA
  1198. *
  1199. * @cmd: command block to be used for cancelling the HCAM
  1200. */
  1201. static void pmcraid_cancel_ldn(struct pmcraid_cmd *cmd)
  1202. {
  1203. pmcraid_cancel_hcam(cmd,
  1204. PMCRAID_HCAM_CODE_LOG_DATA,
  1205. pmcraid_cancel_ccn);
  1206. }
  1207. /**
  1208. * pmcraid_expose_resource - check if the resource can be exposed to OS
  1209. *
  1210. * @fw_version: firmware version code
  1211. * @cfgte: pointer to configuration table entry of the resource
  1212. *
  1213. * Return value:
  1214. * true if resource can be added to midlayer, false(0) otherwise
  1215. */
  1216. static int pmcraid_expose_resource(u16 fw_version,
  1217. struct pmcraid_config_table_entry *cfgte)
  1218. {
  1219. int retval = 0;
  1220. if (cfgte->resource_type == RES_TYPE_VSET) {
  1221. if (fw_version <= PMCRAID_FW_VERSION_1)
  1222. retval = ((cfgte->unique_flags1 & 0x80) == 0);
  1223. else
  1224. retval = ((cfgte->unique_flags0 & 0x80) == 0 &&
  1225. (cfgte->unique_flags1 & 0x80) == 0);
  1226. } else if (cfgte->resource_type == RES_TYPE_GSCSI)
  1227. retval = (RES_BUS(cfgte->resource_address) !=
  1228. PMCRAID_VIRTUAL_ENCL_BUS_ID);
  1229. return retval;
  1230. }
  1231. /* attributes supported by pmcraid_event_family */
  1232. enum {
  1233. PMCRAID_AEN_ATTR_UNSPEC,
  1234. PMCRAID_AEN_ATTR_EVENT,
  1235. __PMCRAID_AEN_ATTR_MAX,
  1236. };
  1237. #define PMCRAID_AEN_ATTR_MAX (__PMCRAID_AEN_ATTR_MAX - 1)
  1238. /* commands supported by pmcraid_event_family */
  1239. enum {
  1240. PMCRAID_AEN_CMD_UNSPEC,
  1241. PMCRAID_AEN_CMD_EVENT,
  1242. __PMCRAID_AEN_CMD_MAX,
  1243. };
  1244. #define PMCRAID_AEN_CMD_MAX (__PMCRAID_AEN_CMD_MAX - 1)
  1245. static struct genl_multicast_group pmcraid_mcgrps[] = {
  1246. { .name = "events", /* not really used - see ID discussion below */ },
  1247. };
  1248. static struct genl_family pmcraid_event_family = {
  1249. /*
  1250. * Due to prior multicast group abuse (the code having assumed that
  1251. * the family ID can be used as a multicast group ID) we need to
  1252. * statically allocate a family (and thus group) ID.
  1253. */
  1254. .id = GENL_ID_PMCRAID,
  1255. .name = "pmcraid",
  1256. .version = 1,
  1257. .maxattr = PMCRAID_AEN_ATTR_MAX,
  1258. .mcgrps = pmcraid_mcgrps,
  1259. .n_mcgrps = ARRAY_SIZE(pmcraid_mcgrps),
  1260. };
  1261. /**
  1262. * pmcraid_netlink_init - registers pmcraid_event_family
  1263. *
  1264. * Return value:
  1265. * 0 if the pmcraid_event_family is successfully registered
  1266. * with netlink generic, non-zero otherwise
  1267. */
  1268. static int pmcraid_netlink_init(void)
  1269. {
  1270. int result;
  1271. result = genl_register_family(&pmcraid_event_family);
  1272. if (result)
  1273. return result;
  1274. pmcraid_info("registered NETLINK GENERIC group: %d\n",
  1275. pmcraid_event_family.id);
  1276. return result;
  1277. }
  1278. /**
  1279. * pmcraid_netlink_release - unregisters pmcraid_event_family
  1280. *
  1281. * Return value:
  1282. * none
  1283. */
  1284. static void pmcraid_netlink_release(void)
  1285. {
  1286. genl_unregister_family(&pmcraid_event_family);
  1287. }
  1288. /**
  1289. * pmcraid_notify_aen - sends event msg to user space application
  1290. * @pinstance: pointer to adapter instance structure
  1291. * @type: HCAM type
  1292. *
  1293. * Return value:
  1294. * 0 if success, error value in case of any failure.
  1295. */
  1296. static int pmcraid_notify_aen(
  1297. struct pmcraid_instance *pinstance,
  1298. struct pmcraid_aen_msg *aen_msg,
  1299. u32 data_size
  1300. )
  1301. {
  1302. struct sk_buff *skb;
  1303. void *msg_header;
  1304. u32 total_size, nla_genl_hdr_total_size;
  1305. int result;
  1306. aen_msg->hostno = (pinstance->host->unique_id << 16 |
  1307. MINOR(pinstance->cdev.dev));
  1308. aen_msg->length = data_size;
  1309. data_size += sizeof(*aen_msg);
  1310. total_size = nla_total_size(data_size);
  1311. /* Add GENL_HDR to total_size */
  1312. nla_genl_hdr_total_size =
  1313. (total_size + (GENL_HDRLEN +
  1314. ((struct genl_family *)&pmcraid_event_family)->hdrsize)
  1315. + NLMSG_HDRLEN);
  1316. skb = genlmsg_new(nla_genl_hdr_total_size, GFP_ATOMIC);
  1317. if (!skb) {
  1318. pmcraid_err("Failed to allocate aen data SKB of size: %x\n",
  1319. total_size);
  1320. return -ENOMEM;
  1321. }
  1322. /* add the genetlink message header */
  1323. msg_header = genlmsg_put(skb, 0, 0,
  1324. &pmcraid_event_family, 0,
  1325. PMCRAID_AEN_CMD_EVENT);
  1326. if (!msg_header) {
  1327. pmcraid_err("failed to copy command details\n");
  1328. nlmsg_free(skb);
  1329. return -ENOMEM;
  1330. }
  1331. result = nla_put(skb, PMCRAID_AEN_ATTR_EVENT, data_size, aen_msg);
  1332. if (result) {
  1333. pmcraid_err("failed to copy AEN attribute data\n");
  1334. nlmsg_free(skb);
  1335. return -EINVAL;
  1336. }
  1337. /* send genetlink multicast message to notify appplications */
  1338. result = genlmsg_end(skb, msg_header);
  1339. if (result < 0) {
  1340. pmcraid_err("genlmsg_end failed\n");
  1341. nlmsg_free(skb);
  1342. return result;
  1343. }
  1344. result = genlmsg_multicast(&pmcraid_event_family, skb,
  1345. 0, 0, GFP_ATOMIC);
  1346. /* If there are no listeners, genlmsg_multicast may return non-zero
  1347. * value.
  1348. */
  1349. if (result)
  1350. pmcraid_info("error (%x) sending aen event message\n", result);
  1351. return result;
  1352. }
  1353. /**
  1354. * pmcraid_notify_ccn - notifies about CCN event msg to user space
  1355. * @pinstance: pointer adapter instance structure
  1356. *
  1357. * Return value:
  1358. * 0 if success, error value in case of any failure
  1359. */
  1360. static int pmcraid_notify_ccn(struct pmcraid_instance *pinstance)
  1361. {
  1362. return pmcraid_notify_aen(pinstance,
  1363. pinstance->ccn.msg,
  1364. pinstance->ccn.hcam->data_len +
  1365. sizeof(struct pmcraid_hcam_hdr));
  1366. }
  1367. /**
  1368. * pmcraid_notify_ldn - notifies about CCN event msg to user space
  1369. * @pinstance: pointer adapter instance structure
  1370. *
  1371. * Return value:
  1372. * 0 if success, error value in case of any failure
  1373. */
  1374. static int pmcraid_notify_ldn(struct pmcraid_instance *pinstance)
  1375. {
  1376. return pmcraid_notify_aen(pinstance,
  1377. pinstance->ldn.msg,
  1378. pinstance->ldn.hcam->data_len +
  1379. sizeof(struct pmcraid_hcam_hdr));
  1380. }
  1381. /**
  1382. * pmcraid_notify_ioastate - sends IOA state event msg to user space
  1383. * @pinstance: pointer adapter instance structure
  1384. * @evt: controller state event to be sent
  1385. *
  1386. * Return value:
  1387. * 0 if success, error value in case of any failure
  1388. */
  1389. static void pmcraid_notify_ioastate(struct pmcraid_instance *pinstance, u32 evt)
  1390. {
  1391. pinstance->scn.ioa_state = evt;
  1392. pmcraid_notify_aen(pinstance,
  1393. &pinstance->scn.msg,
  1394. sizeof(u32));
  1395. }
  1396. /**
  1397. * pmcraid_handle_config_change - Handle a config change from the adapter
  1398. * @pinstance: pointer to per adapter instance structure
  1399. *
  1400. * Return value:
  1401. * none
  1402. */
  1403. static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
  1404. {
  1405. struct pmcraid_config_table_entry *cfg_entry;
  1406. struct pmcraid_hcam_ccn *ccn_hcam;
  1407. struct pmcraid_cmd *cmd;
  1408. struct pmcraid_cmd *cfgcmd;
  1409. struct pmcraid_resource_entry *res = NULL;
  1410. unsigned long lock_flags;
  1411. unsigned long host_lock_flags;
  1412. u32 new_entry = 1;
  1413. u32 hidden_entry = 0;
  1414. u16 fw_version;
  1415. int rc;
  1416. ccn_hcam = (struct pmcraid_hcam_ccn *)pinstance->ccn.hcam;
  1417. cfg_entry = &ccn_hcam->cfg_entry;
  1418. fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
  1419. pmcraid_info("CCN(%x): %x timestamp: %llx type: %x lost: %x flags: %x \
  1420. res: %x:%x:%x:%x\n",
  1421. pinstance->ccn.hcam->ilid,
  1422. pinstance->ccn.hcam->op_code,
  1423. ((pinstance->ccn.hcam->timestamp1) |
  1424. ((pinstance->ccn.hcam->timestamp2 & 0xffffffffLL) << 32)),
  1425. pinstance->ccn.hcam->notification_type,
  1426. pinstance->ccn.hcam->notification_lost,
  1427. pinstance->ccn.hcam->flags,
  1428. pinstance->host->unique_id,
  1429. RES_IS_VSET(*cfg_entry) ? PMCRAID_VSET_BUS_ID :
  1430. (RES_IS_GSCSI(*cfg_entry) ? PMCRAID_PHYS_BUS_ID :
  1431. RES_BUS(cfg_entry->resource_address)),
  1432. RES_IS_VSET(*cfg_entry) ?
  1433. (fw_version <= PMCRAID_FW_VERSION_1 ?
  1434. cfg_entry->unique_flags1 :
  1435. cfg_entry->array_id & 0xFF) :
  1436. RES_TARGET(cfg_entry->resource_address),
  1437. RES_LUN(cfg_entry->resource_address));
  1438. /* If this HCAM indicates a lost notification, read the config table */
  1439. if (pinstance->ccn.hcam->notification_lost) {
  1440. cfgcmd = pmcraid_get_free_cmd(pinstance);
  1441. if (cfgcmd) {
  1442. pmcraid_info("lost CCN, reading config table\b");
  1443. pinstance->reinit_cfg_table = 1;
  1444. pmcraid_querycfg(cfgcmd);
  1445. } else {
  1446. pmcraid_err("lost CCN, no free cmd for querycfg\n");
  1447. }
  1448. goto out_notify_apps;
  1449. }
  1450. /* If this resource is not going to be added to mid-layer, just notify
  1451. * applications and return. If this notification is about hiding a VSET
  1452. * resource, check if it was exposed already.
  1453. */
  1454. if (pinstance->ccn.hcam->notification_type ==
  1455. NOTIFICATION_TYPE_ENTRY_CHANGED &&
  1456. cfg_entry->resource_type == RES_TYPE_VSET) {
  1457. if (fw_version <= PMCRAID_FW_VERSION_1)
  1458. hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0;
  1459. else
  1460. hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0;
  1461. } else if (!pmcraid_expose_resource(fw_version, cfg_entry)) {
  1462. goto out_notify_apps;
  1463. }
  1464. spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
  1465. list_for_each_entry(res, &pinstance->used_res_q, queue) {
  1466. rc = memcmp(&res->cfg_entry.resource_address,
  1467. &cfg_entry->resource_address,
  1468. sizeof(cfg_entry->resource_address));
  1469. if (!rc) {
  1470. new_entry = 0;
  1471. break;
  1472. }
  1473. }
  1474. if (new_entry) {
  1475. if (hidden_entry) {
  1476. spin_unlock_irqrestore(&pinstance->resource_lock,
  1477. lock_flags);
  1478. goto out_notify_apps;
  1479. }
  1480. /* If there are more number of resources than what driver can
  1481. * manage, do not notify the applications about the CCN. Just
  1482. * ignore this notifications and re-register the same HCAM
  1483. */
  1484. if (list_empty(&pinstance->free_res_q)) {
  1485. spin_unlock_irqrestore(&pinstance->resource_lock,
  1486. lock_flags);
  1487. pmcraid_err("too many resources attached\n");
  1488. spin_lock_irqsave(pinstance->host->host_lock,
  1489. host_lock_flags);
  1490. pmcraid_send_hcam(pinstance,
  1491. PMCRAID_HCAM_CODE_CONFIG_CHANGE);
  1492. spin_unlock_irqrestore(pinstance->host->host_lock,
  1493. host_lock_flags);
  1494. return;
  1495. }
  1496. res = list_entry(pinstance->free_res_q.next,
  1497. struct pmcraid_resource_entry, queue);
  1498. list_del(&res->queue);
  1499. res->scsi_dev = NULL;
  1500. res->reset_progress = 0;
  1501. list_add_tail(&res->queue, &pinstance->used_res_q);
  1502. }
  1503. memcpy(&res->cfg_entry, cfg_entry, pinstance->config_table_entry_size);
  1504. if (pinstance->ccn.hcam->notification_type ==
  1505. NOTIFICATION_TYPE_ENTRY_DELETED || hidden_entry) {
  1506. if (res->scsi_dev) {
  1507. if (fw_version <= PMCRAID_FW_VERSION_1)
  1508. res->cfg_entry.unique_flags1 &= 0x7F;
  1509. else
  1510. res->cfg_entry.array_id &= 0xFF;
  1511. res->change_detected = RES_CHANGE_DEL;
  1512. res->cfg_entry.resource_handle =
  1513. PMCRAID_INVALID_RES_HANDLE;
  1514. schedule_work(&pinstance->worker_q);
  1515. } else {
  1516. /* This may be one of the non-exposed resources */
  1517. list_move_tail(&res->queue, &pinstance->free_res_q);
  1518. }
  1519. } else if (!res->scsi_dev) {
  1520. res->change_detected = RES_CHANGE_ADD;
  1521. schedule_work(&pinstance->worker_q);
  1522. }
  1523. spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
  1524. out_notify_apps:
  1525. /* Notify configuration changes to registered applications.*/
  1526. if (!pmcraid_disable_aen)
  1527. pmcraid_notify_ccn(pinstance);
  1528. cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
  1529. if (cmd)
  1530. pmcraid_send_hcam_cmd(cmd);
  1531. }
  1532. /**
  1533. * pmcraid_get_error_info - return error string for an ioasc
  1534. * @ioasc: ioasc code
  1535. * Return Value
  1536. * none
  1537. */
  1538. static struct pmcraid_ioasc_error *pmcraid_get_error_info(u32 ioasc)
  1539. {
  1540. int i;
  1541. for (i = 0; i < ARRAY_SIZE(pmcraid_ioasc_error_table); i++) {
  1542. if (pmcraid_ioasc_error_table[i].ioasc_code == ioasc)
  1543. return &pmcraid_ioasc_error_table[i];
  1544. }
  1545. return NULL;
  1546. }
  1547. /**
  1548. * pmcraid_ioasc_logger - log IOASC information based user-settings
  1549. * @ioasc: ioasc code
  1550. * @cmd: pointer to command that resulted in 'ioasc'
  1551. */
  1552. void pmcraid_ioasc_logger(u32 ioasc, struct pmcraid_cmd *cmd)
  1553. {
  1554. struct pmcraid_ioasc_error *error_info = pmcraid_get_error_info(ioasc);
  1555. if (error_info == NULL ||
  1556. cmd->drv_inst->current_log_level < error_info->log_level)
  1557. return;
  1558. /* log the error string */
  1559. pmcraid_err("cmd [%x] for resource %x failed with %x(%s)\n",
  1560. cmd->ioa_cb->ioarcb.cdb[0],
  1561. cmd->ioa_cb->ioarcb.resource_handle,
  1562. le32_to_cpu(ioasc), error_info->error_string);
  1563. }
  1564. /**
  1565. * pmcraid_handle_error_log - Handle a config change (error log) from the IOA
  1566. *
  1567. * @pinstance: pointer to per adapter instance structure
  1568. *
  1569. * Return value:
  1570. * none
  1571. */
  1572. static void pmcraid_handle_error_log(struct pmcraid_instance *pinstance)
  1573. {
  1574. struct pmcraid_hcam_ldn *hcam_ldn;
  1575. u32 ioasc;
  1576. hcam_ldn = (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;
  1577. pmcraid_info
  1578. ("LDN(%x): %x type: %x lost: %x flags: %x overlay id: %x\n",
  1579. pinstance->ldn.hcam->ilid,
  1580. pinstance->ldn.hcam->op_code,
  1581. pinstance->ldn.hcam->notification_type,
  1582. pinstance->ldn.hcam->notification_lost,
  1583. pinstance->ldn.hcam->flags,
  1584. pinstance->ldn.hcam->overlay_id);
  1585. /* log only the errors, no need to log informational log entries */
  1586. if (pinstance->ldn.hcam->notification_type !=
  1587. NOTIFICATION_TYPE_ERROR_LOG)
  1588. return;
  1589. if (pinstance->ldn.hcam->notification_lost ==
  1590. HOSTRCB_NOTIFICATIONS_LOST)
  1591. dev_info(&pinstance->pdev->dev, "Error notifications lost\n");
  1592. ioasc = le32_to_cpu(hcam_ldn->error_log.fd_ioasc);
  1593. if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET ||
  1594. ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER) {
  1595. dev_info(&pinstance->pdev->dev,
  1596. "UnitAttention due to IOA Bus Reset\n");
  1597. scsi_report_bus_reset(
  1598. pinstance->host,
  1599. RES_BUS(hcam_ldn->error_log.fd_ra));
  1600. }
  1601. return;
  1602. }
  1603. /**
  1604. * pmcraid_process_ccn - Op done function for a CCN.
  1605. * @cmd: pointer to command struct
  1606. *
  1607. * This function is the op done function for a configuration
  1608. * change notification
  1609. *
  1610. * Return value:
  1611. * none
  1612. */
  1613. static void pmcraid_process_ccn(struct pmcraid_cmd *cmd)
  1614. {
  1615. struct pmcraid_instance *pinstance = cmd->drv_inst;
  1616. u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
  1617. unsigned long lock_flags;
  1618. pinstance->ccn.cmd = NULL;
  1619. pmcraid_return_cmd(cmd);
  1620. /* If driver initiated IOA reset happened while this hcam was pending
  1621. * with IOA, or IOA bringdown sequence is in progress, no need to
  1622. * re-register the hcam
  1623. */
  1624. if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
  1625. atomic_read(&pinstance->ccn.ignore) == 1) {
  1626. return;
  1627. } else if (ioasc) {
  1628. dev_info(&pinstance->pdev->dev,
  1629. "Host RCB (CCN) failed with IOASC: 0x%08X\n", ioasc);
  1630. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  1631. pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
  1632. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  1633. } else {
  1634. pmcraid_handle_config_change(pinstance);
  1635. }
  1636. }
  1637. /**
  1638. * pmcraid_process_ldn - op done function for an LDN
  1639. * @cmd: pointer to command block
  1640. *
  1641. * Return value
  1642. * none
  1643. */
  1644. static void pmcraid_initiate_reset(struct pmcraid_instance *);
  1645. static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd);
  1646. static void pmcraid_process_ldn(struct pmcraid_cmd *cmd)
  1647. {
  1648. struct pmcraid_instance *pinstance = cmd->drv_inst;
  1649. struct pmcraid_hcam_ldn *ldn_hcam =
  1650. (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;
  1651. u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
  1652. u32 fd_ioasc = le32_to_cpu(ldn_hcam->error_log.fd_ioasc);
  1653. unsigned long lock_flags;
  1654. /* return the command block back to freepool */
  1655. pinstance->ldn.cmd = NULL;
  1656. pmcraid_return_cmd(cmd);
  1657. /* If driver initiated IOA reset happened while this hcam was pending
  1658. * with IOA, no need to re-register the hcam as reset engine will do it
  1659. * once reset sequence is complete
  1660. */
  1661. if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
  1662. atomic_read(&pinstance->ccn.ignore) == 1) {
  1663. return;
  1664. } else if (!ioasc) {
  1665. pmcraid_handle_error_log(pinstance);
  1666. if (fd_ioasc == PMCRAID_IOASC_NR_IOA_RESET_REQUIRED) {
  1667. spin_lock_irqsave(pinstance->host->host_lock,
  1668. lock_flags);
  1669. pmcraid_initiate_reset(pinstance);
  1670. spin_unlock_irqrestore(pinstance->host->host_lock,
  1671. lock_flags);
  1672. return;
  1673. }
  1674. if (fd_ioasc == PMCRAID_IOASC_TIME_STAMP_OUT_OF_SYNC) {
  1675. pinstance->timestamp_error = 1;
  1676. pmcraid_set_timestamp(cmd);
  1677. }
  1678. } else {
  1679. dev_info(&pinstance->pdev->dev,
  1680. "Host RCB(LDN) failed with IOASC: 0x%08X\n", ioasc);
  1681. }
  1682. /* send netlink message for HCAM notification if enabled */
  1683. if (!pmcraid_disable_aen)
  1684. pmcraid_notify_ldn(pinstance);
  1685. cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
  1686. if (cmd)
  1687. pmcraid_send_hcam_cmd(cmd);
  1688. }
  1689. /**
  1690. * pmcraid_register_hcams - register HCAMs for CCN and LDN
  1691. *
  1692. * @pinstance: pointer per adapter instance structure
  1693. *
  1694. * Return Value
  1695. * none
  1696. */
  1697. static void pmcraid_register_hcams(struct pmcraid_instance *pinstance)
  1698. {
  1699. pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
  1700. pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
  1701. }
  1702. /**
  1703. * pmcraid_unregister_hcams - cancel HCAMs registered already
  1704. * @cmd: pointer to command used as part of reset sequence
  1705. */
  1706. static void pmcraid_unregister_hcams(struct pmcraid_cmd *cmd)
  1707. {
  1708. struct pmcraid_instance *pinstance = cmd->drv_inst;
  1709. /* During IOA bringdown, HCAM gets fired and tasklet proceeds with
  1710. * handling hcam response though it is not necessary. In order to
  1711. * prevent this, set 'ignore', so that bring-down sequence doesn't
  1712. * re-send any more hcams
  1713. */
  1714. atomic_set(&pinstance->ccn.ignore, 1);
  1715. atomic_set(&pinstance->ldn.ignore, 1);
  1716. /* If adapter reset was forced as part of runtime reset sequence,
  1717. * start the reset sequence. Reset will be triggered even in case
  1718. * IOA unit_check.
  1719. */
  1720. if ((pinstance->force_ioa_reset && !pinstance->ioa_bringdown) ||
  1721. pinstance->ioa_unit_check) {
  1722. pinstance->force_ioa_reset = 0;
  1723. pinstance->ioa_unit_check = 0;
  1724. pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
  1725. pmcraid_reset_alert(cmd);
  1726. return;
  1727. }
  1728. /* Driver tries to cancel HCAMs by sending ABORT TASK for each HCAM
  1729. * one after the other. So CCN cancellation will be triggered by
  1730. * pmcraid_cancel_ldn itself.
  1731. */
  1732. pmcraid_cancel_ldn(cmd);
  1733. }
  1734. /**
  1735. * pmcraid_reset_enable_ioa - re-enable IOA after a hard reset
  1736. * @pinstance: pointer to adapter instance structure
  1737. * Return Value
  1738. * 1 if TRANSITION_TO_OPERATIONAL is active, otherwise 0
  1739. */
  1740. static void pmcraid_reinit_buffers(struct pmcraid_instance *);
  1741. static int pmcraid_reset_enable_ioa(struct pmcraid_instance *pinstance)
  1742. {
  1743. u32 intrs;
  1744. pmcraid_reinit_buffers(pinstance);
  1745. intrs = pmcraid_read_interrupts(pinstance);
  1746. pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
  1747. if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) {
  1748. if (!pinstance->interrupt_mode) {
  1749. iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
  1750. pinstance->int_regs.
  1751. ioa_host_interrupt_mask_reg);
  1752. iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
  1753. pinstance->int_regs.ioa_host_interrupt_clr_reg);
  1754. }
  1755. return 1;
  1756. } else {
  1757. return 0;
  1758. }
  1759. }
  1760. /**
  1761. * pmcraid_soft_reset - performs a soft reset and makes IOA become ready
  1762. * @cmd : pointer to reset command block
  1763. *
  1764. * Return Value
  1765. * none
  1766. */
  1767. static void pmcraid_soft_reset(struct pmcraid_cmd *cmd)
  1768. {
  1769. struct pmcraid_instance *pinstance = cmd->drv_inst;
  1770. u32 int_reg;
  1771. u32 doorbell;
  1772. /* There will be an interrupt when Transition to Operational bit is
  1773. * set so tasklet would execute next reset task. The timeout handler
  1774. * would re-initiate a reset
  1775. */
  1776. cmd->cmd_done = pmcraid_ioa_reset;
  1777. cmd->timer.data = (unsigned long)cmd;
  1778. cmd->timer.expires = jiffies +
  1779. msecs_to_jiffies(PMCRAID_TRANSOP_TIMEOUT);
  1780. cmd->timer.function = (void (*)(unsigned long))pmcraid_timeout_handler;
  1781. if (!timer_pending(&cmd->timer))
  1782. add_timer(&cmd->timer);
  1783. /* Enable destructive diagnostics on IOA if it is not yet in
  1784. * operational state
  1785. */
  1786. doorbell = DOORBELL_RUNTIME_RESET |
  1787. DOORBELL_ENABLE_DESTRUCTIVE_DIAGS;
  1788. /* Since we do RESET_ALERT and Start BIST we have to again write
  1789. * MSIX Doorbell to indicate the interrupt mode
  1790. */
  1791. if (pinstance->interrupt_mode) {
  1792. iowrite32(DOORBELL_INTR_MODE_MSIX,
  1793. pinstance->int_regs.host_ioa_interrupt_reg);
  1794. ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
  1795. }
  1796. iowrite32(doorbell, pinstance->int_regs.host_ioa_interrupt_reg);
  1797. ioread32(pinstance->int_regs.host_ioa_interrupt_reg),
  1798. int_reg = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
  1799. pmcraid_info("Waiting for IOA to become operational %x:%x\n",
  1800. ioread32(pinstance->int_regs.host_ioa_interrupt_reg),
  1801. int_reg);
  1802. }
  1803. /**
  1804. * pmcraid_get_dump - retrieves IOA dump in case of Unit Check interrupt
  1805. *
  1806. * @pinstance: pointer to adapter instance structure
  1807. *
  1808. * Return Value
  1809. * none
  1810. */
  1811. static void pmcraid_get_dump(struct pmcraid_instance *pinstance)
  1812. {
  1813. pmcraid_info("%s is not yet implemented\n", __func__);
  1814. }
  1815. /**
  1816. * pmcraid_fail_outstanding_cmds - Fails all outstanding ops.
  1817. * @pinstance: pointer to adapter instance structure
  1818. *
  1819. * This function fails all outstanding ops. If they are submitted to IOA
  1820. * already, it sends cancel all messages if IOA is still accepting IOARCBs,
  1821. * otherwise just completes the commands and returns the cmd blocks to free
  1822. * pool.
  1823. *
  1824. * Return value:
  1825. * none
  1826. */
  1827. static void pmcraid_fail_outstanding_cmds(struct pmcraid_instance *pinstance)
  1828. {
  1829. struct pmcraid_cmd *cmd, *temp;
  1830. unsigned long lock_flags;
  1831. /* pending command list is protected by pending_pool_lock. Its
  1832. * traversal must be done as within this lock
  1833. */
  1834. spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
  1835. list_for_each_entry_safe(cmd, temp, &pinstance->pending_cmd_pool,
  1836. free_list) {
  1837. list_del(&cmd->free_list);
  1838. spin_unlock_irqrestore(&pinstance->pending_pool_lock,
  1839. lock_flags);
  1840. cmd->ioa_cb->ioasa.ioasc =
  1841. cpu_to_le32(PMCRAID_IOASC_IOA_WAS_RESET);
  1842. cmd->ioa_cb->ioasa.ilid =
  1843. cpu_to_be32(PMCRAID_DRIVER_ILID);
  1844. /* In case the command timer is still running */
  1845. del_timer(&cmd->timer);
  1846. /* If this is an IO command, complete it by invoking scsi_done
  1847. * function. If this is one of the internal commands other
  1848. * than pmcraid_ioa_reset and HCAM commands invoke cmd_done to
  1849. * complete it
  1850. */
  1851. if (cmd->scsi_cmd) {
  1852. struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
  1853. __le32 resp = cmd->ioa_cb->ioarcb.response_handle;
  1854. scsi_cmd->result |= DID_ERROR << 16;
  1855. scsi_dma_unmap(scsi_cmd);
  1856. pmcraid_return_cmd(cmd);
  1857. pmcraid_info("failing(%d) CDB[0] = %x result: %x\n",
  1858. le32_to_cpu(resp) >> 2,
  1859. cmd->ioa_cb->ioarcb.cdb[0],
  1860. scsi_cmd->result);
  1861. scsi_cmd->scsi_done(scsi_cmd);
  1862. } else if (cmd->cmd_done == pmcraid_internal_done ||
  1863. cmd->cmd_done == pmcraid_erp_done) {
  1864. cmd->cmd_done(cmd);
  1865. } else if (cmd->cmd_done != pmcraid_ioa_reset &&
  1866. cmd->cmd_done != pmcraid_ioa_shutdown_done) {
  1867. pmcraid_return_cmd(cmd);
  1868. }
  1869. atomic_dec(&pinstance->outstanding_cmds);
  1870. spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
  1871. }
  1872. spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);
  1873. }
  1874. /**
  1875. * pmcraid_ioa_reset - Implementation of IOA reset logic
  1876. *
  1877. * @cmd: pointer to the cmd block to be used for entire reset process
  1878. *
  1879. * This function executes most of the steps required for IOA reset. This gets
  1880. * called by user threads (modprobe/insmod/rmmod) timer, tasklet and midlayer's
  1881. * 'eh_' thread. Access to variables used for controlling the reset sequence is
  1882. * synchronized using host lock. Various functions called during reset process
  1883. * would make use of a single command block, pointer to which is also stored in
  1884. * adapter instance structure.
  1885. *
  1886. * Return Value
  1887. * None
  1888. */
  1889. static void pmcraid_ioa_reset(struct pmcraid_cmd *cmd)
  1890. {
  1891. struct pmcraid_instance *pinstance = cmd->drv_inst;
  1892. u8 reset_complete = 0;
  1893. pinstance->ioa_reset_in_progress = 1;
  1894. if (pinstance->reset_cmd != cmd) {
  1895. pmcraid_err("reset is called with different command block\n");
  1896. pinstance->reset_cmd = cmd;
  1897. }
  1898. pmcraid_info("reset_engine: state = %d, command = %p\n",
  1899. pinstance->ioa_state, cmd);
  1900. switch (pinstance->ioa_state) {
  1901. case IOA_STATE_DEAD:
  1902. /* If IOA is offline, whatever may be the reset reason, just
  1903. * return. callers might be waiting on the reset wait_q, wake
  1904. * up them
  1905. */
  1906. pmcraid_err("IOA is offline no reset is possible\n");
  1907. reset_complete = 1;
  1908. break;
  1909. case IOA_STATE_IN_BRINGDOWN:
  1910. /* we enter here, once ioa shutdown command is processed by IOA
  1911. * Alert IOA for a possible reset. If reset alert fails, IOA
  1912. * goes through hard-reset
  1913. */
  1914. pmcraid_disable_interrupts(pinstance, ~0);
  1915. pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
  1916. pmcraid_reset_alert(cmd);
  1917. break;
  1918. case IOA_STATE_UNKNOWN:
  1919. /* We may be called during probe or resume. Some pre-processing
  1920. * is required for prior to reset
  1921. */
  1922. scsi_block_requests(pinstance->host);
  1923. /* If asked to reset while IOA was processing responses or
  1924. * there are any error responses then IOA may require
  1925. * hard-reset.
  1926. */
  1927. if (pinstance->ioa_hard_reset == 0) {
  1928. if (ioread32(pinstance->ioa_status) &
  1929. INTRS_TRANSITION_TO_OPERATIONAL) {
  1930. pmcraid_info("sticky bit set, bring-up\n");
  1931. pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
  1932. pmcraid_reinit_cmdblk(cmd);
  1933. pmcraid_identify_hrrq(cmd);
  1934. } else {
  1935. pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;
  1936. pmcraid_soft_reset(cmd);
  1937. }
  1938. } else {
  1939. /* Alert IOA of a possible reset and wait for critical
  1940. * operation in progress bit to reset
  1941. */
  1942. pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
  1943. pmcraid_reset_alert(cmd);
  1944. }
  1945. break;
  1946. case IOA_STATE_IN_RESET_ALERT:
  1947. /* If critical operation in progress bit is reset or wait gets
  1948. * timed out, reset proceeds with starting BIST on the IOA.
  1949. * pmcraid_ioa_hard_reset keeps a count of reset attempts. If
  1950. * they are 3 or more, reset engine marks IOA dead and returns
  1951. */
  1952. pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;
  1953. pmcraid_start_bist(cmd);
  1954. break;
  1955. case IOA_STATE_IN_HARD_RESET:
  1956. pinstance->ioa_reset_attempts++;
  1957. /* retry reset if we haven't reached maximum allowed limit */
  1958. if (pinstance->ioa_reset_attempts > PMCRAID_RESET_ATTEMPTS) {
  1959. pinstance->ioa_reset_attempts = 0;
  1960. pmcraid_err("IOA didn't respond marking it as dead\n");
  1961. pinstance->ioa_state = IOA_STATE_DEAD;
  1962. if (pinstance->ioa_bringdown)
  1963. pmcraid_notify_ioastate(pinstance,
  1964. PMC_DEVICE_EVENT_SHUTDOWN_FAILED);
  1965. else
  1966. pmcraid_notify_ioastate(pinstance,
  1967. PMC_DEVICE_EVENT_RESET_FAILED);
  1968. reset_complete = 1;
  1969. break;
  1970. }
  1971. /* Once either bist or pci reset is done, restore PCI config
  1972. * space. If this fails, proceed with hard reset again
  1973. */
  1974. pci_restore_state(pinstance->pdev);
  1975. /* fail all pending commands */
  1976. pmcraid_fail_outstanding_cmds(pinstance);
  1977. /* check if unit check is active, if so extract dump */
  1978. if (pinstance->ioa_unit_check) {
  1979. pmcraid_info("unit check is active\n");
  1980. pinstance->ioa_unit_check = 0;
  1981. pmcraid_get_dump(pinstance);
  1982. pinstance->ioa_reset_attempts--;
  1983. pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
  1984. pmcraid_reset_alert(cmd);
  1985. break;
  1986. }
  1987. /* if the reset reason is to bring-down the ioa, we might be
  1988. * done with the reset restore pci_config_space and complete
  1989. * the reset
  1990. */
  1991. if (pinstance->ioa_bringdown) {
  1992. pmcraid_info("bringing down the adapter\n");
  1993. pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
  1994. pinstance->ioa_bringdown = 0;
  1995. pinstance->ioa_state = IOA_STATE_UNKNOWN;
  1996. pmcraid_notify_ioastate(pinstance,
  1997. PMC_DEVICE_EVENT_SHUTDOWN_SUCCESS);
  1998. reset_complete = 1;
  1999. } else {
  2000. /* bring-up IOA, so proceed with soft reset
  2001. * Reinitialize hrrq_buffers and their indices also
  2002. * enable interrupts after a pci_restore_state
  2003. */
  2004. if (pmcraid_reset_enable_ioa(pinstance)) {
  2005. pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
  2006. pmcraid_info("bringing up the adapter\n");
  2007. pmcraid_reinit_cmdblk(cmd);
  2008. pmcraid_identify_hrrq(cmd);
  2009. } else {
  2010. pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;
  2011. pmcraid_soft_reset(cmd);
  2012. }
  2013. }
  2014. break;
  2015. case IOA_STATE_IN_SOFT_RESET:
  2016. /* TRANSITION TO OPERATIONAL is on so start initialization
  2017. * sequence
  2018. */
  2019. pmcraid_info("In softreset proceeding with bring-up\n");
  2020. pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
  2021. /* Initialization commands start with HRRQ identification. From
  2022. * now on tasklet completes most of the commands as IOA is up
  2023. * and intrs are enabled
  2024. */
  2025. pmcraid_identify_hrrq(cmd);
  2026. break;
  2027. case IOA_STATE_IN_BRINGUP:
  2028. /* we are done with bringing up of IOA, change the ioa_state to
  2029. * operational and wake up any waiters
  2030. */
  2031. pinstance->ioa_state = IOA_STATE_OPERATIONAL;
  2032. reset_complete = 1;
  2033. break;
  2034. case IOA_STATE_OPERATIONAL:
  2035. default:
  2036. /* When IOA is operational and a reset is requested, check for
  2037. * the reset reason. If reset is to bring down IOA, unregister
  2038. * HCAMs and initiate shutdown; if adapter reset is forced then
  2039. * restart reset sequence again
  2040. */
  2041. if (pinstance->ioa_shutdown_type == SHUTDOWN_NONE &&
  2042. pinstance->force_ioa_reset == 0) {
  2043. pmcraid_notify_ioastate(pinstance,
  2044. PMC_DEVICE_EVENT_RESET_SUCCESS);
  2045. reset_complete = 1;
  2046. } else {
  2047. if (pinstance->ioa_shutdown_type != SHUTDOWN_NONE)
  2048. pinstance->ioa_state = IOA_STATE_IN_BRINGDOWN;
  2049. pmcraid_reinit_cmdblk(cmd);
  2050. pmcraid_unregister_hcams(cmd);
  2051. }
  2052. break;
  2053. }
  2054. /* reset will be completed if ioa_state is either DEAD or UNKNOWN or
  2055. * OPERATIONAL. Reset all control variables used during reset, wake up
  2056. * any waiting threads and let the SCSI mid-layer send commands. Note
  2057. * that host_lock must be held before invoking scsi_report_bus_reset.
  2058. */
  2059. if (reset_complete) {
  2060. pinstance->ioa_reset_in_progress = 0;
  2061. pinstance->ioa_reset_attempts = 0;
  2062. pinstance->reset_cmd = NULL;
  2063. pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
  2064. pinstance->ioa_bringdown = 0;
  2065. pmcraid_return_cmd(cmd);
  2066. /* If target state is to bring up the adapter, proceed with
  2067. * hcam registration and resource exposure to mid-layer.
  2068. */
  2069. if (pinstance->ioa_state == IOA_STATE_OPERATIONAL)
  2070. pmcraid_register_hcams(pinstance);
  2071. wake_up_all(&pinstance->reset_wait_q);
  2072. }
  2073. return;
  2074. }
  2075. /**
  2076. * pmcraid_initiate_reset - initiates reset sequence. This is called from
  2077. * ISR/tasklet during error interrupts including IOA unit check. If reset
  2078. * is already in progress, it just returns, otherwise initiates IOA reset
  2079. * to bring IOA up to operational state.
  2080. *
  2081. * @pinstance: pointer to adapter instance structure
  2082. *
  2083. * Return value
  2084. * none
  2085. */
  2086. static void pmcraid_initiate_reset(struct pmcraid_instance *pinstance)
  2087. {
  2088. struct pmcraid_cmd *cmd;
  2089. /* If the reset is already in progress, just return, otherwise start
  2090. * reset sequence and return
  2091. */
  2092. if (!pinstance->ioa_reset_in_progress) {
  2093. scsi_block_requests(pinstance->host);
  2094. cmd = pmcraid_get_free_cmd(pinstance);
  2095. if (cmd == NULL) {
  2096. pmcraid_err("no cmnd blocks for initiate_reset\n");
  2097. return;
  2098. }
  2099. pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
  2100. pinstance->reset_cmd = cmd;
  2101. pinstance->force_ioa_reset = 1;
  2102. pmcraid_notify_ioastate(pinstance,
  2103. PMC_DEVICE_EVENT_RESET_START);
  2104. pmcraid_ioa_reset(cmd);
  2105. }
  2106. }
  2107. /**
  2108. * pmcraid_reset_reload - utility routine for doing IOA reset either to bringup
  2109. * or bringdown IOA
  2110. * @pinstance: pointer adapter instance structure
  2111. * @shutdown_type: shutdown type to be used NONE, NORMAL or ABRREV
  2112. * @target_state: expected target state after reset
  2113. *
  2114. * Note: This command initiates reset and waits for its completion. Hence this
  2115. * should not be called from isr/timer/tasklet functions (timeout handlers,
  2116. * error response handlers and interrupt handlers).
  2117. *
  2118. * Return Value
  2119. * 1 in case ioa_state is not target_state, 0 otherwise.
  2120. */
  2121. static int pmcraid_reset_reload(
  2122. struct pmcraid_instance *pinstance,
  2123. u8 shutdown_type,
  2124. u8 target_state
  2125. )
  2126. {
  2127. struct pmcraid_cmd *reset_cmd = NULL;
  2128. unsigned long lock_flags;
  2129. int reset = 1;
  2130. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  2131. if (pinstance->ioa_reset_in_progress) {
  2132. pmcraid_info("reset_reload: reset is already in progress\n");
  2133. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  2134. wait_event(pinstance->reset_wait_q,
  2135. !pinstance->ioa_reset_in_progress);
  2136. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  2137. if (pinstance->ioa_state == IOA_STATE_DEAD) {
  2138. spin_unlock_irqrestore(pinstance->host->host_lock,
  2139. lock_flags);
  2140. pmcraid_info("reset_reload: IOA is dead\n");
  2141. return reset;
  2142. } else if (pinstance->ioa_state == target_state) {
  2143. reset = 0;
  2144. }
  2145. }
  2146. if (reset) {
  2147. pmcraid_info("reset_reload: proceeding with reset\n");
  2148. scsi_block_requests(pinstance->host);
  2149. reset_cmd = pmcraid_get_free_cmd(pinstance);
  2150. if (reset_cmd == NULL) {
  2151. pmcraid_err("no free cmnd for reset_reload\n");
  2152. spin_unlock_irqrestore(pinstance->host->host_lock,
  2153. lock_flags);
  2154. return reset;
  2155. }
  2156. if (shutdown_type == SHUTDOWN_NORMAL)
  2157. pinstance->ioa_bringdown = 1;
  2158. pinstance->ioa_shutdown_type = shutdown_type;
  2159. pinstance->reset_cmd = reset_cmd;
  2160. pinstance->force_ioa_reset = reset;
  2161. pmcraid_info("reset_reload: initiating reset\n");
  2162. pmcraid_ioa_reset(reset_cmd);
  2163. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  2164. pmcraid_info("reset_reload: waiting for reset to complete\n");
  2165. wait_event(pinstance->reset_wait_q,
  2166. !pinstance->ioa_reset_in_progress);
  2167. pmcraid_info("reset_reload: reset is complete !!\n");
  2168. scsi_unblock_requests(pinstance->host);
  2169. if (pinstance->ioa_state == target_state)
  2170. reset = 0;
  2171. }
  2172. return reset;
  2173. }
  2174. /**
  2175. * pmcraid_reset_bringdown - wrapper over pmcraid_reset_reload to bringdown IOA
  2176. *
  2177. * @pinstance: pointer to adapter instance structure
  2178. *
  2179. * Return Value
  2180. * whatever is returned from pmcraid_reset_reload
  2181. */
  2182. static int pmcraid_reset_bringdown(struct pmcraid_instance *pinstance)
  2183. {
  2184. return pmcraid_reset_reload(pinstance,
  2185. SHUTDOWN_NORMAL,
  2186. IOA_STATE_UNKNOWN);
  2187. }
  2188. /**
  2189. * pmcraid_reset_bringup - wrapper over pmcraid_reset_reload to bring up IOA
  2190. *
  2191. * @pinstance: pointer to adapter instance structure
  2192. *
  2193. * Return Value
  2194. * whatever is returned from pmcraid_reset_reload
  2195. */
  2196. static int pmcraid_reset_bringup(struct pmcraid_instance *pinstance)
  2197. {
  2198. pmcraid_notify_ioastate(pinstance, PMC_DEVICE_EVENT_RESET_START);
  2199. return pmcraid_reset_reload(pinstance,
  2200. SHUTDOWN_NONE,
  2201. IOA_STATE_OPERATIONAL);
  2202. }
  2203. /**
  2204. * pmcraid_request_sense - Send request sense to a device
  2205. * @cmd: pmcraid command struct
  2206. *
  2207. * This function sends a request sense to a device as a result of a check
  2208. * condition. This method re-uses the same command block that failed earlier.
  2209. */
  2210. static void pmcraid_request_sense(struct pmcraid_cmd *cmd)
  2211. {
  2212. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  2213. struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
  2214. /* allocate DMAable memory for sense buffers */
  2215. cmd->sense_buffer = pci_alloc_consistent(cmd->drv_inst->pdev,
  2216. SCSI_SENSE_BUFFERSIZE,
  2217. &cmd->sense_buffer_dma);
  2218. if (cmd->sense_buffer == NULL) {
  2219. pmcraid_err
  2220. ("couldn't allocate sense buffer for request sense\n");
  2221. pmcraid_erp_done(cmd);
  2222. return;
  2223. }
  2224. /* re-use the command block */
  2225. memset(&cmd->ioa_cb->ioasa, 0, sizeof(struct pmcraid_ioasa));
  2226. memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
  2227. ioarcb->request_flags0 = (SYNC_COMPLETE |
  2228. NO_LINK_DESCS |
  2229. INHIBIT_UL_CHECK);
  2230. ioarcb->request_type = REQ_TYPE_SCSI;
  2231. ioarcb->cdb[0] = REQUEST_SENSE;
  2232. ioarcb->cdb[4] = SCSI_SENSE_BUFFERSIZE;
  2233. ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
  2234. offsetof(struct pmcraid_ioarcb,
  2235. add_data.u.ioadl[0]));
  2236. ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
  2237. ioarcb->data_transfer_length = cpu_to_le32(SCSI_SENSE_BUFFERSIZE);
  2238. ioadl->address = cpu_to_le64(cmd->sense_buffer_dma);
  2239. ioadl->data_len = cpu_to_le32(SCSI_SENSE_BUFFERSIZE);
  2240. ioadl->flags = IOADL_FLAGS_LAST_DESC;
  2241. /* request sense might be called as part of error response processing
  2242. * which runs in tasklets context. It is possible that mid-layer might
  2243. * schedule queuecommand during this time, hence, writting to IOARRIN
  2244. * must be protect by host_lock
  2245. */
  2246. pmcraid_send_cmd(cmd, pmcraid_erp_done,
  2247. PMCRAID_REQUEST_SENSE_TIMEOUT,
  2248. pmcraid_timeout_handler);
  2249. }
  2250. /**
  2251. * pmcraid_cancel_all - cancel all outstanding IOARCBs as part of error recovery
  2252. * @cmd: command that failed
  2253. * @sense: true if request_sense is required after cancel all
  2254. *
  2255. * This function sends a cancel all to a device to clear the queue.
  2256. */
  2257. static void pmcraid_cancel_all(struct pmcraid_cmd *cmd, u32 sense)
  2258. {
  2259. struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
  2260. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  2261. struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata;
  2262. void (*cmd_done) (struct pmcraid_cmd *) = sense ? pmcraid_erp_done
  2263. : pmcraid_request_sense;
  2264. memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
  2265. ioarcb->request_flags0 = SYNC_OVERRIDE;
  2266. ioarcb->request_type = REQ_TYPE_IOACMD;
  2267. ioarcb->cdb[0] = PMCRAID_CANCEL_ALL_REQUESTS;
  2268. if (RES_IS_GSCSI(res->cfg_entry))
  2269. ioarcb->cdb[1] = PMCRAID_SYNC_COMPLETE_AFTER_CANCEL;
  2270. ioarcb->ioadl_bus_addr = 0;
  2271. ioarcb->ioadl_length = 0;
  2272. ioarcb->data_transfer_length = 0;
  2273. ioarcb->ioarcb_bus_addr &= (~0x1FULL);
  2274. /* writing to IOARRIN must be protected by host_lock, as mid-layer
  2275. * schedule queuecommand while we are doing this
  2276. */
  2277. pmcraid_send_cmd(cmd, cmd_done,
  2278. PMCRAID_REQUEST_SENSE_TIMEOUT,
  2279. pmcraid_timeout_handler);
  2280. }
  2281. /**
  2282. * pmcraid_frame_auto_sense: frame fixed format sense information
  2283. *
  2284. * @cmd: pointer to failing command block
  2285. *
  2286. * Return value
  2287. * none
  2288. */
  2289. static void pmcraid_frame_auto_sense(struct pmcraid_cmd *cmd)
  2290. {
  2291. u8 *sense_buf = cmd->scsi_cmd->sense_buffer;
  2292. struct pmcraid_resource_entry *res = cmd->scsi_cmd->device->hostdata;
  2293. struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;
  2294. u32 ioasc = le32_to_cpu(ioasa->ioasc);
  2295. u32 failing_lba = 0;
  2296. memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
  2297. cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
  2298. if (RES_IS_VSET(res->cfg_entry) &&
  2299. ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC &&
  2300. ioasa->u.vset.failing_lba_hi != 0) {
  2301. sense_buf[0] = 0x72;
  2302. sense_buf[1] = PMCRAID_IOASC_SENSE_KEY(ioasc);
  2303. sense_buf[2] = PMCRAID_IOASC_SENSE_CODE(ioasc);
  2304. sense_buf[3] = PMCRAID_IOASC_SENSE_QUAL(ioasc);
  2305. sense_buf[7] = 12;
  2306. sense_buf[8] = 0;
  2307. sense_buf[9] = 0x0A;
  2308. sense_buf[10] = 0x80;
  2309. failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_hi);
  2310. sense_buf[12] = (failing_lba & 0xff000000) >> 24;
  2311. sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
  2312. sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
  2313. sense_buf[15] = failing_lba & 0x000000ff;
  2314. failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_lo);
  2315. sense_buf[16] = (failing_lba & 0xff000000) >> 24;
  2316. sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
  2317. sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
  2318. sense_buf[19] = failing_lba & 0x000000ff;
  2319. } else {
  2320. sense_buf[0] = 0x70;
  2321. sense_buf[2] = PMCRAID_IOASC_SENSE_KEY(ioasc);
  2322. sense_buf[12] = PMCRAID_IOASC_SENSE_CODE(ioasc);
  2323. sense_buf[13] = PMCRAID_IOASC_SENSE_QUAL(ioasc);
  2324. if (ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC) {
  2325. if (RES_IS_VSET(res->cfg_entry))
  2326. failing_lba =
  2327. le32_to_cpu(ioasa->u.
  2328. vset.failing_lba_lo);
  2329. sense_buf[0] |= 0x80;
  2330. sense_buf[3] = (failing_lba >> 24) & 0xff;
  2331. sense_buf[4] = (failing_lba >> 16) & 0xff;
  2332. sense_buf[5] = (failing_lba >> 8) & 0xff;
  2333. sense_buf[6] = failing_lba & 0xff;
  2334. }
  2335. sense_buf[7] = 6; /* additional length */
  2336. }
  2337. }
  2338. /**
  2339. * pmcraid_error_handler - Error response handlers for a SCSI op
  2340. * @cmd: pointer to pmcraid_cmd that has failed
  2341. *
  2342. * This function determines whether or not to initiate ERP on the affected
  2343. * device. This is called from a tasklet, which doesn't hold any locks.
  2344. *
  2345. * Return value:
  2346. * 0 it caller can complete the request, otherwise 1 where in error
  2347. * handler itself completes the request and returns the command block
  2348. * back to free-pool
  2349. */
  2350. static int pmcraid_error_handler(struct pmcraid_cmd *cmd)
  2351. {
  2352. struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
  2353. struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata;
  2354. struct pmcraid_instance *pinstance = cmd->drv_inst;
  2355. struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;
  2356. u32 ioasc = le32_to_cpu(ioasa->ioasc);
  2357. u32 masked_ioasc = ioasc & PMCRAID_IOASC_SENSE_MASK;
  2358. u32 sense_copied = 0;
  2359. if (!res) {
  2360. pmcraid_info("resource pointer is NULL\n");
  2361. return 0;
  2362. }
  2363. /* If this was a SCSI read/write command keep count of errors */
  2364. if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_READ_CMD)
  2365. atomic_inc(&res->read_failures);
  2366. else if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_WRITE_CMD)
  2367. atomic_inc(&res->write_failures);
  2368. if (!RES_IS_GSCSI(res->cfg_entry) &&
  2369. masked_ioasc != PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR) {
  2370. pmcraid_frame_auto_sense(cmd);
  2371. }
  2372. /* Log IOASC/IOASA information based on user settings */
  2373. pmcraid_ioasc_logger(ioasc, cmd);
  2374. switch (masked_ioasc) {
  2375. case PMCRAID_IOASC_AC_TERMINATED_BY_HOST:
  2376. scsi_cmd->result |= (DID_ABORT << 16);
  2377. break;
  2378. case PMCRAID_IOASC_IR_INVALID_RESOURCE_HANDLE:
  2379. case PMCRAID_IOASC_HW_CANNOT_COMMUNICATE:
  2380. scsi_cmd->result |= (DID_NO_CONNECT << 16);
  2381. break;
  2382. case PMCRAID_IOASC_NR_SYNC_REQUIRED:
  2383. res->sync_reqd = 1;
  2384. scsi_cmd->result |= (DID_IMM_RETRY << 16);
  2385. break;
  2386. case PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC:
  2387. scsi_cmd->result |= (DID_PASSTHROUGH << 16);
  2388. break;
  2389. case PMCRAID_IOASC_UA_BUS_WAS_RESET:
  2390. case PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER:
  2391. if (!res->reset_progress)
  2392. scsi_report_bus_reset(pinstance->host,
  2393. scsi_cmd->device->channel);
  2394. scsi_cmd->result |= (DID_ERROR << 16);
  2395. break;
  2396. case PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR:
  2397. scsi_cmd->result |= PMCRAID_IOASC_SENSE_STATUS(ioasc);
  2398. res->sync_reqd = 1;
  2399. /* if check_condition is not active return with error otherwise
  2400. * get/frame the sense buffer
  2401. */
  2402. if (PMCRAID_IOASC_SENSE_STATUS(ioasc) !=
  2403. SAM_STAT_CHECK_CONDITION &&
  2404. PMCRAID_IOASC_SENSE_STATUS(ioasc) != SAM_STAT_ACA_ACTIVE)
  2405. return 0;
  2406. /* If we have auto sense data as part of IOASA pass it to
  2407. * mid-layer
  2408. */
  2409. if (ioasa->auto_sense_length != 0) {
  2410. short sense_len = ioasa->auto_sense_length;
  2411. int data_size = min_t(u16, le16_to_cpu(sense_len),
  2412. SCSI_SENSE_BUFFERSIZE);
  2413. memcpy(scsi_cmd->sense_buffer,
  2414. ioasa->sense_data,
  2415. data_size);
  2416. sense_copied = 1;
  2417. }
  2418. if (RES_IS_GSCSI(res->cfg_entry))
  2419. pmcraid_cancel_all(cmd, sense_copied);
  2420. else if (sense_copied)
  2421. pmcraid_erp_done(cmd);
  2422. else
  2423. pmcraid_request_sense(cmd);
  2424. return 1;
  2425. case PMCRAID_IOASC_NR_INIT_CMD_REQUIRED:
  2426. break;
  2427. default:
  2428. if (PMCRAID_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
  2429. scsi_cmd->result |= (DID_ERROR << 16);
  2430. break;
  2431. }
  2432. return 0;
  2433. }
  2434. /**
  2435. * pmcraid_reset_device - device reset handler functions
  2436. *
  2437. * @scsi_cmd: scsi command struct
  2438. * @modifier: reset modifier indicating the reset sequence to be performed
  2439. *
  2440. * This function issues a device reset to the affected device.
  2441. * A LUN reset will be sent to the device first. If that does
  2442. * not work, a target reset will be sent.
  2443. *
  2444. * Return value:
  2445. * SUCCESS / FAILED
  2446. */
  2447. static int pmcraid_reset_device(
  2448. struct scsi_cmnd *scsi_cmd,
  2449. unsigned long timeout,
  2450. u8 modifier
  2451. )
  2452. {
  2453. struct pmcraid_cmd *cmd;
  2454. struct pmcraid_instance *pinstance;
  2455. struct pmcraid_resource_entry *res;
  2456. struct pmcraid_ioarcb *ioarcb;
  2457. unsigned long lock_flags;
  2458. u32 ioasc;
  2459. pinstance =
  2460. (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
  2461. res = scsi_cmd->device->hostdata;
  2462. if (!res) {
  2463. sdev_printk(KERN_ERR, scsi_cmd->device,
  2464. "reset_device: NULL resource pointer\n");
  2465. return FAILED;
  2466. }
  2467. /* If adapter is currently going through reset/reload, return failed.
  2468. * This will force the mid-layer to call _eh_bus/host reset, which
  2469. * will then go to sleep and wait for the reset to complete
  2470. */
  2471. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  2472. if (pinstance->ioa_reset_in_progress ||
  2473. pinstance->ioa_state == IOA_STATE_DEAD) {
  2474. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  2475. return FAILED;
  2476. }
  2477. res->reset_progress = 1;
  2478. pmcraid_info("Resetting %s resource with addr %x\n",
  2479. ((modifier & RESET_DEVICE_LUN) ? "LUN" :
  2480. ((modifier & RESET_DEVICE_TARGET) ? "TARGET" : "BUS")),
  2481. le32_to_cpu(res->cfg_entry.resource_address));
  2482. /* get a free cmd block */
  2483. cmd = pmcraid_get_free_cmd(pinstance);
  2484. if (cmd == NULL) {
  2485. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  2486. pmcraid_err("%s: no cmd blocks are available\n", __func__);
  2487. return FAILED;
  2488. }
  2489. ioarcb = &cmd->ioa_cb->ioarcb;
  2490. ioarcb->resource_handle = res->cfg_entry.resource_handle;
  2491. ioarcb->request_type = REQ_TYPE_IOACMD;
  2492. ioarcb->cdb[0] = PMCRAID_RESET_DEVICE;
  2493. /* Initialize reset modifier bits */
  2494. if (modifier)
  2495. modifier = ENABLE_RESET_MODIFIER | modifier;
  2496. ioarcb->cdb[1] = modifier;
  2497. init_completion(&cmd->wait_for_completion);
  2498. cmd->completion_req = 1;
  2499. pmcraid_info("cmd(CDB[0] = %x) for %x with index = %d\n",
  2500. cmd->ioa_cb->ioarcb.cdb[0],
  2501. le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle),
  2502. le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2);
  2503. pmcraid_send_cmd(cmd,
  2504. pmcraid_internal_done,
  2505. timeout,
  2506. pmcraid_timeout_handler);
  2507. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  2508. /* RESET_DEVICE command completes after all pending IOARCBs are
  2509. * completed. Once this command is completed, pmcraind_internal_done
  2510. * will wake up the 'completion' queue.
  2511. */
  2512. wait_for_completion(&cmd->wait_for_completion);
  2513. /* complete the command here itself and return the command block
  2514. * to free list
  2515. */
  2516. pmcraid_return_cmd(cmd);
  2517. res->reset_progress = 0;
  2518. ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
  2519. /* set the return value based on the returned ioasc */
  2520. return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
  2521. }
  2522. /**
  2523. * _pmcraid_io_done - helper for pmcraid_io_done function
  2524. *
  2525. * @cmd: pointer to pmcraid command struct
  2526. * @reslen: residual data length to be set in the ioasa
  2527. * @ioasc: ioasc either returned by IOA or set by driver itself.
  2528. *
  2529. * This function is invoked by pmcraid_io_done to complete mid-layer
  2530. * scsi ops.
  2531. *
  2532. * Return value:
  2533. * 0 if caller is required to return it to free_pool. Returns 1 if
  2534. * caller need not worry about freeing command block as error handler
  2535. * will take care of that.
  2536. */
  2537. static int _pmcraid_io_done(struct pmcraid_cmd *cmd, int reslen, int ioasc)
  2538. {
  2539. struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
  2540. int rc = 0;
  2541. scsi_set_resid(scsi_cmd, reslen);
  2542. pmcraid_info("response(%d) CDB[0] = %x ioasc:result: %x:%x\n",
  2543. le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
  2544. cmd->ioa_cb->ioarcb.cdb[0],
  2545. ioasc, scsi_cmd->result);
  2546. if (PMCRAID_IOASC_SENSE_KEY(ioasc) != 0)
  2547. rc = pmcraid_error_handler(cmd);
  2548. if (rc == 0) {
  2549. scsi_dma_unmap(scsi_cmd);
  2550. scsi_cmd->scsi_done(scsi_cmd);
  2551. }
  2552. return rc;
  2553. }
  2554. /**
  2555. * pmcraid_io_done - SCSI completion function
  2556. *
  2557. * @cmd: pointer to pmcraid command struct
  2558. *
  2559. * This function is invoked by tasklet/mid-layer error handler to completing
  2560. * the SCSI ops sent from mid-layer.
  2561. *
  2562. * Return value
  2563. * none
  2564. */
  2565. static void pmcraid_io_done(struct pmcraid_cmd *cmd)
  2566. {
  2567. u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
  2568. u32 reslen = le32_to_cpu(cmd->ioa_cb->ioasa.residual_data_length);
  2569. if (_pmcraid_io_done(cmd, reslen, ioasc) == 0)
  2570. pmcraid_return_cmd(cmd);
  2571. }
  2572. /**
  2573. * pmcraid_abort_cmd - Aborts a single IOARCB already submitted to IOA
  2574. *
  2575. * @cmd: command block of the command to be aborted
  2576. *
  2577. * Return Value:
  2578. * returns pointer to command structure used as cancelling cmd
  2579. */
  2580. static struct pmcraid_cmd *pmcraid_abort_cmd(struct pmcraid_cmd *cmd)
  2581. {
  2582. struct pmcraid_cmd *cancel_cmd;
  2583. struct pmcraid_instance *pinstance;
  2584. struct pmcraid_resource_entry *res;
  2585. pinstance = (struct pmcraid_instance *)cmd->drv_inst;
  2586. res = cmd->scsi_cmd->device->hostdata;
  2587. cancel_cmd = pmcraid_get_free_cmd(pinstance);
  2588. if (cancel_cmd == NULL) {
  2589. pmcraid_err("%s: no cmd blocks are available\n", __func__);
  2590. return NULL;
  2591. }
  2592. pmcraid_prepare_cancel_cmd(cancel_cmd, cmd);
  2593. pmcraid_info("aborting command CDB[0]= %x with index = %d\n",
  2594. cmd->ioa_cb->ioarcb.cdb[0],
  2595. cmd->ioa_cb->ioarcb.response_handle >> 2);
  2596. init_completion(&cancel_cmd->wait_for_completion);
  2597. cancel_cmd->completion_req = 1;
  2598. pmcraid_info("command (%d) CDB[0] = %x for %x\n",
  2599. le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.response_handle) >> 2,
  2600. cancel_cmd->ioa_cb->ioarcb.cdb[0],
  2601. le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.resource_handle));
  2602. pmcraid_send_cmd(cancel_cmd,
  2603. pmcraid_internal_done,
  2604. PMCRAID_INTERNAL_TIMEOUT,
  2605. pmcraid_timeout_handler);
  2606. return cancel_cmd;
  2607. }
  2608. /**
  2609. * pmcraid_abort_complete - Waits for ABORT TASK completion
  2610. *
  2611. * @cancel_cmd: command block use as cancelling command
  2612. *
  2613. * Return Value:
  2614. * returns SUCCESS if ABORT TASK has good completion
  2615. * otherwise FAILED
  2616. */
  2617. static int pmcraid_abort_complete(struct pmcraid_cmd *cancel_cmd)
  2618. {
  2619. struct pmcraid_resource_entry *res;
  2620. u32 ioasc;
  2621. wait_for_completion(&cancel_cmd->wait_for_completion);
  2622. res = cancel_cmd->res;
  2623. cancel_cmd->res = NULL;
  2624. ioasc = le32_to_cpu(cancel_cmd->ioa_cb->ioasa.ioasc);
  2625. /* If the abort task is not timed out we will get a Good completion
  2626. * as sense_key, otherwise we may get one the following responses
  2627. * due to subsequent bus reset or device reset. In case IOASC is
  2628. * NR_SYNC_REQUIRED, set sync_reqd flag for the corresponding resource
  2629. */
  2630. if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET ||
  2631. ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED) {
  2632. if (ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED)
  2633. res->sync_reqd = 1;
  2634. ioasc = 0;
  2635. }
  2636. /* complete the command here itself */
  2637. pmcraid_return_cmd(cancel_cmd);
  2638. return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
  2639. }
  2640. /**
  2641. * pmcraid_eh_abort_handler - entry point for aborting a single task on errors
  2642. *
  2643. * @scsi_cmd: scsi command struct given by mid-layer. When this is called
  2644. * mid-layer ensures that no other commands are queued. This
  2645. * never gets called under interrupt, but a separate eh thread.
  2646. *
  2647. * Return value:
  2648. * SUCCESS / FAILED
  2649. */
  2650. static int pmcraid_eh_abort_handler(struct scsi_cmnd *scsi_cmd)
  2651. {
  2652. struct pmcraid_instance *pinstance;
  2653. struct pmcraid_cmd *cmd;
  2654. struct pmcraid_resource_entry *res;
  2655. unsigned long host_lock_flags;
  2656. unsigned long pending_lock_flags;
  2657. struct pmcraid_cmd *cancel_cmd = NULL;
  2658. int cmd_found = 0;
  2659. int rc = FAILED;
  2660. pinstance =
  2661. (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
  2662. scmd_printk(KERN_INFO, scsi_cmd,
  2663. "I/O command timed out, aborting it.\n");
  2664. res = scsi_cmd->device->hostdata;
  2665. if (res == NULL)
  2666. return rc;
  2667. /* If we are currently going through reset/reload, return failed.
  2668. * This will force the mid-layer to eventually call
  2669. * pmcraid_eh_host_reset which will then go to sleep and wait for the
  2670. * reset to complete
  2671. */
  2672. spin_lock_irqsave(pinstance->host->host_lock, host_lock_flags);
  2673. if (pinstance->ioa_reset_in_progress ||
  2674. pinstance->ioa_state == IOA_STATE_DEAD) {
  2675. spin_unlock_irqrestore(pinstance->host->host_lock,
  2676. host_lock_flags);
  2677. return rc;
  2678. }
  2679. /* loop over pending cmd list to find cmd corresponding to this
  2680. * scsi_cmd. Note that this command might not have been completed
  2681. * already. locking: all pending commands are protected with
  2682. * pending_pool_lock.
  2683. */
  2684. spin_lock_irqsave(&pinstance->pending_pool_lock, pending_lock_flags);
  2685. list_for_each_entry(cmd, &pinstance->pending_cmd_pool, free_list) {
  2686. if (cmd->scsi_cmd == scsi_cmd) {
  2687. cmd_found = 1;
  2688. break;
  2689. }
  2690. }
  2691. spin_unlock_irqrestore(&pinstance->pending_pool_lock,
  2692. pending_lock_flags);
  2693. /* If the command to be aborted was given to IOA and still pending with
  2694. * it, send ABORT_TASK to abort this and wait for its completion
  2695. */
  2696. if (cmd_found)
  2697. cancel_cmd = pmcraid_abort_cmd(cmd);
  2698. spin_unlock_irqrestore(pinstance->host->host_lock,
  2699. host_lock_flags);
  2700. if (cancel_cmd) {
  2701. cancel_cmd->res = cmd->scsi_cmd->device->hostdata;
  2702. rc = pmcraid_abort_complete(cancel_cmd);
  2703. }
  2704. return cmd_found ? rc : SUCCESS;
  2705. }
  2706. /**
  2707. * pmcraid_eh_xxxx_reset_handler - bus/target/device reset handler callbacks
  2708. *
  2709. * @scmd: pointer to scsi_cmd that was sent to the resource to be reset.
  2710. *
  2711. * All these routines invokve pmcraid_reset_device with appropriate parameters.
  2712. * Since these are called from mid-layer EH thread, no other IO will be queued
  2713. * to the resource being reset. However, control path (IOCTL) may be active so
  2714. * it is necessary to synchronize IOARRIN writes which pmcraid_reset_device
  2715. * takes care by locking/unlocking host_lock.
  2716. *
  2717. * Return value
  2718. * SUCCESS or FAILED
  2719. */
  2720. static int pmcraid_eh_device_reset_handler(struct scsi_cmnd *scmd)
  2721. {
  2722. scmd_printk(KERN_INFO, scmd,
  2723. "resetting device due to an I/O command timeout.\n");
  2724. return pmcraid_reset_device(scmd,
  2725. PMCRAID_INTERNAL_TIMEOUT,
  2726. RESET_DEVICE_LUN);
  2727. }
  2728. static int pmcraid_eh_bus_reset_handler(struct scsi_cmnd *scmd)
  2729. {
  2730. scmd_printk(KERN_INFO, scmd,
  2731. "Doing bus reset due to an I/O command timeout.\n");
  2732. return pmcraid_reset_device(scmd,
  2733. PMCRAID_RESET_BUS_TIMEOUT,
  2734. RESET_DEVICE_BUS);
  2735. }
  2736. static int pmcraid_eh_target_reset_handler(struct scsi_cmnd *scmd)
  2737. {
  2738. scmd_printk(KERN_INFO, scmd,
  2739. "Doing target reset due to an I/O command timeout.\n");
  2740. return pmcraid_reset_device(scmd,
  2741. PMCRAID_INTERNAL_TIMEOUT,
  2742. RESET_DEVICE_TARGET);
  2743. }
  2744. /**
  2745. * pmcraid_eh_host_reset_handler - adapter reset handler callback
  2746. *
  2747. * @scmd: pointer to scsi_cmd that was sent to a resource of adapter
  2748. *
  2749. * Initiates adapter reset to bring it up to operational state
  2750. *
  2751. * Return value
  2752. * SUCCESS or FAILED
  2753. */
  2754. static int pmcraid_eh_host_reset_handler(struct scsi_cmnd *scmd)
  2755. {
  2756. unsigned long interval = 10000; /* 10 seconds interval */
  2757. int waits = jiffies_to_msecs(PMCRAID_RESET_HOST_TIMEOUT) / interval;
  2758. struct pmcraid_instance *pinstance =
  2759. (struct pmcraid_instance *)(scmd->device->host->hostdata);
  2760. /* wait for an additional 150 seconds just in case firmware could come
  2761. * up and if it could complete all the pending commands excluding the
  2762. * two HCAM (CCN and LDN).
  2763. */
  2764. while (waits--) {
  2765. if (atomic_read(&pinstance->outstanding_cmds) <=
  2766. PMCRAID_MAX_HCAM_CMD)
  2767. return SUCCESS;
  2768. msleep(interval);
  2769. }
  2770. dev_err(&pinstance->pdev->dev,
  2771. "Adapter being reset due to an I/O command timeout.\n");
  2772. return pmcraid_reset_bringup(pinstance) == 0 ? SUCCESS : FAILED;
  2773. }
  2774. /**
  2775. * pmcraid_task_attributes - Translate SPI Q-Tags to task attributes
  2776. * @scsi_cmd: scsi command struct
  2777. *
  2778. * Return value
  2779. * number of tags or 0 if the task is not tagged
  2780. */
  2781. static u8 pmcraid_task_attributes(struct scsi_cmnd *scsi_cmd)
  2782. {
  2783. char tag[2];
  2784. u8 rc = 0;
  2785. if (scsi_populate_tag_msg(scsi_cmd, tag)) {
  2786. switch (tag[0]) {
  2787. case MSG_SIMPLE_TAG:
  2788. rc = TASK_TAG_SIMPLE;
  2789. break;
  2790. case MSG_HEAD_TAG:
  2791. rc = TASK_TAG_QUEUE_HEAD;
  2792. break;
  2793. case MSG_ORDERED_TAG:
  2794. rc = TASK_TAG_ORDERED;
  2795. break;
  2796. };
  2797. }
  2798. return rc;
  2799. }
  2800. /**
  2801. * pmcraid_init_ioadls - initializes IOADL related fields in IOARCB
  2802. * @cmd: pmcraid command struct
  2803. * @sgcount: count of scatter-gather elements
  2804. *
  2805. * Return value
  2806. * returns pointer pmcraid_ioadl_desc, initialized to point to internal
  2807. * or external IOADLs
  2808. */
  2809. struct pmcraid_ioadl_desc *
  2810. pmcraid_init_ioadls(struct pmcraid_cmd *cmd, int sgcount)
  2811. {
  2812. struct pmcraid_ioadl_desc *ioadl;
  2813. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  2814. int ioadl_count = 0;
  2815. if (ioarcb->add_cmd_param_length)
  2816. ioadl_count = DIV_ROUND_UP(ioarcb->add_cmd_param_length, 16);
  2817. ioarcb->ioadl_length =
  2818. sizeof(struct pmcraid_ioadl_desc) * sgcount;
  2819. if ((sgcount + ioadl_count) > (ARRAY_SIZE(ioarcb->add_data.u.ioadl))) {
  2820. /* external ioadls start at offset 0x80 from control_block
  2821. * structure, re-using 24 out of 27 ioadls part of IOARCB.
  2822. * It is necessary to indicate to firmware that driver is
  2823. * using ioadls to be treated as external to IOARCB.
  2824. */
  2825. ioarcb->ioarcb_bus_addr &= ~(0x1FULL);
  2826. ioarcb->ioadl_bus_addr =
  2827. cpu_to_le64((cmd->ioa_cb_bus_addr) +
  2828. offsetof(struct pmcraid_ioarcb,
  2829. add_data.u.ioadl[3]));
  2830. ioadl = &ioarcb->add_data.u.ioadl[3];
  2831. } else {
  2832. ioarcb->ioadl_bus_addr =
  2833. cpu_to_le64((cmd->ioa_cb_bus_addr) +
  2834. offsetof(struct pmcraid_ioarcb,
  2835. add_data.u.ioadl[ioadl_count]));
  2836. ioadl = &ioarcb->add_data.u.ioadl[ioadl_count];
  2837. ioarcb->ioarcb_bus_addr |=
  2838. DIV_ROUND_CLOSEST(sgcount + ioadl_count, 8);
  2839. }
  2840. return ioadl;
  2841. }
  2842. /**
  2843. * pmcraid_build_ioadl - Build a scatter/gather list and map the buffer
  2844. * @pinstance: pointer to adapter instance structure
  2845. * @cmd: pmcraid command struct
  2846. *
  2847. * This function is invoked by queuecommand entry point while sending a command
  2848. * to firmware. This builds ioadl descriptors and sets up ioarcb fields.
  2849. *
  2850. * Return value:
  2851. * 0 on success or -1 on failure
  2852. */
  2853. static int pmcraid_build_ioadl(
  2854. struct pmcraid_instance *pinstance,
  2855. struct pmcraid_cmd *cmd
  2856. )
  2857. {
  2858. int i, nseg;
  2859. struct scatterlist *sglist;
  2860. struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
  2861. struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);
  2862. struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
  2863. u32 length = scsi_bufflen(scsi_cmd);
  2864. if (!length)
  2865. return 0;
  2866. nseg = scsi_dma_map(scsi_cmd);
  2867. if (nseg < 0) {
  2868. scmd_printk(KERN_ERR, scsi_cmd, "scsi_map_dma failed!\n");
  2869. return -1;
  2870. } else if (nseg > PMCRAID_MAX_IOADLS) {
  2871. scsi_dma_unmap(scsi_cmd);
  2872. scmd_printk(KERN_ERR, scsi_cmd,
  2873. "sg count is (%d) more than allowed!\n", nseg);
  2874. return -1;
  2875. }
  2876. /* Initialize IOARCB data transfer length fields */
  2877. if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE)
  2878. ioarcb->request_flags0 |= TRANSFER_DIR_WRITE;
  2879. ioarcb->request_flags0 |= NO_LINK_DESCS;
  2880. ioarcb->data_transfer_length = cpu_to_le32(length);
  2881. ioadl = pmcraid_init_ioadls(cmd, nseg);
  2882. /* Initialize IOADL descriptor addresses */
  2883. scsi_for_each_sg(scsi_cmd, sglist, nseg, i) {
  2884. ioadl[i].data_len = cpu_to_le32(sg_dma_len(sglist));
  2885. ioadl[i].address = cpu_to_le64(sg_dma_address(sglist));
  2886. ioadl[i].flags = 0;
  2887. }
  2888. /* setup last descriptor */
  2889. ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC;
  2890. return 0;
  2891. }
  2892. /**
  2893. * pmcraid_free_sglist - Frees an allocated SG buffer list
  2894. * @sglist: scatter/gather list pointer
  2895. *
  2896. * Free a DMA'able memory previously allocated with pmcraid_alloc_sglist
  2897. *
  2898. * Return value:
  2899. * none
  2900. */
  2901. static void pmcraid_free_sglist(struct pmcraid_sglist *sglist)
  2902. {
  2903. int i;
  2904. for (i = 0; i < sglist->num_sg; i++)
  2905. __free_pages(sg_page(&(sglist->scatterlist[i])),
  2906. sglist->order);
  2907. kfree(sglist);
  2908. }
  2909. /**
  2910. * pmcraid_alloc_sglist - Allocates memory for a SG list
  2911. * @buflen: buffer length
  2912. *
  2913. * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
  2914. * list.
  2915. *
  2916. * Return value
  2917. * pointer to sglist / NULL on failure
  2918. */
  2919. static struct pmcraid_sglist *pmcraid_alloc_sglist(int buflen)
  2920. {
  2921. struct pmcraid_sglist *sglist;
  2922. struct scatterlist *scatterlist;
  2923. struct page *page;
  2924. int num_elem, i, j;
  2925. int sg_size;
  2926. int order;
  2927. int bsize_elem;
  2928. sg_size = buflen / (PMCRAID_MAX_IOADLS - 1);
  2929. order = (sg_size > 0) ? get_order(sg_size) : 0;
  2930. bsize_elem = PAGE_SIZE * (1 << order);
  2931. /* Determine the actual number of sg entries needed */
  2932. if (buflen % bsize_elem)
  2933. num_elem = (buflen / bsize_elem) + 1;
  2934. else
  2935. num_elem = buflen / bsize_elem;
  2936. /* Allocate a scatter/gather list for the DMA */
  2937. sglist = kzalloc(sizeof(struct pmcraid_sglist) +
  2938. (sizeof(struct scatterlist) * (num_elem - 1)),
  2939. GFP_KERNEL);
  2940. if (sglist == NULL)
  2941. return NULL;
  2942. scatterlist = sglist->scatterlist;
  2943. sg_init_table(scatterlist, num_elem);
  2944. sglist->order = order;
  2945. sglist->num_sg = num_elem;
  2946. sg_size = buflen;
  2947. for (i = 0; i < num_elem; i++) {
  2948. page = alloc_pages(GFP_KERNEL|GFP_DMA|__GFP_ZERO, order);
  2949. if (!page) {
  2950. for (j = i - 1; j >= 0; j--)
  2951. __free_pages(sg_page(&scatterlist[j]), order);
  2952. kfree(sglist);
  2953. return NULL;
  2954. }
  2955. sg_set_page(&scatterlist[i], page,
  2956. sg_size < bsize_elem ? sg_size : bsize_elem, 0);
  2957. sg_size -= bsize_elem;
  2958. }
  2959. return sglist;
  2960. }
  2961. /**
  2962. * pmcraid_copy_sglist - Copy user buffer to kernel buffer's SG list
  2963. * @sglist: scatter/gather list pointer
  2964. * @buffer: buffer pointer
  2965. * @len: buffer length
  2966. * @direction: data transfer direction
  2967. *
  2968. * Copy a user buffer into a buffer allocated by pmcraid_alloc_sglist
  2969. *
  2970. * Return value:
  2971. * 0 on success / other on failure
  2972. */
  2973. static int pmcraid_copy_sglist(
  2974. struct pmcraid_sglist *sglist,
  2975. unsigned long buffer,
  2976. u32 len,
  2977. int direction
  2978. )
  2979. {
  2980. struct scatterlist *scatterlist;
  2981. void *kaddr;
  2982. int bsize_elem;
  2983. int i;
  2984. int rc = 0;
  2985. /* Determine the actual number of bytes per element */
  2986. bsize_elem = PAGE_SIZE * (1 << sglist->order);
  2987. scatterlist = sglist->scatterlist;
  2988. for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
  2989. struct page *page = sg_page(&scatterlist[i]);
  2990. kaddr = kmap(page);
  2991. if (direction == DMA_TO_DEVICE)
  2992. rc = __copy_from_user(kaddr,
  2993. (void *)buffer,
  2994. bsize_elem);
  2995. else
  2996. rc = __copy_to_user((void *)buffer, kaddr, bsize_elem);
  2997. kunmap(page);
  2998. if (rc) {
  2999. pmcraid_err("failed to copy user data into sg list\n");
  3000. return -EFAULT;
  3001. }
  3002. scatterlist[i].length = bsize_elem;
  3003. }
  3004. if (len % bsize_elem) {
  3005. struct page *page = sg_page(&scatterlist[i]);
  3006. kaddr = kmap(page);
  3007. if (direction == DMA_TO_DEVICE)
  3008. rc = __copy_from_user(kaddr,
  3009. (void *)buffer,
  3010. len % bsize_elem);
  3011. else
  3012. rc = __copy_to_user((void *)buffer,
  3013. kaddr,
  3014. len % bsize_elem);
  3015. kunmap(page);
  3016. scatterlist[i].length = len % bsize_elem;
  3017. }
  3018. if (rc) {
  3019. pmcraid_err("failed to copy user data into sg list\n");
  3020. rc = -EFAULT;
  3021. }
  3022. return rc;
  3023. }
  3024. /**
  3025. * pmcraid_queuecommand - Queue a mid-layer request
  3026. * @scsi_cmd: scsi command struct
  3027. * @done: done function
  3028. *
  3029. * This function queues a request generated by the mid-layer. Midlayer calls
  3030. * this routine within host->lock. Some of the functions called by queuecommand
  3031. * would use cmd block queue locks (free_pool_lock and pending_pool_lock)
  3032. *
  3033. * Return value:
  3034. * 0 on success
  3035. * SCSI_MLQUEUE_DEVICE_BUSY if device is busy
  3036. * SCSI_MLQUEUE_HOST_BUSY if host is busy
  3037. */
  3038. static int pmcraid_queuecommand_lck(
  3039. struct scsi_cmnd *scsi_cmd,
  3040. void (*done) (struct scsi_cmnd *)
  3041. )
  3042. {
  3043. struct pmcraid_instance *pinstance;
  3044. struct pmcraid_resource_entry *res;
  3045. struct pmcraid_ioarcb *ioarcb;
  3046. struct pmcraid_cmd *cmd;
  3047. u32 fw_version;
  3048. int rc = 0;
  3049. pinstance =
  3050. (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
  3051. fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
  3052. scsi_cmd->scsi_done = done;
  3053. res = scsi_cmd->device->hostdata;
  3054. scsi_cmd->result = (DID_OK << 16);
  3055. /* if adapter is marked as dead, set result to DID_NO_CONNECT complete
  3056. * the command
  3057. */
  3058. if (pinstance->ioa_state == IOA_STATE_DEAD) {
  3059. pmcraid_info("IOA is dead, but queuecommand is scheduled\n");
  3060. scsi_cmd->result = (DID_NO_CONNECT << 16);
  3061. scsi_cmd->scsi_done(scsi_cmd);
  3062. return 0;
  3063. }
  3064. /* If IOA reset is in progress, can't queue the commands */
  3065. if (pinstance->ioa_reset_in_progress)
  3066. return SCSI_MLQUEUE_HOST_BUSY;
  3067. /* Firmware doesn't support SYNCHRONIZE_CACHE command (0x35), complete
  3068. * the command here itself with success return
  3069. */
  3070. if (scsi_cmd->cmnd[0] == SYNCHRONIZE_CACHE) {
  3071. pmcraid_info("SYNC_CACHE(0x35), completing in driver itself\n");
  3072. scsi_cmd->scsi_done(scsi_cmd);
  3073. return 0;
  3074. }
  3075. /* initialize the command and IOARCB to be sent to IOA */
  3076. cmd = pmcraid_get_free_cmd(pinstance);
  3077. if (cmd == NULL) {
  3078. pmcraid_err("free command block is not available\n");
  3079. return SCSI_MLQUEUE_HOST_BUSY;
  3080. }
  3081. cmd->scsi_cmd = scsi_cmd;
  3082. ioarcb = &(cmd->ioa_cb->ioarcb);
  3083. memcpy(ioarcb->cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
  3084. ioarcb->resource_handle = res->cfg_entry.resource_handle;
  3085. ioarcb->request_type = REQ_TYPE_SCSI;
  3086. /* set hrrq number where the IOA should respond to. Note that all cmds
  3087. * generated internally uses hrrq_id 0, exception to this is the cmd
  3088. * block of scsi_cmd which is re-used (e.g. cancel/abort), which uses
  3089. * hrrq_id assigned here in queuecommand
  3090. */
  3091. ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
  3092. pinstance->num_hrrq;
  3093. cmd->cmd_done = pmcraid_io_done;
  3094. if (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry)) {
  3095. if (scsi_cmd->underflow == 0)
  3096. ioarcb->request_flags0 |= INHIBIT_UL_CHECK;
  3097. if (res->sync_reqd) {
  3098. ioarcb->request_flags0 |= SYNC_COMPLETE;
  3099. res->sync_reqd = 0;
  3100. }
  3101. ioarcb->request_flags0 |= NO_LINK_DESCS;
  3102. ioarcb->request_flags1 |= pmcraid_task_attributes(scsi_cmd);
  3103. if (RES_IS_GSCSI(res->cfg_entry))
  3104. ioarcb->request_flags1 |= DELAY_AFTER_RESET;
  3105. }
  3106. rc = pmcraid_build_ioadl(pinstance, cmd);
  3107. pmcraid_info("command (%d) CDB[0] = %x for %x:%x:%x:%x\n",
  3108. le32_to_cpu(ioarcb->response_handle) >> 2,
  3109. scsi_cmd->cmnd[0], pinstance->host->unique_id,
  3110. RES_IS_VSET(res->cfg_entry) ? PMCRAID_VSET_BUS_ID :
  3111. PMCRAID_PHYS_BUS_ID,
  3112. RES_IS_VSET(res->cfg_entry) ?
  3113. (fw_version <= PMCRAID_FW_VERSION_1 ?
  3114. res->cfg_entry.unique_flags1 :
  3115. res->cfg_entry.array_id & 0xFF) :
  3116. RES_TARGET(res->cfg_entry.resource_address),
  3117. RES_LUN(res->cfg_entry.resource_address));
  3118. if (likely(rc == 0)) {
  3119. _pmcraid_fire_command(cmd);
  3120. } else {
  3121. pmcraid_err("queuecommand could not build ioadl\n");
  3122. pmcraid_return_cmd(cmd);
  3123. rc = SCSI_MLQUEUE_HOST_BUSY;
  3124. }
  3125. return rc;
  3126. }
  3127. static DEF_SCSI_QCMD(pmcraid_queuecommand)
  3128. /**
  3129. * pmcraid_open -char node "open" entry, allowed only users with admin access
  3130. */
  3131. static int pmcraid_chr_open(struct inode *inode, struct file *filep)
  3132. {
  3133. struct pmcraid_instance *pinstance;
  3134. if (!capable(CAP_SYS_ADMIN))
  3135. return -EACCES;
  3136. /* Populate adapter instance * pointer for use by ioctl */
  3137. pinstance = container_of(inode->i_cdev, struct pmcraid_instance, cdev);
  3138. filep->private_data = pinstance;
  3139. return 0;
  3140. }
  3141. /**
  3142. * pmcraid_fasync - Async notifier registration from applications
  3143. *
  3144. * This function adds the calling process to a driver global queue. When an
  3145. * event occurs, SIGIO will be sent to all processes in this queue.
  3146. */
  3147. static int pmcraid_chr_fasync(int fd, struct file *filep, int mode)
  3148. {
  3149. struct pmcraid_instance *pinstance;
  3150. int rc;
  3151. pinstance = filep->private_data;
  3152. mutex_lock(&pinstance->aen_queue_lock);
  3153. rc = fasync_helper(fd, filep, mode, &pinstance->aen_queue);
  3154. mutex_unlock(&pinstance->aen_queue_lock);
  3155. return rc;
  3156. }
  3157. /**
  3158. * pmcraid_build_passthrough_ioadls - builds SG elements for passthrough
  3159. * commands sent over IOCTL interface
  3160. *
  3161. * @cmd : pointer to struct pmcraid_cmd
  3162. * @buflen : length of the request buffer
  3163. * @direction : data transfer direction
  3164. *
  3165. * Return value
  3166. * 0 on success, non-zero error code on failure
  3167. */
  3168. static int pmcraid_build_passthrough_ioadls(
  3169. struct pmcraid_cmd *cmd,
  3170. int buflen,
  3171. int direction
  3172. )
  3173. {
  3174. struct pmcraid_sglist *sglist = NULL;
  3175. struct scatterlist *sg = NULL;
  3176. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  3177. struct pmcraid_ioadl_desc *ioadl;
  3178. int i;
  3179. sglist = pmcraid_alloc_sglist(buflen);
  3180. if (!sglist) {
  3181. pmcraid_err("can't allocate memory for passthrough SGls\n");
  3182. return -ENOMEM;
  3183. }
  3184. sglist->num_dma_sg = pci_map_sg(cmd->drv_inst->pdev,
  3185. sglist->scatterlist,
  3186. sglist->num_sg, direction);
  3187. if (!sglist->num_dma_sg || sglist->num_dma_sg > PMCRAID_MAX_IOADLS) {
  3188. dev_err(&cmd->drv_inst->pdev->dev,
  3189. "Failed to map passthrough buffer!\n");
  3190. pmcraid_free_sglist(sglist);
  3191. return -EIO;
  3192. }
  3193. cmd->sglist = sglist;
  3194. ioarcb->request_flags0 |= NO_LINK_DESCS;
  3195. ioadl = pmcraid_init_ioadls(cmd, sglist->num_dma_sg);
  3196. /* Initialize IOADL descriptor addresses */
  3197. for_each_sg(sglist->scatterlist, sg, sglist->num_dma_sg, i) {
  3198. ioadl[i].data_len = cpu_to_le32(sg_dma_len(sg));
  3199. ioadl[i].address = cpu_to_le64(sg_dma_address(sg));
  3200. ioadl[i].flags = 0;
  3201. }
  3202. /* setup the last descriptor */
  3203. ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC;
  3204. return 0;
  3205. }
  3206. /**
  3207. * pmcraid_release_passthrough_ioadls - release passthrough ioadls
  3208. *
  3209. * @cmd: pointer to struct pmcraid_cmd for which ioadls were allocated
  3210. * @buflen: size of the request buffer
  3211. * @direction: data transfer direction
  3212. *
  3213. * Return value
  3214. * 0 on success, non-zero error code on failure
  3215. */
  3216. static void pmcraid_release_passthrough_ioadls(
  3217. struct pmcraid_cmd *cmd,
  3218. int buflen,
  3219. int direction
  3220. )
  3221. {
  3222. struct pmcraid_sglist *sglist = cmd->sglist;
  3223. if (buflen > 0) {
  3224. pci_unmap_sg(cmd->drv_inst->pdev,
  3225. sglist->scatterlist,
  3226. sglist->num_sg,
  3227. direction);
  3228. pmcraid_free_sglist(sglist);
  3229. cmd->sglist = NULL;
  3230. }
  3231. }
  3232. /**
  3233. * pmcraid_ioctl_passthrough - handling passthrough IOCTL commands
  3234. *
  3235. * @pinstance: pointer to adapter instance structure
  3236. * @cmd: ioctl code
  3237. * @arg: pointer to pmcraid_passthrough_buffer user buffer
  3238. *
  3239. * Return value
  3240. * 0 on success, non-zero error code on failure
  3241. */
  3242. static long pmcraid_ioctl_passthrough(
  3243. struct pmcraid_instance *pinstance,
  3244. unsigned int ioctl_cmd,
  3245. unsigned int buflen,
  3246. unsigned long arg
  3247. )
  3248. {
  3249. struct pmcraid_passthrough_ioctl_buffer *buffer;
  3250. struct pmcraid_ioarcb *ioarcb;
  3251. struct pmcraid_cmd *cmd;
  3252. struct pmcraid_cmd *cancel_cmd;
  3253. unsigned long request_buffer;
  3254. unsigned long request_offset;
  3255. unsigned long lock_flags;
  3256. void *ioasa;
  3257. u32 ioasc;
  3258. int request_size;
  3259. int buffer_size;
  3260. u8 access, direction;
  3261. int rc = 0;
  3262. /* If IOA reset is in progress, wait 10 secs for reset to complete */
  3263. if (pinstance->ioa_reset_in_progress) {
  3264. rc = wait_event_interruptible_timeout(
  3265. pinstance->reset_wait_q,
  3266. !pinstance->ioa_reset_in_progress,
  3267. msecs_to_jiffies(10000));
  3268. if (!rc)
  3269. return -ETIMEDOUT;
  3270. else if (rc < 0)
  3271. return -ERESTARTSYS;
  3272. }
  3273. /* If adapter is not in operational state, return error */
  3274. if (pinstance->ioa_state != IOA_STATE_OPERATIONAL) {
  3275. pmcraid_err("IOA is not operational\n");
  3276. return -ENOTTY;
  3277. }
  3278. buffer_size = sizeof(struct pmcraid_passthrough_ioctl_buffer);
  3279. buffer = kmalloc(buffer_size, GFP_KERNEL);
  3280. if (!buffer) {
  3281. pmcraid_err("no memory for passthrough buffer\n");
  3282. return -ENOMEM;
  3283. }
  3284. request_offset =
  3285. offsetof(struct pmcraid_passthrough_ioctl_buffer, request_buffer);
  3286. request_buffer = arg + request_offset;
  3287. rc = __copy_from_user(buffer,
  3288. (struct pmcraid_passthrough_ioctl_buffer *) arg,
  3289. sizeof(struct pmcraid_passthrough_ioctl_buffer));
  3290. ioasa =
  3291. (void *)(arg +
  3292. offsetof(struct pmcraid_passthrough_ioctl_buffer, ioasa));
  3293. if (rc) {
  3294. pmcraid_err("ioctl: can't copy passthrough buffer\n");
  3295. rc = -EFAULT;
  3296. goto out_free_buffer;
  3297. }
  3298. request_size = buffer->ioarcb.data_transfer_length;
  3299. if (buffer->ioarcb.request_flags0 & TRANSFER_DIR_WRITE) {
  3300. access = VERIFY_READ;
  3301. direction = DMA_TO_DEVICE;
  3302. } else {
  3303. access = VERIFY_WRITE;
  3304. direction = DMA_FROM_DEVICE;
  3305. }
  3306. if (request_size > 0) {
  3307. rc = access_ok(access, arg, request_offset + request_size);
  3308. if (!rc) {
  3309. rc = -EFAULT;
  3310. goto out_free_buffer;
  3311. }
  3312. } else if (request_size < 0) {
  3313. rc = -EINVAL;
  3314. goto out_free_buffer;
  3315. }
  3316. /* check if we have any additional command parameters */
  3317. if (buffer->ioarcb.add_cmd_param_length > PMCRAID_ADD_CMD_PARAM_LEN) {
  3318. rc = -EINVAL;
  3319. goto out_free_buffer;
  3320. }
  3321. cmd = pmcraid_get_free_cmd(pinstance);
  3322. if (!cmd) {
  3323. pmcraid_err("free command block is not available\n");
  3324. rc = -ENOMEM;
  3325. goto out_free_buffer;
  3326. }
  3327. cmd->scsi_cmd = NULL;
  3328. ioarcb = &(cmd->ioa_cb->ioarcb);
  3329. /* Copy the user-provided IOARCB stuff field by field */
  3330. ioarcb->resource_handle = buffer->ioarcb.resource_handle;
  3331. ioarcb->data_transfer_length = buffer->ioarcb.data_transfer_length;
  3332. ioarcb->cmd_timeout = buffer->ioarcb.cmd_timeout;
  3333. ioarcb->request_type = buffer->ioarcb.request_type;
  3334. ioarcb->request_flags0 = buffer->ioarcb.request_flags0;
  3335. ioarcb->request_flags1 = buffer->ioarcb.request_flags1;
  3336. memcpy(ioarcb->cdb, buffer->ioarcb.cdb, PMCRAID_MAX_CDB_LEN);
  3337. if (buffer->ioarcb.add_cmd_param_length) {
  3338. ioarcb->add_cmd_param_length =
  3339. buffer->ioarcb.add_cmd_param_length;
  3340. ioarcb->add_cmd_param_offset =
  3341. buffer->ioarcb.add_cmd_param_offset;
  3342. memcpy(ioarcb->add_data.u.add_cmd_params,
  3343. buffer->ioarcb.add_data.u.add_cmd_params,
  3344. buffer->ioarcb.add_cmd_param_length);
  3345. }
  3346. /* set hrrq number where the IOA should respond to. Note that all cmds
  3347. * generated internally uses hrrq_id 0, exception to this is the cmd
  3348. * block of scsi_cmd which is re-used (e.g. cancel/abort), which uses
  3349. * hrrq_id assigned here in queuecommand
  3350. */
  3351. ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
  3352. pinstance->num_hrrq;
  3353. if (request_size) {
  3354. rc = pmcraid_build_passthrough_ioadls(cmd,
  3355. request_size,
  3356. direction);
  3357. if (rc) {
  3358. pmcraid_err("couldn't build passthrough ioadls\n");
  3359. goto out_free_buffer;
  3360. }
  3361. } else if (request_size < 0) {
  3362. rc = -EINVAL;
  3363. goto out_free_buffer;
  3364. }
  3365. /* If data is being written into the device, copy the data from user
  3366. * buffers
  3367. */
  3368. if (direction == DMA_TO_DEVICE && request_size > 0) {
  3369. rc = pmcraid_copy_sglist(cmd->sglist,
  3370. request_buffer,
  3371. request_size,
  3372. direction);
  3373. if (rc) {
  3374. pmcraid_err("failed to copy user buffer\n");
  3375. goto out_free_sglist;
  3376. }
  3377. }
  3378. /* passthrough ioctl is a blocking command so, put the user to sleep
  3379. * until timeout. Note that a timeout value of 0 means, do timeout.
  3380. */
  3381. cmd->cmd_done = pmcraid_internal_done;
  3382. init_completion(&cmd->wait_for_completion);
  3383. cmd->completion_req = 1;
  3384. pmcraid_info("command(%d) (CDB[0] = %x) for %x\n",
  3385. le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
  3386. cmd->ioa_cb->ioarcb.cdb[0],
  3387. le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle));
  3388. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  3389. _pmcraid_fire_command(cmd);
  3390. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  3391. /* NOTE ! Remove the below line once abort_task is implemented
  3392. * in firmware. This line disables ioctl command timeout handling logic
  3393. * similar to IO command timeout handling, making ioctl commands to wait
  3394. * until the command completion regardless of timeout value specified in
  3395. * ioarcb
  3396. */
  3397. buffer->ioarcb.cmd_timeout = 0;
  3398. /* If command timeout is specified put caller to wait till that time,
  3399. * otherwise it would be blocking wait. If command gets timed out, it
  3400. * will be aborted.
  3401. */
  3402. if (buffer->ioarcb.cmd_timeout == 0) {
  3403. wait_for_completion(&cmd->wait_for_completion);
  3404. } else if (!wait_for_completion_timeout(
  3405. &cmd->wait_for_completion,
  3406. msecs_to_jiffies(buffer->ioarcb.cmd_timeout * 1000))) {
  3407. pmcraid_info("aborting cmd %d (CDB[0] = %x) due to timeout\n",
  3408. le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle >> 2),
  3409. cmd->ioa_cb->ioarcb.cdb[0]);
  3410. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  3411. cancel_cmd = pmcraid_abort_cmd(cmd);
  3412. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  3413. if (cancel_cmd) {
  3414. wait_for_completion(&cancel_cmd->wait_for_completion);
  3415. ioasc = cancel_cmd->ioa_cb->ioasa.ioasc;
  3416. pmcraid_return_cmd(cancel_cmd);
  3417. /* if abort task couldn't find the command i.e it got
  3418. * completed prior to aborting, return good completion.
  3419. * if command got aborted successfully or there was IOA
  3420. * reset due to abort task itself getting timedout then
  3421. * return -ETIMEDOUT
  3422. */
  3423. if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
  3424. PMCRAID_IOASC_SENSE_KEY(ioasc) == 0x00) {
  3425. if (ioasc != PMCRAID_IOASC_GC_IOARCB_NOTFOUND)
  3426. rc = -ETIMEDOUT;
  3427. goto out_handle_response;
  3428. }
  3429. }
  3430. /* no command block for abort task or abort task failed to abort
  3431. * the IOARCB, then wait for 150 more seconds and initiate reset
  3432. * sequence after timeout
  3433. */
  3434. if (!wait_for_completion_timeout(
  3435. &cmd->wait_for_completion,
  3436. msecs_to_jiffies(150 * 1000))) {
  3437. pmcraid_reset_bringup(cmd->drv_inst);
  3438. rc = -ETIMEDOUT;
  3439. }
  3440. }
  3441. out_handle_response:
  3442. /* copy entire IOASA buffer and return IOCTL success.
  3443. * If copying IOASA to user-buffer fails, return
  3444. * EFAULT
  3445. */
  3446. if (copy_to_user(ioasa, &cmd->ioa_cb->ioasa,
  3447. sizeof(struct pmcraid_ioasa))) {
  3448. pmcraid_err("failed to copy ioasa buffer to user\n");
  3449. rc = -EFAULT;
  3450. }
  3451. /* If the data transfer was from device, copy the data onto user
  3452. * buffers
  3453. */
  3454. else if (direction == DMA_FROM_DEVICE && request_size > 0) {
  3455. rc = pmcraid_copy_sglist(cmd->sglist,
  3456. request_buffer,
  3457. request_size,
  3458. direction);
  3459. if (rc) {
  3460. pmcraid_err("failed to copy user buffer\n");
  3461. rc = -EFAULT;
  3462. }
  3463. }
  3464. out_free_sglist:
  3465. pmcraid_release_passthrough_ioadls(cmd, request_size, direction);
  3466. pmcraid_return_cmd(cmd);
  3467. out_free_buffer:
  3468. kfree(buffer);
  3469. return rc;
  3470. }
  3471. /**
  3472. * pmcraid_ioctl_driver - ioctl handler for commands handled by driver itself
  3473. *
  3474. * @pinstance: pointer to adapter instance structure
  3475. * @cmd: ioctl command passed in
  3476. * @buflen: length of user_buffer
  3477. * @user_buffer: user buffer pointer
  3478. *
  3479. * Return Value
  3480. * 0 in case of success, otherwise appropriate error code
  3481. */
  3482. static long pmcraid_ioctl_driver(
  3483. struct pmcraid_instance *pinstance,
  3484. unsigned int cmd,
  3485. unsigned int buflen,
  3486. void __user *user_buffer
  3487. )
  3488. {
  3489. int rc = -ENOSYS;
  3490. if (!access_ok(VERIFY_READ, user_buffer, _IOC_SIZE(cmd))) {
  3491. pmcraid_err("ioctl_driver: access fault in request buffer\n");
  3492. return -EFAULT;
  3493. }
  3494. switch (cmd) {
  3495. case PMCRAID_IOCTL_RESET_ADAPTER:
  3496. pmcraid_reset_bringup(pinstance);
  3497. rc = 0;
  3498. break;
  3499. default:
  3500. break;
  3501. }
  3502. return rc;
  3503. }
  3504. /**
  3505. * pmcraid_check_ioctl_buffer - check for proper access to user buffer
  3506. *
  3507. * @cmd: ioctl command
  3508. * @arg: user buffer
  3509. * @hdr: pointer to kernel memory for pmcraid_ioctl_header
  3510. *
  3511. * Return Value
  3512. * negetive error code if there are access issues, otherwise zero.
  3513. * Upon success, returns ioctl header copied out of user buffer.
  3514. */
  3515. static int pmcraid_check_ioctl_buffer(
  3516. int cmd,
  3517. void __user *arg,
  3518. struct pmcraid_ioctl_header *hdr
  3519. )
  3520. {
  3521. int rc = 0;
  3522. int access = VERIFY_READ;
  3523. if (copy_from_user(hdr, arg, sizeof(struct pmcraid_ioctl_header))) {
  3524. pmcraid_err("couldn't copy ioctl header from user buffer\n");
  3525. return -EFAULT;
  3526. }
  3527. /* check for valid driver signature */
  3528. rc = memcmp(hdr->signature,
  3529. PMCRAID_IOCTL_SIGNATURE,
  3530. sizeof(hdr->signature));
  3531. if (rc) {
  3532. pmcraid_err("signature verification failed\n");
  3533. return -EINVAL;
  3534. }
  3535. /* check for appropriate buffer access */
  3536. if ((_IOC_DIR(cmd) & _IOC_READ) == _IOC_READ)
  3537. access = VERIFY_WRITE;
  3538. rc = access_ok(access,
  3539. (arg + sizeof(struct pmcraid_ioctl_header)),
  3540. hdr->buffer_length);
  3541. if (!rc) {
  3542. pmcraid_err("access failed for user buffer of size %d\n",
  3543. hdr->buffer_length);
  3544. return -EFAULT;
  3545. }
  3546. return 0;
  3547. }
  3548. /**
  3549. * pmcraid_ioctl - char node ioctl entry point
  3550. */
  3551. static long pmcraid_chr_ioctl(
  3552. struct file *filep,
  3553. unsigned int cmd,
  3554. unsigned long arg
  3555. )
  3556. {
  3557. struct pmcraid_instance *pinstance = NULL;
  3558. struct pmcraid_ioctl_header *hdr = NULL;
  3559. int retval = -ENOTTY;
  3560. hdr = kmalloc(sizeof(struct pmcraid_ioctl_header), GFP_KERNEL);
  3561. if (!hdr) {
  3562. pmcraid_err("failed to allocate memory for ioctl header\n");
  3563. return -ENOMEM;
  3564. }
  3565. retval = pmcraid_check_ioctl_buffer(cmd, (void *)arg, hdr);
  3566. if (retval) {
  3567. pmcraid_info("chr_ioctl: header check failed\n");
  3568. kfree(hdr);
  3569. return retval;
  3570. }
  3571. pinstance = filep->private_data;
  3572. if (!pinstance) {
  3573. pmcraid_info("adapter instance is not found\n");
  3574. kfree(hdr);
  3575. return -ENOTTY;
  3576. }
  3577. switch (_IOC_TYPE(cmd)) {
  3578. case PMCRAID_PASSTHROUGH_IOCTL:
  3579. /* If ioctl code is to download microcode, we need to block
  3580. * mid-layer requests.
  3581. */
  3582. if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
  3583. scsi_block_requests(pinstance->host);
  3584. retval = pmcraid_ioctl_passthrough(pinstance,
  3585. cmd,
  3586. hdr->buffer_length,
  3587. arg);
  3588. if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
  3589. scsi_unblock_requests(pinstance->host);
  3590. break;
  3591. case PMCRAID_DRIVER_IOCTL:
  3592. arg += sizeof(struct pmcraid_ioctl_header);
  3593. retval = pmcraid_ioctl_driver(pinstance,
  3594. cmd,
  3595. hdr->buffer_length,
  3596. (void __user *)arg);
  3597. break;
  3598. default:
  3599. retval = -ENOTTY;
  3600. break;
  3601. }
  3602. kfree(hdr);
  3603. return retval;
  3604. }
  3605. /**
  3606. * File operations structure for management interface
  3607. */
  3608. static const struct file_operations pmcraid_fops = {
  3609. .owner = THIS_MODULE,
  3610. .open = pmcraid_chr_open,
  3611. .fasync = pmcraid_chr_fasync,
  3612. .unlocked_ioctl = pmcraid_chr_ioctl,
  3613. #ifdef CONFIG_COMPAT
  3614. .compat_ioctl = pmcraid_chr_ioctl,
  3615. #endif
  3616. .llseek = noop_llseek,
  3617. };
  3618. /**
  3619. * pmcraid_show_log_level - Display adapter's error logging level
  3620. * @dev: class device struct
  3621. * @buf: buffer
  3622. *
  3623. * Return value:
  3624. * number of bytes printed to buffer
  3625. */
  3626. static ssize_t pmcraid_show_log_level(
  3627. struct device *dev,
  3628. struct device_attribute *attr,
  3629. char *buf)
  3630. {
  3631. struct Scsi_Host *shost = class_to_shost(dev);
  3632. struct pmcraid_instance *pinstance =
  3633. (struct pmcraid_instance *)shost->hostdata;
  3634. return snprintf(buf, PAGE_SIZE, "%d\n", pinstance->current_log_level);
  3635. }
  3636. /**
  3637. * pmcraid_store_log_level - Change the adapter's error logging level
  3638. * @dev: class device struct
  3639. * @buf: buffer
  3640. * @count: not used
  3641. *
  3642. * Return value:
  3643. * number of bytes printed to buffer
  3644. */
  3645. static ssize_t pmcraid_store_log_level(
  3646. struct device *dev,
  3647. struct device_attribute *attr,
  3648. const char *buf,
  3649. size_t count
  3650. )
  3651. {
  3652. struct Scsi_Host *shost;
  3653. struct pmcraid_instance *pinstance;
  3654. unsigned long val;
  3655. if (strict_strtoul(buf, 10, &val))
  3656. return -EINVAL;
  3657. /* log-level should be from 0 to 2 */
  3658. if (val > 2)
  3659. return -EINVAL;
  3660. shost = class_to_shost(dev);
  3661. pinstance = (struct pmcraid_instance *)shost->hostdata;
  3662. pinstance->current_log_level = val;
  3663. return strlen(buf);
  3664. }
  3665. static struct device_attribute pmcraid_log_level_attr = {
  3666. .attr = {
  3667. .name = "log_level",
  3668. .mode = S_IRUGO | S_IWUSR,
  3669. },
  3670. .show = pmcraid_show_log_level,
  3671. .store = pmcraid_store_log_level,
  3672. };
  3673. /**
  3674. * pmcraid_show_drv_version - Display driver version
  3675. * @dev: class device struct
  3676. * @buf: buffer
  3677. *
  3678. * Return value:
  3679. * number of bytes printed to buffer
  3680. */
  3681. static ssize_t pmcraid_show_drv_version(
  3682. struct device *dev,
  3683. struct device_attribute *attr,
  3684. char *buf
  3685. )
  3686. {
  3687. return snprintf(buf, PAGE_SIZE, "version: %s\n",
  3688. PMCRAID_DRIVER_VERSION);
  3689. }
  3690. static struct device_attribute pmcraid_driver_version_attr = {
  3691. .attr = {
  3692. .name = "drv_version",
  3693. .mode = S_IRUGO,
  3694. },
  3695. .show = pmcraid_show_drv_version,
  3696. };
  3697. /**
  3698. * pmcraid_show_io_adapter_id - Display driver assigned adapter id
  3699. * @dev: class device struct
  3700. * @buf: buffer
  3701. *
  3702. * Return value:
  3703. * number of bytes printed to buffer
  3704. */
  3705. static ssize_t pmcraid_show_adapter_id(
  3706. struct device *dev,
  3707. struct device_attribute *attr,
  3708. char *buf
  3709. )
  3710. {
  3711. struct Scsi_Host *shost = class_to_shost(dev);
  3712. struct pmcraid_instance *pinstance =
  3713. (struct pmcraid_instance *)shost->hostdata;
  3714. u32 adapter_id = (pinstance->pdev->bus->number << 8) |
  3715. pinstance->pdev->devfn;
  3716. u32 aen_group = pmcraid_event_family.id;
  3717. return snprintf(buf, PAGE_SIZE,
  3718. "adapter id: %d\nminor: %d\naen group: %d\n",
  3719. adapter_id, MINOR(pinstance->cdev.dev), aen_group);
  3720. }
  3721. static struct device_attribute pmcraid_adapter_id_attr = {
  3722. .attr = {
  3723. .name = "adapter_id",
  3724. .mode = S_IRUGO | S_IWUSR,
  3725. },
  3726. .show = pmcraid_show_adapter_id,
  3727. };
  3728. static struct device_attribute *pmcraid_host_attrs[] = {
  3729. &pmcraid_log_level_attr,
  3730. &pmcraid_driver_version_attr,
  3731. &pmcraid_adapter_id_attr,
  3732. NULL,
  3733. };
  3734. /* host template structure for pmcraid driver */
  3735. static struct scsi_host_template pmcraid_host_template = {
  3736. .module = THIS_MODULE,
  3737. .name = PMCRAID_DRIVER_NAME,
  3738. .queuecommand = pmcraid_queuecommand,
  3739. .eh_abort_handler = pmcraid_eh_abort_handler,
  3740. .eh_bus_reset_handler = pmcraid_eh_bus_reset_handler,
  3741. .eh_target_reset_handler = pmcraid_eh_target_reset_handler,
  3742. .eh_device_reset_handler = pmcraid_eh_device_reset_handler,
  3743. .eh_host_reset_handler = pmcraid_eh_host_reset_handler,
  3744. .slave_alloc = pmcraid_slave_alloc,
  3745. .slave_configure = pmcraid_slave_configure,
  3746. .slave_destroy = pmcraid_slave_destroy,
  3747. .change_queue_depth = pmcraid_change_queue_depth,
  3748. .change_queue_type = pmcraid_change_queue_type,
  3749. .can_queue = PMCRAID_MAX_IO_CMD,
  3750. .this_id = -1,
  3751. .sg_tablesize = PMCRAID_MAX_IOADLS,
  3752. .max_sectors = PMCRAID_IOA_MAX_SECTORS,
  3753. .cmd_per_lun = PMCRAID_MAX_CMD_PER_LUN,
  3754. .use_clustering = ENABLE_CLUSTERING,
  3755. .shost_attrs = pmcraid_host_attrs,
  3756. .proc_name = PMCRAID_DRIVER_NAME
  3757. };
  3758. /*
  3759. * pmcraid_isr_msix - implements MSI-X interrupt handling routine
  3760. * @irq: interrupt vector number
  3761. * @dev_id: pointer hrrq_vector
  3762. *
  3763. * Return Value
  3764. * IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored
  3765. */
  3766. static irqreturn_t pmcraid_isr_msix(int irq, void *dev_id)
  3767. {
  3768. struct pmcraid_isr_param *hrrq_vector;
  3769. struct pmcraid_instance *pinstance;
  3770. unsigned long lock_flags;
  3771. u32 intrs_val;
  3772. int hrrq_id;
  3773. hrrq_vector = (struct pmcraid_isr_param *)dev_id;
  3774. hrrq_id = hrrq_vector->hrrq_id;
  3775. pinstance = hrrq_vector->drv_inst;
  3776. if (!hrrq_id) {
  3777. /* Read the interrupt */
  3778. intrs_val = pmcraid_read_interrupts(pinstance);
  3779. if (intrs_val &&
  3780. ((ioread32(pinstance->int_regs.host_ioa_interrupt_reg)
  3781. & DOORBELL_INTR_MSIX_CLR) == 0)) {
  3782. /* Any error interrupts including unit_check,
  3783. * initiate IOA reset.In case of unit check indicate
  3784. * to reset_sequence that IOA unit checked and prepare
  3785. * for a dump during reset sequence
  3786. */
  3787. if (intrs_val & PMCRAID_ERROR_INTERRUPTS) {
  3788. if (intrs_val & INTRS_IOA_UNIT_CHECK)
  3789. pinstance->ioa_unit_check = 1;
  3790. pmcraid_err("ISR: error interrupts: %x \
  3791. initiating reset\n", intrs_val);
  3792. spin_lock_irqsave(pinstance->host->host_lock,
  3793. lock_flags);
  3794. pmcraid_initiate_reset(pinstance);
  3795. spin_unlock_irqrestore(
  3796. pinstance->host->host_lock,
  3797. lock_flags);
  3798. }
  3799. /* If interrupt was as part of the ioa initialization,
  3800. * clear it. Delete the timer and wakeup the
  3801. * reset engine to proceed with reset sequence
  3802. */
  3803. if (intrs_val & INTRS_TRANSITION_TO_OPERATIONAL)
  3804. pmcraid_clr_trans_op(pinstance);
  3805. /* Clear the interrupt register by writing
  3806. * to host to ioa doorbell. Once done
  3807. * FW will clear the interrupt.
  3808. */
  3809. iowrite32(DOORBELL_INTR_MSIX_CLR,
  3810. pinstance->int_regs.host_ioa_interrupt_reg);
  3811. ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
  3812. }
  3813. }
  3814. tasklet_schedule(&(pinstance->isr_tasklet[hrrq_id]));
  3815. return IRQ_HANDLED;
  3816. }
  3817. /**
  3818. * pmcraid_isr - implements legacy interrupt handling routine
  3819. *
  3820. * @irq: interrupt vector number
  3821. * @dev_id: pointer hrrq_vector
  3822. *
  3823. * Return Value
  3824. * IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored
  3825. */
  3826. static irqreturn_t pmcraid_isr(int irq, void *dev_id)
  3827. {
  3828. struct pmcraid_isr_param *hrrq_vector;
  3829. struct pmcraid_instance *pinstance;
  3830. u32 intrs;
  3831. unsigned long lock_flags;
  3832. int hrrq_id = 0;
  3833. /* In case of legacy interrupt mode where interrupts are shared across
  3834. * isrs, it may be possible that the current interrupt is not from IOA
  3835. */
  3836. if (!dev_id) {
  3837. printk(KERN_INFO "%s(): NULL host pointer\n", __func__);
  3838. return IRQ_NONE;
  3839. }
  3840. hrrq_vector = (struct pmcraid_isr_param *)dev_id;
  3841. pinstance = hrrq_vector->drv_inst;
  3842. intrs = pmcraid_read_interrupts(pinstance);
  3843. if (unlikely((intrs & PMCRAID_PCI_INTERRUPTS) == 0))
  3844. return IRQ_NONE;
  3845. /* Any error interrupts including unit_check, initiate IOA reset.
  3846. * In case of unit check indicate to reset_sequence that IOA unit
  3847. * checked and prepare for a dump during reset sequence
  3848. */
  3849. if (intrs & PMCRAID_ERROR_INTERRUPTS) {
  3850. if (intrs & INTRS_IOA_UNIT_CHECK)
  3851. pinstance->ioa_unit_check = 1;
  3852. iowrite32(intrs,
  3853. pinstance->int_regs.ioa_host_interrupt_clr_reg);
  3854. pmcraid_err("ISR: error interrupts: %x initiating reset\n",
  3855. intrs);
  3856. intrs = ioread32(
  3857. pinstance->int_regs.ioa_host_interrupt_clr_reg);
  3858. spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
  3859. pmcraid_initiate_reset(pinstance);
  3860. spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
  3861. } else {
  3862. /* If interrupt was as part of the ioa initialization,
  3863. * clear. Delete the timer and wakeup the
  3864. * reset engine to proceed with reset sequence
  3865. */
  3866. if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) {
  3867. pmcraid_clr_trans_op(pinstance);
  3868. } else {
  3869. iowrite32(intrs,
  3870. pinstance->int_regs.ioa_host_interrupt_clr_reg);
  3871. ioread32(
  3872. pinstance->int_regs.ioa_host_interrupt_clr_reg);
  3873. tasklet_schedule(
  3874. &(pinstance->isr_tasklet[hrrq_id]));
  3875. }
  3876. }
  3877. return IRQ_HANDLED;
  3878. }
  3879. /**
  3880. * pmcraid_worker_function - worker thread function
  3881. *
  3882. * @workp: pointer to struct work queue
  3883. *
  3884. * Return Value
  3885. * None
  3886. */
  3887. static void pmcraid_worker_function(struct work_struct *workp)
  3888. {
  3889. struct pmcraid_instance *pinstance;
  3890. struct pmcraid_resource_entry *res;
  3891. struct pmcraid_resource_entry *temp;
  3892. struct scsi_device *sdev;
  3893. unsigned long lock_flags;
  3894. unsigned long host_lock_flags;
  3895. u16 fw_version;
  3896. u8 bus, target, lun;
  3897. pinstance = container_of(workp, struct pmcraid_instance, worker_q);
  3898. /* add resources only after host is added into system */
  3899. if (!atomic_read(&pinstance->expose_resources))
  3900. return;
  3901. fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
  3902. spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
  3903. list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) {
  3904. if (res->change_detected == RES_CHANGE_DEL && res->scsi_dev) {
  3905. sdev = res->scsi_dev;
  3906. /* host_lock must be held before calling
  3907. * scsi_device_get
  3908. */
  3909. spin_lock_irqsave(pinstance->host->host_lock,
  3910. host_lock_flags);
  3911. if (!scsi_device_get(sdev)) {
  3912. spin_unlock_irqrestore(
  3913. pinstance->host->host_lock,
  3914. host_lock_flags);
  3915. pmcraid_info("deleting %x from midlayer\n",
  3916. res->cfg_entry.resource_address);
  3917. list_move_tail(&res->queue,
  3918. &pinstance->free_res_q);
  3919. spin_unlock_irqrestore(
  3920. &pinstance->resource_lock,
  3921. lock_flags);
  3922. scsi_remove_device(sdev);
  3923. scsi_device_put(sdev);
  3924. spin_lock_irqsave(&pinstance->resource_lock,
  3925. lock_flags);
  3926. res->change_detected = 0;
  3927. } else {
  3928. spin_unlock_irqrestore(
  3929. pinstance->host->host_lock,
  3930. host_lock_flags);
  3931. }
  3932. }
  3933. }
  3934. list_for_each_entry(res, &pinstance->used_res_q, queue) {
  3935. if (res->change_detected == RES_CHANGE_ADD) {
  3936. if (!pmcraid_expose_resource(fw_version,
  3937. &res->cfg_entry))
  3938. continue;
  3939. if (RES_IS_VSET(res->cfg_entry)) {
  3940. bus = PMCRAID_VSET_BUS_ID;
  3941. if (fw_version <= PMCRAID_FW_VERSION_1)
  3942. target = res->cfg_entry.unique_flags1;
  3943. else
  3944. target = res->cfg_entry.array_id & 0xFF;
  3945. lun = PMCRAID_VSET_LUN_ID;
  3946. } else {
  3947. bus = PMCRAID_PHYS_BUS_ID;
  3948. target =
  3949. RES_TARGET(
  3950. res->cfg_entry.resource_address);
  3951. lun = RES_LUN(res->cfg_entry.resource_address);
  3952. }
  3953. res->change_detected = 0;
  3954. spin_unlock_irqrestore(&pinstance->resource_lock,
  3955. lock_flags);
  3956. scsi_add_device(pinstance->host, bus, target, lun);
  3957. spin_lock_irqsave(&pinstance->resource_lock,
  3958. lock_flags);
  3959. }
  3960. }
  3961. spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
  3962. }
  3963. /**
  3964. * pmcraid_tasklet_function - Tasklet function
  3965. *
  3966. * @instance: pointer to msix param structure
  3967. *
  3968. * Return Value
  3969. * None
  3970. */
  3971. static void pmcraid_tasklet_function(unsigned long instance)
  3972. {
  3973. struct pmcraid_isr_param *hrrq_vector;
  3974. struct pmcraid_instance *pinstance;
  3975. unsigned long hrrq_lock_flags;
  3976. unsigned long pending_lock_flags;
  3977. unsigned long host_lock_flags;
  3978. spinlock_t *lockp; /* hrrq buffer lock */
  3979. int id;
  3980. __le32 resp;
  3981. hrrq_vector = (struct pmcraid_isr_param *)instance;
  3982. pinstance = hrrq_vector->drv_inst;
  3983. id = hrrq_vector->hrrq_id;
  3984. lockp = &(pinstance->hrrq_lock[id]);
  3985. /* loop through each of the commands responded by IOA. Each HRRQ buf is
  3986. * protected by its own lock. Traversals must be done within this lock
  3987. * as there may be multiple tasklets running on multiple CPUs. Note
  3988. * that the lock is held just for picking up the response handle and
  3989. * manipulating hrrq_curr/toggle_bit values.
  3990. */
  3991. spin_lock_irqsave(lockp, hrrq_lock_flags);
  3992. resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
  3993. while ((resp & HRRQ_TOGGLE_BIT) ==
  3994. pinstance->host_toggle_bit[id]) {
  3995. int cmd_index = resp >> 2;
  3996. struct pmcraid_cmd *cmd = NULL;
  3997. if (pinstance->hrrq_curr[id] < pinstance->hrrq_end[id]) {
  3998. pinstance->hrrq_curr[id]++;
  3999. } else {
  4000. pinstance->hrrq_curr[id] = pinstance->hrrq_start[id];
  4001. pinstance->host_toggle_bit[id] ^= 1u;
  4002. }
  4003. if (cmd_index >= PMCRAID_MAX_CMD) {
  4004. /* In case of invalid response handle, log message */
  4005. pmcraid_err("Invalid response handle %d\n", cmd_index);
  4006. resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
  4007. continue;
  4008. }
  4009. cmd = pinstance->cmd_list[cmd_index];
  4010. spin_unlock_irqrestore(lockp, hrrq_lock_flags);
  4011. spin_lock_irqsave(&pinstance->pending_pool_lock,
  4012. pending_lock_flags);
  4013. list_del(&cmd->free_list);
  4014. spin_unlock_irqrestore(&pinstance->pending_pool_lock,
  4015. pending_lock_flags);
  4016. del_timer(&cmd->timer);
  4017. atomic_dec(&pinstance->outstanding_cmds);
  4018. if (cmd->cmd_done == pmcraid_ioa_reset) {
  4019. spin_lock_irqsave(pinstance->host->host_lock,
  4020. host_lock_flags);
  4021. cmd->cmd_done(cmd);
  4022. spin_unlock_irqrestore(pinstance->host->host_lock,
  4023. host_lock_flags);
  4024. } else if (cmd->cmd_done != NULL) {
  4025. cmd->cmd_done(cmd);
  4026. }
  4027. /* loop over until we are done with all responses */
  4028. spin_lock_irqsave(lockp, hrrq_lock_flags);
  4029. resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
  4030. }
  4031. spin_unlock_irqrestore(lockp, hrrq_lock_flags);
  4032. }
  4033. /**
  4034. * pmcraid_unregister_interrupt_handler - de-register interrupts handlers
  4035. * @pinstance: pointer to adapter instance structure
  4036. *
  4037. * This routine un-registers registered interrupt handler and
  4038. * also frees irqs/vectors.
  4039. *
  4040. * Retun Value
  4041. * None
  4042. */
  4043. static
  4044. void pmcraid_unregister_interrupt_handler(struct pmcraid_instance *pinstance)
  4045. {
  4046. int i;
  4047. for (i = 0; i < pinstance->num_hrrq; i++)
  4048. free_irq(pinstance->hrrq_vector[i].vector,
  4049. &(pinstance->hrrq_vector[i]));
  4050. if (pinstance->interrupt_mode) {
  4051. pci_disable_msix(pinstance->pdev);
  4052. pinstance->interrupt_mode = 0;
  4053. }
  4054. }
  4055. /**
  4056. * pmcraid_register_interrupt_handler - registers interrupt handler
  4057. * @pinstance: pointer to per-adapter instance structure
  4058. *
  4059. * Return Value
  4060. * 0 on success, non-zero error code otherwise.
  4061. */
  4062. static int
  4063. pmcraid_register_interrupt_handler(struct pmcraid_instance *pinstance)
  4064. {
  4065. int rc;
  4066. struct pci_dev *pdev = pinstance->pdev;
  4067. if ((pmcraid_enable_msix) &&
  4068. (pci_find_capability(pdev, PCI_CAP_ID_MSIX))) {
  4069. int num_hrrq = PMCRAID_NUM_MSIX_VECTORS;
  4070. struct msix_entry entries[PMCRAID_NUM_MSIX_VECTORS];
  4071. int i;
  4072. for (i = 0; i < PMCRAID_NUM_MSIX_VECTORS; i++)
  4073. entries[i].entry = i;
  4074. rc = pci_enable_msix(pdev, entries, num_hrrq);
  4075. if (rc < 0)
  4076. goto pmcraid_isr_legacy;
  4077. /* Check how many MSIX vectors are allocated and register
  4078. * msi-x handlers for each of them giving appropriate buffer
  4079. */
  4080. if (rc > 0) {
  4081. num_hrrq = rc;
  4082. if (pci_enable_msix(pdev, entries, num_hrrq))
  4083. goto pmcraid_isr_legacy;
  4084. }
  4085. for (i = 0; i < num_hrrq; i++) {
  4086. pinstance->hrrq_vector[i].hrrq_id = i;
  4087. pinstance->hrrq_vector[i].drv_inst = pinstance;
  4088. pinstance->hrrq_vector[i].vector = entries[i].vector;
  4089. rc = request_irq(pinstance->hrrq_vector[i].vector,
  4090. pmcraid_isr_msix, 0,
  4091. PMCRAID_DRIVER_NAME,
  4092. &(pinstance->hrrq_vector[i]));
  4093. if (rc) {
  4094. int j;
  4095. for (j = 0; j < i; j++)
  4096. free_irq(entries[j].vector,
  4097. &(pinstance->hrrq_vector[j]));
  4098. pci_disable_msix(pdev);
  4099. goto pmcraid_isr_legacy;
  4100. }
  4101. }
  4102. pinstance->num_hrrq = num_hrrq;
  4103. pinstance->interrupt_mode = 1;
  4104. iowrite32(DOORBELL_INTR_MODE_MSIX,
  4105. pinstance->int_regs.host_ioa_interrupt_reg);
  4106. ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
  4107. goto pmcraid_isr_out;
  4108. }
  4109. pmcraid_isr_legacy:
  4110. /* If MSI-X registration failed fallback to legacy mode, where
  4111. * only one hrrq entry will be used
  4112. */
  4113. pinstance->hrrq_vector[0].hrrq_id = 0;
  4114. pinstance->hrrq_vector[0].drv_inst = pinstance;
  4115. pinstance->hrrq_vector[0].vector = pdev->irq;
  4116. pinstance->num_hrrq = 1;
  4117. rc = 0;
  4118. rc = request_irq(pdev->irq, pmcraid_isr, IRQF_SHARED,
  4119. PMCRAID_DRIVER_NAME, &pinstance->hrrq_vector[0]);
  4120. pmcraid_isr_out:
  4121. return rc;
  4122. }
  4123. /**
  4124. * pmcraid_release_cmd_blocks - release buufers allocated for command blocks
  4125. * @pinstance: per adapter instance structure pointer
  4126. * @max_index: number of buffer blocks to release
  4127. *
  4128. * Return Value
  4129. * None
  4130. */
  4131. static void
  4132. pmcraid_release_cmd_blocks(struct pmcraid_instance *pinstance, int max_index)
  4133. {
  4134. int i;
  4135. for (i = 0; i < max_index; i++) {
  4136. kmem_cache_free(pinstance->cmd_cachep, pinstance->cmd_list[i]);
  4137. pinstance->cmd_list[i] = NULL;
  4138. }
  4139. kmem_cache_destroy(pinstance->cmd_cachep);
  4140. pinstance->cmd_cachep = NULL;
  4141. }
  4142. /**
  4143. * pmcraid_release_control_blocks - releases buffers alloced for control blocks
  4144. * @pinstance: pointer to per adapter instance structure
  4145. * @max_index: number of buffers (from 0 onwards) to release
  4146. *
  4147. * This function assumes that the command blocks for which control blocks are
  4148. * linked are not released.
  4149. *
  4150. * Return Value
  4151. * None
  4152. */
  4153. static void
  4154. pmcraid_release_control_blocks(
  4155. struct pmcraid_instance *pinstance,
  4156. int max_index
  4157. )
  4158. {
  4159. int i;
  4160. if (pinstance->control_pool == NULL)
  4161. return;
  4162. for (i = 0; i < max_index; i++) {
  4163. pci_pool_free(pinstance->control_pool,
  4164. pinstance->cmd_list[i]->ioa_cb,
  4165. pinstance->cmd_list[i]->ioa_cb_bus_addr);
  4166. pinstance->cmd_list[i]->ioa_cb = NULL;
  4167. pinstance->cmd_list[i]->ioa_cb_bus_addr = 0;
  4168. }
  4169. pci_pool_destroy(pinstance->control_pool);
  4170. pinstance->control_pool = NULL;
  4171. }
  4172. /**
  4173. * pmcraid_allocate_cmd_blocks - allocate memory for cmd block structures
  4174. * @pinstance - pointer to per adapter instance structure
  4175. *
  4176. * Allocates memory for command blocks using kernel slab allocator.
  4177. *
  4178. * Return Value
  4179. * 0 in case of success; -ENOMEM in case of failure
  4180. */
  4181. static int pmcraid_allocate_cmd_blocks(struct pmcraid_instance *pinstance)
  4182. {
  4183. int i;
  4184. sprintf(pinstance->cmd_pool_name, "pmcraid_cmd_pool_%d",
  4185. pinstance->host->unique_id);
  4186. pinstance->cmd_cachep = kmem_cache_create(
  4187. pinstance->cmd_pool_name,
  4188. sizeof(struct pmcraid_cmd), 0,
  4189. SLAB_HWCACHE_ALIGN, NULL);
  4190. if (!pinstance->cmd_cachep)
  4191. return -ENOMEM;
  4192. for (i = 0; i < PMCRAID_MAX_CMD; i++) {
  4193. pinstance->cmd_list[i] =
  4194. kmem_cache_alloc(pinstance->cmd_cachep, GFP_KERNEL);
  4195. if (!pinstance->cmd_list[i]) {
  4196. pmcraid_release_cmd_blocks(pinstance, i);
  4197. return -ENOMEM;
  4198. }
  4199. }
  4200. return 0;
  4201. }
  4202. /**
  4203. * pmcraid_allocate_control_blocks - allocates memory control blocks
  4204. * @pinstance : pointer to per adapter instance structure
  4205. *
  4206. * This function allocates PCI memory for DMAable buffers like IOARCB, IOADLs
  4207. * and IOASAs. This is called after command blocks are already allocated.
  4208. *
  4209. * Return Value
  4210. * 0 in case it can allocate all control blocks, otherwise -ENOMEM
  4211. */
  4212. static int pmcraid_allocate_control_blocks(struct pmcraid_instance *pinstance)
  4213. {
  4214. int i;
  4215. sprintf(pinstance->ctl_pool_name, "pmcraid_control_pool_%d",
  4216. pinstance->host->unique_id);
  4217. pinstance->control_pool =
  4218. pci_pool_create(pinstance->ctl_pool_name,
  4219. pinstance->pdev,
  4220. sizeof(struct pmcraid_control_block),
  4221. PMCRAID_IOARCB_ALIGNMENT, 0);
  4222. if (!pinstance->control_pool)
  4223. return -ENOMEM;
  4224. for (i = 0; i < PMCRAID_MAX_CMD; i++) {
  4225. pinstance->cmd_list[i]->ioa_cb =
  4226. pci_pool_alloc(
  4227. pinstance->control_pool,
  4228. GFP_KERNEL,
  4229. &(pinstance->cmd_list[i]->ioa_cb_bus_addr));
  4230. if (!pinstance->cmd_list[i]->ioa_cb) {
  4231. pmcraid_release_control_blocks(pinstance, i);
  4232. return -ENOMEM;
  4233. }
  4234. memset(pinstance->cmd_list[i]->ioa_cb, 0,
  4235. sizeof(struct pmcraid_control_block));
  4236. }
  4237. return 0;
  4238. }
  4239. /**
  4240. * pmcraid_release_host_rrqs - release memory allocated for hrrq buffer(s)
  4241. * @pinstance: pointer to per adapter instance structure
  4242. * @maxindex: size of hrrq buffer pointer array
  4243. *
  4244. * Return Value
  4245. * None
  4246. */
  4247. static void
  4248. pmcraid_release_host_rrqs(struct pmcraid_instance *pinstance, int maxindex)
  4249. {
  4250. int i;
  4251. for (i = 0; i < maxindex; i++) {
  4252. pci_free_consistent(pinstance->pdev,
  4253. HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD,
  4254. pinstance->hrrq_start[i],
  4255. pinstance->hrrq_start_bus_addr[i]);
  4256. /* reset pointers and toggle bit to zeros */
  4257. pinstance->hrrq_start[i] = NULL;
  4258. pinstance->hrrq_start_bus_addr[i] = 0;
  4259. pinstance->host_toggle_bit[i] = 0;
  4260. }
  4261. }
  4262. /**
  4263. * pmcraid_allocate_host_rrqs - Allocate and initialize host RRQ buffers
  4264. * @pinstance: pointer to per adapter instance structure
  4265. *
  4266. * Return value
  4267. * 0 hrrq buffers are allocated, -ENOMEM otherwise.
  4268. */
  4269. static int pmcraid_allocate_host_rrqs(struct pmcraid_instance *pinstance)
  4270. {
  4271. int i, buffer_size;
  4272. buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD;
  4273. for (i = 0; i < pinstance->num_hrrq; i++) {
  4274. pinstance->hrrq_start[i] =
  4275. pci_alloc_consistent(
  4276. pinstance->pdev,
  4277. buffer_size,
  4278. &(pinstance->hrrq_start_bus_addr[i]));
  4279. if (pinstance->hrrq_start[i] == 0) {
  4280. pmcraid_err("pci_alloc failed for hrrq vector : %d\n",
  4281. i);
  4282. pmcraid_release_host_rrqs(pinstance, i);
  4283. return -ENOMEM;
  4284. }
  4285. memset(pinstance->hrrq_start[i], 0, buffer_size);
  4286. pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];
  4287. pinstance->hrrq_end[i] =
  4288. pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;
  4289. pinstance->host_toggle_bit[i] = 1;
  4290. spin_lock_init(&pinstance->hrrq_lock[i]);
  4291. }
  4292. return 0;
  4293. }
  4294. /**
  4295. * pmcraid_release_hcams - release HCAM buffers
  4296. *
  4297. * @pinstance: pointer to per adapter instance structure
  4298. *
  4299. * Return value
  4300. * none
  4301. */
  4302. static void pmcraid_release_hcams(struct pmcraid_instance *pinstance)
  4303. {
  4304. if (pinstance->ccn.msg != NULL) {
  4305. pci_free_consistent(pinstance->pdev,
  4306. PMCRAID_AEN_HDR_SIZE +
  4307. sizeof(struct pmcraid_hcam_ccn_ext),
  4308. pinstance->ccn.msg,
  4309. pinstance->ccn.baddr);
  4310. pinstance->ccn.msg = NULL;
  4311. pinstance->ccn.hcam = NULL;
  4312. pinstance->ccn.baddr = 0;
  4313. }
  4314. if (pinstance->ldn.msg != NULL) {
  4315. pci_free_consistent(pinstance->pdev,
  4316. PMCRAID_AEN_HDR_SIZE +
  4317. sizeof(struct pmcraid_hcam_ldn),
  4318. pinstance->ldn.msg,
  4319. pinstance->ldn.baddr);
  4320. pinstance->ldn.msg = NULL;
  4321. pinstance->ldn.hcam = NULL;
  4322. pinstance->ldn.baddr = 0;
  4323. }
  4324. }
  4325. /**
  4326. * pmcraid_allocate_hcams - allocates HCAM buffers
  4327. * @pinstance : pointer to per adapter instance structure
  4328. *
  4329. * Return Value:
  4330. * 0 in case of successful allocation, non-zero otherwise
  4331. */
  4332. static int pmcraid_allocate_hcams(struct pmcraid_instance *pinstance)
  4333. {
  4334. pinstance->ccn.msg = pci_alloc_consistent(
  4335. pinstance->pdev,
  4336. PMCRAID_AEN_HDR_SIZE +
  4337. sizeof(struct pmcraid_hcam_ccn_ext),
  4338. &(pinstance->ccn.baddr));
  4339. pinstance->ldn.msg = pci_alloc_consistent(
  4340. pinstance->pdev,
  4341. PMCRAID_AEN_HDR_SIZE +
  4342. sizeof(struct pmcraid_hcam_ldn),
  4343. &(pinstance->ldn.baddr));
  4344. if (pinstance->ldn.msg == NULL || pinstance->ccn.msg == NULL) {
  4345. pmcraid_release_hcams(pinstance);
  4346. } else {
  4347. pinstance->ccn.hcam =
  4348. (void *)pinstance->ccn.msg + PMCRAID_AEN_HDR_SIZE;
  4349. pinstance->ldn.hcam =
  4350. (void *)pinstance->ldn.msg + PMCRAID_AEN_HDR_SIZE;
  4351. atomic_set(&pinstance->ccn.ignore, 0);
  4352. atomic_set(&pinstance->ldn.ignore, 0);
  4353. }
  4354. return (pinstance->ldn.msg == NULL) ? -ENOMEM : 0;
  4355. }
  4356. /**
  4357. * pmcraid_release_config_buffers - release config.table buffers
  4358. * @pinstance: pointer to per adapter instance structure
  4359. *
  4360. * Return Value
  4361. * none
  4362. */
  4363. static void pmcraid_release_config_buffers(struct pmcraid_instance *pinstance)
  4364. {
  4365. if (pinstance->cfg_table != NULL &&
  4366. pinstance->cfg_table_bus_addr != 0) {
  4367. pci_free_consistent(pinstance->pdev,
  4368. sizeof(struct pmcraid_config_table),
  4369. pinstance->cfg_table,
  4370. pinstance->cfg_table_bus_addr);
  4371. pinstance->cfg_table = NULL;
  4372. pinstance->cfg_table_bus_addr = 0;
  4373. }
  4374. if (pinstance->res_entries != NULL) {
  4375. int i;
  4376. for (i = 0; i < PMCRAID_MAX_RESOURCES; i++)
  4377. list_del(&pinstance->res_entries[i].queue);
  4378. kfree(pinstance->res_entries);
  4379. pinstance->res_entries = NULL;
  4380. }
  4381. pmcraid_release_hcams(pinstance);
  4382. }
  4383. /**
  4384. * pmcraid_allocate_config_buffers - allocates DMAable memory for config table
  4385. * @pinstance : pointer to per adapter instance structure
  4386. *
  4387. * Return Value
  4388. * 0 for successful allocation, -ENOMEM for any failure
  4389. */
  4390. static int pmcraid_allocate_config_buffers(struct pmcraid_instance *pinstance)
  4391. {
  4392. int i;
  4393. pinstance->res_entries =
  4394. kzalloc(sizeof(struct pmcraid_resource_entry) *
  4395. PMCRAID_MAX_RESOURCES, GFP_KERNEL);
  4396. if (NULL == pinstance->res_entries) {
  4397. pmcraid_err("failed to allocate memory for resource table\n");
  4398. return -ENOMEM;
  4399. }
  4400. for (i = 0; i < PMCRAID_MAX_RESOURCES; i++)
  4401. list_add_tail(&pinstance->res_entries[i].queue,
  4402. &pinstance->free_res_q);
  4403. pinstance->cfg_table =
  4404. pci_alloc_consistent(pinstance->pdev,
  4405. sizeof(struct pmcraid_config_table),
  4406. &pinstance->cfg_table_bus_addr);
  4407. if (NULL == pinstance->cfg_table) {
  4408. pmcraid_err("couldn't alloc DMA memory for config table\n");
  4409. pmcraid_release_config_buffers(pinstance);
  4410. return -ENOMEM;
  4411. }
  4412. if (pmcraid_allocate_hcams(pinstance)) {
  4413. pmcraid_err("could not alloc DMA memory for HCAMS\n");
  4414. pmcraid_release_config_buffers(pinstance);
  4415. return -ENOMEM;
  4416. }
  4417. return 0;
  4418. }
  4419. /**
  4420. * pmcraid_init_tasklets - registers tasklets for response handling
  4421. *
  4422. * @pinstance: pointer adapter instance structure
  4423. *
  4424. * Return value
  4425. * none
  4426. */
  4427. static void pmcraid_init_tasklets(struct pmcraid_instance *pinstance)
  4428. {
  4429. int i;
  4430. for (i = 0; i < pinstance->num_hrrq; i++)
  4431. tasklet_init(&pinstance->isr_tasklet[i],
  4432. pmcraid_tasklet_function,
  4433. (unsigned long)&pinstance->hrrq_vector[i]);
  4434. }
  4435. /**
  4436. * pmcraid_kill_tasklets - destroys tasklets registered for response handling
  4437. *
  4438. * @pinstance: pointer to adapter instance structure
  4439. *
  4440. * Return value
  4441. * none
  4442. */
  4443. static void pmcraid_kill_tasklets(struct pmcraid_instance *pinstance)
  4444. {
  4445. int i;
  4446. for (i = 0; i < pinstance->num_hrrq; i++)
  4447. tasklet_kill(&pinstance->isr_tasklet[i]);
  4448. }
  4449. /**
  4450. * pmcraid_release_buffers - release per-adapter buffers allocated
  4451. *
  4452. * @pinstance: pointer to adapter soft state
  4453. *
  4454. * Return Value
  4455. * none
  4456. */
  4457. static void pmcraid_release_buffers(struct pmcraid_instance *pinstance)
  4458. {
  4459. pmcraid_release_config_buffers(pinstance);
  4460. pmcraid_release_control_blocks(pinstance, PMCRAID_MAX_CMD);
  4461. pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);
  4462. pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
  4463. if (pinstance->inq_data != NULL) {
  4464. pci_free_consistent(pinstance->pdev,
  4465. sizeof(struct pmcraid_inquiry_data),
  4466. pinstance->inq_data,
  4467. pinstance->inq_data_baddr);
  4468. pinstance->inq_data = NULL;
  4469. pinstance->inq_data_baddr = 0;
  4470. }
  4471. if (pinstance->timestamp_data != NULL) {
  4472. pci_free_consistent(pinstance->pdev,
  4473. sizeof(struct pmcraid_timestamp_data),
  4474. pinstance->timestamp_data,
  4475. pinstance->timestamp_data_baddr);
  4476. pinstance->timestamp_data = NULL;
  4477. pinstance->timestamp_data_baddr = 0;
  4478. }
  4479. }
  4480. /**
  4481. * pmcraid_init_buffers - allocates memory and initializes various structures
  4482. * @pinstance: pointer to per adapter instance structure
  4483. *
  4484. * This routine pre-allocates memory based on the type of block as below:
  4485. * cmdblocks(PMCRAID_MAX_CMD): kernel memory using kernel's slab_allocator,
  4486. * IOARCBs(PMCRAID_MAX_CMD) : DMAable memory, using pci pool allocator
  4487. * config-table entries : DMAable memory using pci_alloc_consistent
  4488. * HostRRQs : DMAable memory, using pci_alloc_consistent
  4489. *
  4490. * Return Value
  4491. * 0 in case all of the blocks are allocated, -ENOMEM otherwise.
  4492. */
  4493. static int pmcraid_init_buffers(struct pmcraid_instance *pinstance)
  4494. {
  4495. int i;
  4496. if (pmcraid_allocate_host_rrqs(pinstance)) {
  4497. pmcraid_err("couldn't allocate memory for %d host rrqs\n",
  4498. pinstance->num_hrrq);
  4499. return -ENOMEM;
  4500. }
  4501. if (pmcraid_allocate_config_buffers(pinstance)) {
  4502. pmcraid_err("couldn't allocate memory for config buffers\n");
  4503. pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
  4504. return -ENOMEM;
  4505. }
  4506. if (pmcraid_allocate_cmd_blocks(pinstance)) {
  4507. pmcraid_err("couldn't allocate memory for cmd blocks\n");
  4508. pmcraid_release_config_buffers(pinstance);
  4509. pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
  4510. return -ENOMEM;
  4511. }
  4512. if (pmcraid_allocate_control_blocks(pinstance)) {
  4513. pmcraid_err("couldn't allocate memory control blocks\n");
  4514. pmcraid_release_config_buffers(pinstance);
  4515. pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);
  4516. pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
  4517. return -ENOMEM;
  4518. }
  4519. /* allocate DMAable memory for page D0 INQUIRY buffer */
  4520. pinstance->inq_data = pci_alloc_consistent(
  4521. pinstance->pdev,
  4522. sizeof(struct pmcraid_inquiry_data),
  4523. &pinstance->inq_data_baddr);
  4524. if (pinstance->inq_data == NULL) {
  4525. pmcraid_err("couldn't allocate DMA memory for INQUIRY\n");
  4526. pmcraid_release_buffers(pinstance);
  4527. return -ENOMEM;
  4528. }
  4529. /* allocate DMAable memory for set timestamp data buffer */
  4530. pinstance->timestamp_data = pci_alloc_consistent(
  4531. pinstance->pdev,
  4532. sizeof(struct pmcraid_timestamp_data),
  4533. &pinstance->timestamp_data_baddr);
  4534. if (pinstance->timestamp_data == NULL) {
  4535. pmcraid_err("couldn't allocate DMA memory for \
  4536. set time_stamp \n");
  4537. pmcraid_release_buffers(pinstance);
  4538. return -ENOMEM;
  4539. }
  4540. /* Initialize all the command blocks and add them to free pool. No
  4541. * need to lock (free_pool_lock) as this is done in initialization
  4542. * itself
  4543. */
  4544. for (i = 0; i < PMCRAID_MAX_CMD; i++) {
  4545. struct pmcraid_cmd *cmdp = pinstance->cmd_list[i];
  4546. pmcraid_init_cmdblk(cmdp, i);
  4547. cmdp->drv_inst = pinstance;
  4548. list_add_tail(&cmdp->free_list, &pinstance->free_cmd_pool);
  4549. }
  4550. return 0;
  4551. }
  4552. /**
  4553. * pmcraid_reinit_buffers - resets various buffer pointers
  4554. * @pinstance: pointer to adapter instance
  4555. * Return value
  4556. * none
  4557. */
  4558. static void pmcraid_reinit_buffers(struct pmcraid_instance *pinstance)
  4559. {
  4560. int i;
  4561. int buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD;
  4562. for (i = 0; i < pinstance->num_hrrq; i++) {
  4563. memset(pinstance->hrrq_start[i], 0, buffer_size);
  4564. pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];
  4565. pinstance->hrrq_end[i] =
  4566. pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;
  4567. pinstance->host_toggle_bit[i] = 1;
  4568. }
  4569. }
  4570. /**
  4571. * pmcraid_init_instance - initialize per instance data structure
  4572. * @pdev: pointer to pci device structure
  4573. * @host: pointer to Scsi_Host structure
  4574. * @mapped_pci_addr: memory mapped IOA configuration registers
  4575. *
  4576. * Return Value
  4577. * 0 on success, non-zero in case of any failure
  4578. */
  4579. static int pmcraid_init_instance(struct pci_dev *pdev, struct Scsi_Host *host,
  4580. void __iomem *mapped_pci_addr)
  4581. {
  4582. struct pmcraid_instance *pinstance =
  4583. (struct pmcraid_instance *)host->hostdata;
  4584. pinstance->host = host;
  4585. pinstance->pdev = pdev;
  4586. /* Initialize register addresses */
  4587. pinstance->mapped_dma_addr = mapped_pci_addr;
  4588. /* Initialize chip-specific details */
  4589. {
  4590. struct pmcraid_chip_details *chip_cfg = pinstance->chip_cfg;
  4591. struct pmcraid_interrupts *pint_regs = &pinstance->int_regs;
  4592. pinstance->ioarrin = mapped_pci_addr + chip_cfg->ioarrin;
  4593. pint_regs->ioa_host_interrupt_reg =
  4594. mapped_pci_addr + chip_cfg->ioa_host_intr;
  4595. pint_regs->ioa_host_interrupt_clr_reg =
  4596. mapped_pci_addr + chip_cfg->ioa_host_intr_clr;
  4597. pint_regs->ioa_host_msix_interrupt_reg =
  4598. mapped_pci_addr + chip_cfg->ioa_host_msix_intr;
  4599. pint_regs->host_ioa_interrupt_reg =
  4600. mapped_pci_addr + chip_cfg->host_ioa_intr;
  4601. pint_regs->host_ioa_interrupt_clr_reg =
  4602. mapped_pci_addr + chip_cfg->host_ioa_intr_clr;
  4603. /* Current version of firmware exposes interrupt mask set
  4604. * and mask clr registers through memory mapped bar0.
  4605. */
  4606. pinstance->mailbox = mapped_pci_addr + chip_cfg->mailbox;
  4607. pinstance->ioa_status = mapped_pci_addr + chip_cfg->ioastatus;
  4608. pint_regs->ioa_host_interrupt_mask_reg =
  4609. mapped_pci_addr + chip_cfg->ioa_host_mask;
  4610. pint_regs->ioa_host_interrupt_mask_clr_reg =
  4611. mapped_pci_addr + chip_cfg->ioa_host_mask_clr;
  4612. pint_regs->global_interrupt_mask_reg =
  4613. mapped_pci_addr + chip_cfg->global_intr_mask;
  4614. };
  4615. pinstance->ioa_reset_attempts = 0;
  4616. init_waitqueue_head(&pinstance->reset_wait_q);
  4617. atomic_set(&pinstance->outstanding_cmds, 0);
  4618. atomic_set(&pinstance->last_message_id, 0);
  4619. atomic_set(&pinstance->expose_resources, 0);
  4620. INIT_LIST_HEAD(&pinstance->free_res_q);
  4621. INIT_LIST_HEAD(&pinstance->used_res_q);
  4622. INIT_LIST_HEAD(&pinstance->free_cmd_pool);
  4623. INIT_LIST_HEAD(&pinstance->pending_cmd_pool);
  4624. spin_lock_init(&pinstance->free_pool_lock);
  4625. spin_lock_init(&pinstance->pending_pool_lock);
  4626. spin_lock_init(&pinstance->resource_lock);
  4627. mutex_init(&pinstance->aen_queue_lock);
  4628. /* Work-queue (Shared) for deferred processing error handling */
  4629. INIT_WORK(&pinstance->worker_q, pmcraid_worker_function);
  4630. /* Initialize the default log_level */
  4631. pinstance->current_log_level = pmcraid_log_level;
  4632. /* Setup variables required for reset engine */
  4633. pinstance->ioa_state = IOA_STATE_UNKNOWN;
  4634. pinstance->reset_cmd = NULL;
  4635. return 0;
  4636. }
  4637. /**
  4638. * pmcraid_shutdown - shutdown adapter controller.
  4639. * @pdev: pci device struct
  4640. *
  4641. * Issues an adapter shutdown to the card waits for its completion
  4642. *
  4643. * Return value
  4644. * none
  4645. */
  4646. static void pmcraid_shutdown(struct pci_dev *pdev)
  4647. {
  4648. struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
  4649. pmcraid_reset_bringdown(pinstance);
  4650. }
  4651. /**
  4652. * pmcraid_get_minor - returns unused minor number from minor number bitmap
  4653. */
  4654. static unsigned short pmcraid_get_minor(void)
  4655. {
  4656. int minor;
  4657. minor = find_first_zero_bit(pmcraid_minor, sizeof(pmcraid_minor));
  4658. __set_bit(minor, pmcraid_minor);
  4659. return minor;
  4660. }
  4661. /**
  4662. * pmcraid_release_minor - releases given minor back to minor number bitmap
  4663. */
  4664. static void pmcraid_release_minor(unsigned short minor)
  4665. {
  4666. __clear_bit(minor, pmcraid_minor);
  4667. }
  4668. /**
  4669. * pmcraid_setup_chrdev - allocates a minor number and registers a char device
  4670. *
  4671. * @pinstance: pointer to adapter instance for which to register device
  4672. *
  4673. * Return value
  4674. * 0 in case of success, otherwise non-zero
  4675. */
  4676. static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance)
  4677. {
  4678. int minor;
  4679. int error;
  4680. minor = pmcraid_get_minor();
  4681. cdev_init(&pinstance->cdev, &pmcraid_fops);
  4682. pinstance->cdev.owner = THIS_MODULE;
  4683. error = cdev_add(&pinstance->cdev, MKDEV(pmcraid_major, minor), 1);
  4684. if (error)
  4685. pmcraid_release_minor(minor);
  4686. else
  4687. device_create(pmcraid_class, NULL, MKDEV(pmcraid_major, minor),
  4688. NULL, "%s%u", PMCRAID_DEVFILE, minor);
  4689. return error;
  4690. }
  4691. /**
  4692. * pmcraid_release_chrdev - unregisters per-adapter management interface
  4693. *
  4694. * @pinstance: pointer to adapter instance structure
  4695. *
  4696. * Return value
  4697. * none
  4698. */
  4699. static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance)
  4700. {
  4701. pmcraid_release_minor(MINOR(pinstance->cdev.dev));
  4702. device_destroy(pmcraid_class,
  4703. MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev)));
  4704. cdev_del(&pinstance->cdev);
  4705. }
  4706. /**
  4707. * pmcraid_remove - IOA hot plug remove entry point
  4708. * @pdev: pci device struct
  4709. *
  4710. * Return value
  4711. * none
  4712. */
  4713. static void pmcraid_remove(struct pci_dev *pdev)
  4714. {
  4715. struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
  4716. /* remove the management interface (/dev file) for this device */
  4717. pmcraid_release_chrdev(pinstance);
  4718. /* remove host template from scsi midlayer */
  4719. scsi_remove_host(pinstance->host);
  4720. /* block requests from mid-layer */
  4721. scsi_block_requests(pinstance->host);
  4722. /* initiate shutdown adapter */
  4723. pmcraid_shutdown(pdev);
  4724. pmcraid_disable_interrupts(pinstance, ~0);
  4725. flush_work(&pinstance->worker_q);
  4726. pmcraid_kill_tasklets(pinstance);
  4727. pmcraid_unregister_interrupt_handler(pinstance);
  4728. pmcraid_release_buffers(pinstance);
  4729. iounmap(pinstance->mapped_dma_addr);
  4730. pci_release_regions(pdev);
  4731. scsi_host_put(pinstance->host);
  4732. pci_disable_device(pdev);
  4733. return;
  4734. }
  4735. #ifdef CONFIG_PM
  4736. /**
  4737. * pmcraid_suspend - driver suspend entry point for power management
  4738. * @pdev: PCI device structure
  4739. * @state: PCI power state to suspend routine
  4740. *
  4741. * Return Value - 0 always
  4742. */
  4743. static int pmcraid_suspend(struct pci_dev *pdev, pm_message_t state)
  4744. {
  4745. struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
  4746. pmcraid_shutdown(pdev);
  4747. pmcraid_disable_interrupts(pinstance, ~0);
  4748. pmcraid_kill_tasklets(pinstance);
  4749. pci_set_drvdata(pinstance->pdev, pinstance);
  4750. pmcraid_unregister_interrupt_handler(pinstance);
  4751. pci_save_state(pdev);
  4752. pci_disable_device(pdev);
  4753. pci_set_power_state(pdev, pci_choose_state(pdev, state));
  4754. return 0;
  4755. }
  4756. /**
  4757. * pmcraid_resume - driver resume entry point PCI power management
  4758. * @pdev: PCI device structure
  4759. *
  4760. * Return Value - 0 in case of success. Error code in case of any failure
  4761. */
  4762. static int pmcraid_resume(struct pci_dev *pdev)
  4763. {
  4764. struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
  4765. struct Scsi_Host *host = pinstance->host;
  4766. int rc;
  4767. pci_set_power_state(pdev, PCI_D0);
  4768. pci_enable_wake(pdev, PCI_D0, 0);
  4769. pci_restore_state(pdev);
  4770. rc = pci_enable_device(pdev);
  4771. if (rc) {
  4772. dev_err(&pdev->dev, "resume: Enable device failed\n");
  4773. return rc;
  4774. }
  4775. pci_set_master(pdev);
  4776. if ((sizeof(dma_addr_t) == 4) ||
  4777. pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
  4778. rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
  4779. if (rc == 0)
  4780. rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
  4781. if (rc != 0) {
  4782. dev_err(&pdev->dev, "resume: Failed to set PCI DMA mask\n");
  4783. goto disable_device;
  4784. }
  4785. pmcraid_disable_interrupts(pinstance, ~0);
  4786. atomic_set(&pinstance->outstanding_cmds, 0);
  4787. rc = pmcraid_register_interrupt_handler(pinstance);
  4788. if (rc) {
  4789. dev_err(&pdev->dev,
  4790. "resume: couldn't register interrupt handlers\n");
  4791. rc = -ENODEV;
  4792. goto release_host;
  4793. }
  4794. pmcraid_init_tasklets(pinstance);
  4795. pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
  4796. /* Start with hard reset sequence which brings up IOA to operational
  4797. * state as well as completes the reset sequence.
  4798. */
  4799. pinstance->ioa_hard_reset = 1;
  4800. /* Start IOA firmware initialization and bring card to Operational
  4801. * state.
  4802. */
  4803. if (pmcraid_reset_bringup(pinstance)) {
  4804. dev_err(&pdev->dev, "couldn't initialize IOA\n");
  4805. rc = -ENODEV;
  4806. goto release_tasklets;
  4807. }
  4808. return 0;
  4809. release_tasklets:
  4810. pmcraid_disable_interrupts(pinstance, ~0);
  4811. pmcraid_kill_tasklets(pinstance);
  4812. pmcraid_unregister_interrupt_handler(pinstance);
  4813. release_host:
  4814. scsi_host_put(host);
  4815. disable_device:
  4816. pci_disable_device(pdev);
  4817. return rc;
  4818. }
  4819. #else
  4820. #define pmcraid_suspend NULL
  4821. #define pmcraid_resume NULL
  4822. #endif /* CONFIG_PM */
  4823. /**
  4824. * pmcraid_complete_ioa_reset - Called by either timer or tasklet during
  4825. * completion of the ioa reset
  4826. * @cmd: pointer to reset command block
  4827. */
  4828. static void pmcraid_complete_ioa_reset(struct pmcraid_cmd *cmd)
  4829. {
  4830. struct pmcraid_instance *pinstance = cmd->drv_inst;
  4831. unsigned long flags;
  4832. spin_lock_irqsave(pinstance->host->host_lock, flags);
  4833. pmcraid_ioa_reset(cmd);
  4834. spin_unlock_irqrestore(pinstance->host->host_lock, flags);
  4835. scsi_unblock_requests(pinstance->host);
  4836. schedule_work(&pinstance->worker_q);
  4837. }
  4838. /**
  4839. * pmcraid_set_supported_devs - sends SET SUPPORTED DEVICES to IOAFP
  4840. *
  4841. * @cmd: pointer to pmcraid_cmd structure
  4842. *
  4843. * Return Value
  4844. * 0 for success or non-zero for failure cases
  4845. */
  4846. static void pmcraid_set_supported_devs(struct pmcraid_cmd *cmd)
  4847. {
  4848. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  4849. void (*cmd_done) (struct pmcraid_cmd *) = pmcraid_complete_ioa_reset;
  4850. pmcraid_reinit_cmdblk(cmd);
  4851. ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
  4852. ioarcb->request_type = REQ_TYPE_IOACMD;
  4853. ioarcb->cdb[0] = PMCRAID_SET_SUPPORTED_DEVICES;
  4854. ioarcb->cdb[1] = ALL_DEVICES_SUPPORTED;
  4855. /* If this was called as part of resource table reinitialization due to
  4856. * lost CCN, it is enough to return the command block back to free pool
  4857. * as part of set_supported_devs completion function.
  4858. */
  4859. if (cmd->drv_inst->reinit_cfg_table) {
  4860. cmd->drv_inst->reinit_cfg_table = 0;
  4861. cmd->release = 1;
  4862. cmd_done = pmcraid_reinit_cfgtable_done;
  4863. }
  4864. /* we will be done with the reset sequence after set supported devices,
  4865. * setup the done function to return the command block back to free
  4866. * pool
  4867. */
  4868. pmcraid_send_cmd(cmd,
  4869. cmd_done,
  4870. PMCRAID_SET_SUP_DEV_TIMEOUT,
  4871. pmcraid_timeout_handler);
  4872. return;
  4873. }
  4874. /**
  4875. * pmcraid_set_timestamp - set the timestamp to IOAFP
  4876. *
  4877. * @cmd: pointer to pmcraid_cmd structure
  4878. *
  4879. * Return Value
  4880. * 0 for success or non-zero for failure cases
  4881. */
  4882. static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd)
  4883. {
  4884. struct pmcraid_instance *pinstance = cmd->drv_inst;
  4885. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  4886. __be32 time_stamp_len = cpu_to_be32(PMCRAID_TIMESTAMP_LEN);
  4887. struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
  4888. struct timeval tv;
  4889. __le64 timestamp;
  4890. do_gettimeofday(&tv);
  4891. timestamp = tv.tv_sec * 1000;
  4892. pinstance->timestamp_data->timestamp[0] = (__u8)(timestamp);
  4893. pinstance->timestamp_data->timestamp[1] = (__u8)((timestamp) >> 8);
  4894. pinstance->timestamp_data->timestamp[2] = (__u8)((timestamp) >> 16);
  4895. pinstance->timestamp_data->timestamp[3] = (__u8)((timestamp) >> 24);
  4896. pinstance->timestamp_data->timestamp[4] = (__u8)((timestamp) >> 32);
  4897. pinstance->timestamp_data->timestamp[5] = (__u8)((timestamp) >> 40);
  4898. pmcraid_reinit_cmdblk(cmd);
  4899. ioarcb->request_type = REQ_TYPE_SCSI;
  4900. ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
  4901. ioarcb->cdb[0] = PMCRAID_SCSI_SET_TIMESTAMP;
  4902. ioarcb->cdb[1] = PMCRAID_SCSI_SERVICE_ACTION;
  4903. memcpy(&(ioarcb->cdb[6]), &time_stamp_len, sizeof(time_stamp_len));
  4904. ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
  4905. offsetof(struct pmcraid_ioarcb,
  4906. add_data.u.ioadl[0]));
  4907. ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
  4908. ioarcb->ioarcb_bus_addr &= ~(0x1FULL);
  4909. ioarcb->request_flags0 |= NO_LINK_DESCS;
  4910. ioarcb->request_flags0 |= TRANSFER_DIR_WRITE;
  4911. ioarcb->data_transfer_length =
  4912. cpu_to_le32(sizeof(struct pmcraid_timestamp_data));
  4913. ioadl = &(ioarcb->add_data.u.ioadl[0]);
  4914. ioadl->flags = IOADL_FLAGS_LAST_DESC;
  4915. ioadl->address = cpu_to_le64(pinstance->timestamp_data_baddr);
  4916. ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_timestamp_data));
  4917. if (!pinstance->timestamp_error) {
  4918. pinstance->timestamp_error = 0;
  4919. pmcraid_send_cmd(cmd, pmcraid_set_supported_devs,
  4920. PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
  4921. } else {
  4922. pmcraid_send_cmd(cmd, pmcraid_return_cmd,
  4923. PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
  4924. return;
  4925. }
  4926. }
  4927. /**
  4928. * pmcraid_init_res_table - Initialize the resource table
  4929. * @cmd: pointer to pmcraid command struct
  4930. *
  4931. * This function looks through the existing resource table, comparing
  4932. * it with the config table. This function will take care of old/new
  4933. * devices and schedule adding/removing them from the mid-layer
  4934. * as appropriate.
  4935. *
  4936. * Return value
  4937. * None
  4938. */
  4939. static void pmcraid_init_res_table(struct pmcraid_cmd *cmd)
  4940. {
  4941. struct pmcraid_instance *pinstance = cmd->drv_inst;
  4942. struct pmcraid_resource_entry *res, *temp;
  4943. struct pmcraid_config_table_entry *cfgte;
  4944. unsigned long lock_flags;
  4945. int found, rc, i;
  4946. u16 fw_version;
  4947. LIST_HEAD(old_res);
  4948. if (pinstance->cfg_table->flags & MICROCODE_UPDATE_REQUIRED)
  4949. pmcraid_err("IOA requires microcode download\n");
  4950. fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
  4951. /* resource list is protected by pinstance->resource_lock.
  4952. * init_res_table can be called from probe (user-thread) or runtime
  4953. * reset (timer/tasklet)
  4954. */
  4955. spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
  4956. list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue)
  4957. list_move_tail(&res->queue, &old_res);
  4958. for (i = 0; i < pinstance->cfg_table->num_entries; i++) {
  4959. if (be16_to_cpu(pinstance->inq_data->fw_version) <=
  4960. PMCRAID_FW_VERSION_1)
  4961. cfgte = &pinstance->cfg_table->entries[i];
  4962. else
  4963. cfgte = (struct pmcraid_config_table_entry *)
  4964. &pinstance->cfg_table->entries_ext[i];
  4965. if (!pmcraid_expose_resource(fw_version, cfgte))
  4966. continue;
  4967. found = 0;
  4968. /* If this entry was already detected and initialized */
  4969. list_for_each_entry_safe(res, temp, &old_res, queue) {
  4970. rc = memcmp(&res->cfg_entry.resource_address,
  4971. &cfgte->resource_address,
  4972. sizeof(cfgte->resource_address));
  4973. if (!rc) {
  4974. list_move_tail(&res->queue,
  4975. &pinstance->used_res_q);
  4976. found = 1;
  4977. break;
  4978. }
  4979. }
  4980. /* If this is new entry, initialize it and add it the queue */
  4981. if (!found) {
  4982. if (list_empty(&pinstance->free_res_q)) {
  4983. pmcraid_err("Too many devices attached\n");
  4984. break;
  4985. }
  4986. found = 1;
  4987. res = list_entry(pinstance->free_res_q.next,
  4988. struct pmcraid_resource_entry, queue);
  4989. res->scsi_dev = NULL;
  4990. res->change_detected = RES_CHANGE_ADD;
  4991. res->reset_progress = 0;
  4992. list_move_tail(&res->queue, &pinstance->used_res_q);
  4993. }
  4994. /* copy new configuration table entry details into driver
  4995. * maintained resource entry
  4996. */
  4997. if (found) {
  4998. memcpy(&res->cfg_entry, cfgte,
  4999. pinstance->config_table_entry_size);
  5000. pmcraid_info("New res type:%x, vset:%x, addr:%x:\n",
  5001. res->cfg_entry.resource_type,
  5002. (fw_version <= PMCRAID_FW_VERSION_1 ?
  5003. res->cfg_entry.unique_flags1 :
  5004. res->cfg_entry.array_id & 0xFF),
  5005. le32_to_cpu(res->cfg_entry.resource_address));
  5006. }
  5007. }
  5008. /* Detect any deleted entries, mark them for deletion from mid-layer */
  5009. list_for_each_entry_safe(res, temp, &old_res, queue) {
  5010. if (res->scsi_dev) {
  5011. res->change_detected = RES_CHANGE_DEL;
  5012. res->cfg_entry.resource_handle =
  5013. PMCRAID_INVALID_RES_HANDLE;
  5014. list_move_tail(&res->queue, &pinstance->used_res_q);
  5015. } else {
  5016. list_move_tail(&res->queue, &pinstance->free_res_q);
  5017. }
  5018. }
  5019. /* release the resource list lock */
  5020. spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
  5021. pmcraid_set_timestamp(cmd);
  5022. }
  5023. /**
  5024. * pmcraid_querycfg - Send a Query IOA Config to the adapter.
  5025. * @cmd: pointer pmcraid_cmd struct
  5026. *
  5027. * This function sends a Query IOA Configuration command to the adapter to
  5028. * retrieve the IOA configuration table.
  5029. *
  5030. * Return value:
  5031. * none
  5032. */
  5033. static void pmcraid_querycfg(struct pmcraid_cmd *cmd)
  5034. {
  5035. struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
  5036. struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
  5037. struct pmcraid_instance *pinstance = cmd->drv_inst;
  5038. int cfg_table_size = cpu_to_be32(sizeof(struct pmcraid_config_table));
  5039. if (be16_to_cpu(pinstance->inq_data->fw_version) <=
  5040. PMCRAID_FW_VERSION_1)
  5041. pinstance->config_table_entry_size =
  5042. sizeof(struct pmcraid_config_table_entry);
  5043. else
  5044. pinstance->config_table_entry_size =
  5045. sizeof(struct pmcraid_config_table_entry_ext);
  5046. ioarcb->request_type = REQ_TYPE_IOACMD;
  5047. ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
  5048. ioarcb->cdb[0] = PMCRAID_QUERY_IOA_CONFIG;
  5049. /* firmware requires 4-byte length field, specified in B.E format */
  5050. memcpy(&(ioarcb->cdb[10]), &cfg_table_size, sizeof(cfg_table_size));
  5051. /* Since entire config table can be described by single IOADL, it can
  5052. * be part of IOARCB itself
  5053. */
  5054. ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
  5055. offsetof(struct pmcraid_ioarcb,
  5056. add_data.u.ioadl[0]));
  5057. ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
  5058. ioarcb->ioarcb_bus_addr &= ~(0x1FULL);
  5059. ioarcb->request_flags0 |= NO_LINK_DESCS;
  5060. ioarcb->data_transfer_length =
  5061. cpu_to_le32(sizeof(struct pmcraid_config_table));
  5062. ioadl = &(ioarcb->add_data.u.ioadl[0]);
  5063. ioadl->flags = IOADL_FLAGS_LAST_DESC;
  5064. ioadl->address = cpu_to_le64(pinstance->cfg_table_bus_addr);
  5065. ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_config_table));
  5066. pmcraid_send_cmd(cmd, pmcraid_init_res_table,
  5067. PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
  5068. }
  5069. /**
  5070. * pmcraid_probe - PCI probe entry pointer for PMC MaxRAID controller driver
  5071. * @pdev: pointer to pci device structure
  5072. * @dev_id: pointer to device ids structure
  5073. *
  5074. * Return Value
  5075. * returns 0 if the device is claimed and successfully configured.
  5076. * returns non-zero error code in case of any failure
  5077. */
  5078. static int pmcraid_probe(struct pci_dev *pdev,
  5079. const struct pci_device_id *dev_id)
  5080. {
  5081. struct pmcraid_instance *pinstance;
  5082. struct Scsi_Host *host;
  5083. void __iomem *mapped_pci_addr;
  5084. int rc = PCIBIOS_SUCCESSFUL;
  5085. if (atomic_read(&pmcraid_adapter_count) >= PMCRAID_MAX_ADAPTERS) {
  5086. pmcraid_err
  5087. ("maximum number(%d) of supported adapters reached\n",
  5088. atomic_read(&pmcraid_adapter_count));
  5089. return -ENOMEM;
  5090. }
  5091. atomic_inc(&pmcraid_adapter_count);
  5092. rc = pci_enable_device(pdev);
  5093. if (rc) {
  5094. dev_err(&pdev->dev, "Cannot enable adapter\n");
  5095. atomic_dec(&pmcraid_adapter_count);
  5096. return rc;
  5097. }
  5098. dev_info(&pdev->dev,
  5099. "Found new IOA(%x:%x), Total IOA count: %d\n",
  5100. pdev->vendor, pdev->device,
  5101. atomic_read(&pmcraid_adapter_count));
  5102. rc = pci_request_regions(pdev, PMCRAID_DRIVER_NAME);
  5103. if (rc < 0) {
  5104. dev_err(&pdev->dev,
  5105. "Couldn't register memory range of registers\n");
  5106. goto out_disable_device;
  5107. }
  5108. mapped_pci_addr = pci_iomap(pdev, 0, 0);
  5109. if (!mapped_pci_addr) {
  5110. dev_err(&pdev->dev, "Couldn't map PCI registers memory\n");
  5111. rc = -ENOMEM;
  5112. goto out_release_regions;
  5113. }
  5114. pci_set_master(pdev);
  5115. /* Firmware requires the system bus address of IOARCB to be within
  5116. * 32-bit addressable range though it has 64-bit IOARRIN register.
  5117. * However, firmware supports 64-bit streaming DMA buffers, whereas
  5118. * coherent buffers are to be 32-bit. Since pci_alloc_consistent always
  5119. * returns memory within 4GB (if not, change this logic), coherent
  5120. * buffers are within firmware acceptable address ranges.
  5121. */
  5122. if ((sizeof(dma_addr_t) == 4) ||
  5123. pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
  5124. rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
  5125. /* firmware expects 32-bit DMA addresses for IOARRIN register; set 32
  5126. * bit mask for pci_alloc_consistent to return addresses within 4GB
  5127. */
  5128. if (rc == 0)
  5129. rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
  5130. if (rc != 0) {
  5131. dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
  5132. goto cleanup_nomem;
  5133. }
  5134. host = scsi_host_alloc(&pmcraid_host_template,
  5135. sizeof(struct pmcraid_instance));
  5136. if (!host) {
  5137. dev_err(&pdev->dev, "scsi_host_alloc failed!\n");
  5138. rc = -ENOMEM;
  5139. goto cleanup_nomem;
  5140. }
  5141. host->max_id = PMCRAID_MAX_NUM_TARGETS_PER_BUS;
  5142. host->max_lun = PMCRAID_MAX_NUM_LUNS_PER_TARGET;
  5143. host->unique_id = host->host_no;
  5144. host->max_channel = PMCRAID_MAX_BUS_TO_SCAN;
  5145. host->max_cmd_len = PMCRAID_MAX_CDB_LEN;
  5146. /* zero out entire instance structure */
  5147. pinstance = (struct pmcraid_instance *)host->hostdata;
  5148. memset(pinstance, 0, sizeof(*pinstance));
  5149. pinstance->chip_cfg =
  5150. (struct pmcraid_chip_details *)(dev_id->driver_data);
  5151. rc = pmcraid_init_instance(pdev, host, mapped_pci_addr);
  5152. if (rc < 0) {
  5153. dev_err(&pdev->dev, "failed to initialize adapter instance\n");
  5154. goto out_scsi_host_put;
  5155. }
  5156. pci_set_drvdata(pdev, pinstance);
  5157. /* Save PCI config-space for use following the reset */
  5158. rc = pci_save_state(pinstance->pdev);
  5159. if (rc != 0) {
  5160. dev_err(&pdev->dev, "Failed to save PCI config space\n");
  5161. goto out_scsi_host_put;
  5162. }
  5163. pmcraid_disable_interrupts(pinstance, ~0);
  5164. rc = pmcraid_register_interrupt_handler(pinstance);
  5165. if (rc) {
  5166. dev_err(&pdev->dev, "couldn't register interrupt handler\n");
  5167. goto out_scsi_host_put;
  5168. }
  5169. pmcraid_init_tasklets(pinstance);
  5170. /* allocate verious buffers used by LLD.*/
  5171. rc = pmcraid_init_buffers(pinstance);
  5172. if (rc) {
  5173. pmcraid_err("couldn't allocate memory blocks\n");
  5174. goto out_unregister_isr;
  5175. }
  5176. /* check the reset type required */
  5177. pmcraid_reset_type(pinstance);
  5178. pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
  5179. /* Start IOA firmware initialization and bring card to Operational
  5180. * state.
  5181. */
  5182. pmcraid_info("starting IOA initialization sequence\n");
  5183. if (pmcraid_reset_bringup(pinstance)) {
  5184. dev_err(&pdev->dev, "couldn't initialize IOA\n");
  5185. rc = 1;
  5186. goto out_release_bufs;
  5187. }
  5188. /* Add adapter instance into mid-layer list */
  5189. rc = scsi_add_host(pinstance->host, &pdev->dev);
  5190. if (rc != 0) {
  5191. pmcraid_err("couldn't add host into mid-layer: %d\n", rc);
  5192. goto out_release_bufs;
  5193. }
  5194. scsi_scan_host(pinstance->host);
  5195. rc = pmcraid_setup_chrdev(pinstance);
  5196. if (rc != 0) {
  5197. pmcraid_err("couldn't create mgmt interface, error: %x\n",
  5198. rc);
  5199. goto out_remove_host;
  5200. }
  5201. /* Schedule worker thread to handle CCN and take care of adding and
  5202. * removing devices to OS
  5203. */
  5204. atomic_set(&pinstance->expose_resources, 1);
  5205. schedule_work(&pinstance->worker_q);
  5206. return rc;
  5207. out_remove_host:
  5208. scsi_remove_host(host);
  5209. out_release_bufs:
  5210. pmcraid_release_buffers(pinstance);
  5211. out_unregister_isr:
  5212. pmcraid_kill_tasklets(pinstance);
  5213. pmcraid_unregister_interrupt_handler(pinstance);
  5214. out_scsi_host_put:
  5215. scsi_host_put(host);
  5216. cleanup_nomem:
  5217. iounmap(mapped_pci_addr);
  5218. out_release_regions:
  5219. pci_release_regions(pdev);
  5220. out_disable_device:
  5221. atomic_dec(&pmcraid_adapter_count);
  5222. pci_disable_device(pdev);
  5223. return -ENODEV;
  5224. }
  5225. /*
  5226. * PCI driver structure of pcmraid driver
  5227. */
  5228. static struct pci_driver pmcraid_driver = {
  5229. .name = PMCRAID_DRIVER_NAME,
  5230. .id_table = pmcraid_pci_table,
  5231. .probe = pmcraid_probe,
  5232. .remove = pmcraid_remove,
  5233. .suspend = pmcraid_suspend,
  5234. .resume = pmcraid_resume,
  5235. .shutdown = pmcraid_shutdown
  5236. };
  5237. /**
  5238. * pmcraid_init - module load entry point
  5239. */
  5240. static int __init pmcraid_init(void)
  5241. {
  5242. dev_t dev;
  5243. int error;
  5244. pmcraid_info("%s Device Driver version: %s\n",
  5245. PMCRAID_DRIVER_NAME, PMCRAID_DRIVER_VERSION);
  5246. error = alloc_chrdev_region(&dev, 0,
  5247. PMCRAID_MAX_ADAPTERS,
  5248. PMCRAID_DEVFILE);
  5249. if (error) {
  5250. pmcraid_err("failed to get a major number for adapters\n");
  5251. goto out_init;
  5252. }
  5253. pmcraid_major = MAJOR(dev);
  5254. pmcraid_class = class_create(THIS_MODULE, PMCRAID_DEVFILE);
  5255. if (IS_ERR(pmcraid_class)) {
  5256. error = PTR_ERR(pmcraid_class);
  5257. pmcraid_err("failed to register with sysfs, error = %x\n",
  5258. error);
  5259. goto out_unreg_chrdev;
  5260. }
  5261. error = pmcraid_netlink_init();
  5262. if (error)
  5263. goto out_unreg_chrdev;
  5264. error = pci_register_driver(&pmcraid_driver);
  5265. if (error == 0)
  5266. goto out_init;
  5267. pmcraid_err("failed to register pmcraid driver, error = %x\n",
  5268. error);
  5269. class_destroy(pmcraid_class);
  5270. pmcraid_netlink_release();
  5271. out_unreg_chrdev:
  5272. unregister_chrdev_region(MKDEV(pmcraid_major, 0), PMCRAID_MAX_ADAPTERS);
  5273. out_init:
  5274. return error;
  5275. }
  5276. /**
  5277. * pmcraid_exit - module unload entry point
  5278. */
  5279. static void __exit pmcraid_exit(void)
  5280. {
  5281. pmcraid_netlink_release();
  5282. unregister_chrdev_region(MKDEV(pmcraid_major, 0),
  5283. PMCRAID_MAX_ADAPTERS);
  5284. pci_unregister_driver(&pmcraid_driver);
  5285. class_destroy(pmcraid_class);
  5286. }
  5287. module_init(pmcraid_init);
  5288. module_exit(pmcraid_exit);