bfa_fcs_lport.c 141 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706570757085709571057115712
  1. /*
  2. * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
  3. * All rights reserved
  4. * www.brocade.com
  5. *
  6. * Linux driver for Brocade Fibre Channel Host Bus Adapter.
  7. *
  8. * This program is free software; you can redistribute it and/or modify it
  9. * under the terms of the GNU General Public License (GPL) Version 2 as
  10. * published by the Free Software Foundation
  11. *
  12. * This program is distributed in the hope that it will be useful, but
  13. * WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15. * General Public License for more details.
  16. */
  17. #include "bfad_drv.h"
  18. #include "bfa_fcs.h"
  19. #include "bfa_fcbuild.h"
  20. #include "bfa_fc.h"
  21. BFA_TRC_FILE(FCS, PORT);
  22. static void bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port,
  23. struct fchs_s *rx_fchs, u8 reason_code,
  24. u8 reason_code_expl);
  25. static void bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port,
  26. struct fchs_s *rx_fchs, struct fc_logi_s *plogi);
  27. static void bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port);
  28. static void bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port);
  29. static void bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s *port);
  30. static void bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s *port);
  31. static void bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s *port);
  32. static void bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port);
  33. static void bfa_fcs_lport_echo(struct bfa_fcs_lport_s *port,
  34. struct fchs_s *rx_fchs,
  35. struct fc_echo_s *echo, u16 len);
  36. static void bfa_fcs_lport_rnid(struct bfa_fcs_lport_s *port,
  37. struct fchs_s *rx_fchs,
  38. struct fc_rnid_cmd_s *rnid, u16 len);
  39. static void bfa_fs_port_get_gen_topo_data(struct bfa_fcs_lport_s *port,
  40. struct fc_rnid_general_topology_data_s *gen_topo_data);
  41. static void bfa_fcs_lport_fab_init(struct bfa_fcs_lport_s *port);
  42. static void bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s *port);
  43. static void bfa_fcs_lport_fab_offline(struct bfa_fcs_lport_s *port);
  44. static void bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s *port);
  45. static void bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port);
  46. static void bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port);
  47. static struct {
  48. void (*init) (struct bfa_fcs_lport_s *port);
  49. void (*online) (struct bfa_fcs_lport_s *port);
  50. void (*offline) (struct bfa_fcs_lport_s *port);
  51. } __port_action[] = {
  52. {
  53. bfa_fcs_lport_unknown_init, bfa_fcs_lport_unknown_online,
  54. bfa_fcs_lport_unknown_offline}, {
  55. bfa_fcs_lport_fab_init, bfa_fcs_lport_fab_online,
  56. bfa_fcs_lport_fab_offline}, {
  57. bfa_fcs_lport_n2n_init, bfa_fcs_lport_n2n_online,
  58. bfa_fcs_lport_n2n_offline},
  59. };
  60. /*
  61. * fcs_port_sm FCS logical port state machine
  62. */
  63. enum bfa_fcs_lport_event {
  64. BFA_FCS_PORT_SM_CREATE = 1,
  65. BFA_FCS_PORT_SM_ONLINE = 2,
  66. BFA_FCS_PORT_SM_OFFLINE = 3,
  67. BFA_FCS_PORT_SM_DELETE = 4,
  68. BFA_FCS_PORT_SM_DELRPORT = 5,
  69. };
  70. static void bfa_fcs_lport_sm_uninit(struct bfa_fcs_lport_s *port,
  71. enum bfa_fcs_lport_event event);
  72. static void bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s *port,
  73. enum bfa_fcs_lport_event event);
  74. static void bfa_fcs_lport_sm_online(struct bfa_fcs_lport_s *port,
  75. enum bfa_fcs_lport_event event);
  76. static void bfa_fcs_lport_sm_offline(struct bfa_fcs_lport_s *port,
  77. enum bfa_fcs_lport_event event);
  78. static void bfa_fcs_lport_sm_deleting(struct bfa_fcs_lport_s *port,
  79. enum bfa_fcs_lport_event event);
  80. static void
  81. bfa_fcs_lport_sm_uninit(
  82. struct bfa_fcs_lport_s *port,
  83. enum bfa_fcs_lport_event event)
  84. {
  85. bfa_trc(port->fcs, port->port_cfg.pwwn);
  86. bfa_trc(port->fcs, event);
  87. switch (event) {
  88. case BFA_FCS_PORT_SM_CREATE:
  89. bfa_sm_set_state(port, bfa_fcs_lport_sm_init);
  90. break;
  91. default:
  92. bfa_sm_fault(port->fcs, event);
  93. }
  94. }
  95. static void
  96. bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s *port,
  97. enum bfa_fcs_lport_event event)
  98. {
  99. bfa_trc(port->fcs, port->port_cfg.pwwn);
  100. bfa_trc(port->fcs, event);
  101. switch (event) {
  102. case BFA_FCS_PORT_SM_ONLINE:
  103. bfa_sm_set_state(port, bfa_fcs_lport_sm_online);
  104. bfa_fcs_lport_online_actions(port);
  105. break;
  106. case BFA_FCS_PORT_SM_DELETE:
  107. bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit);
  108. bfa_fcs_lport_deleted(port);
  109. break;
  110. case BFA_FCS_PORT_SM_OFFLINE:
  111. break;
  112. default:
  113. bfa_sm_fault(port->fcs, event);
  114. }
  115. }
  116. static void
  117. bfa_fcs_lport_sm_online(
  118. struct bfa_fcs_lport_s *port,
  119. enum bfa_fcs_lport_event event)
  120. {
  121. struct bfa_fcs_rport_s *rport;
  122. struct list_head *qe, *qen;
  123. bfa_trc(port->fcs, port->port_cfg.pwwn);
  124. bfa_trc(port->fcs, event);
  125. switch (event) {
  126. case BFA_FCS_PORT_SM_OFFLINE:
  127. bfa_sm_set_state(port, bfa_fcs_lport_sm_offline);
  128. bfa_fcs_lport_offline_actions(port);
  129. break;
  130. case BFA_FCS_PORT_SM_DELETE:
  131. __port_action[port->fabric->fab_type].offline(port);
  132. if (port->num_rports == 0) {
  133. bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit);
  134. bfa_fcs_lport_deleted(port);
  135. } else {
  136. bfa_sm_set_state(port, bfa_fcs_lport_sm_deleting);
  137. list_for_each_safe(qe, qen, &port->rport_q) {
  138. rport = (struct bfa_fcs_rport_s *) qe;
  139. bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
  140. }
  141. }
  142. break;
  143. case BFA_FCS_PORT_SM_DELRPORT:
  144. break;
  145. default:
  146. bfa_sm_fault(port->fcs, event);
  147. }
  148. }
  149. static void
  150. bfa_fcs_lport_sm_offline(
  151. struct bfa_fcs_lport_s *port,
  152. enum bfa_fcs_lport_event event)
  153. {
  154. struct bfa_fcs_rport_s *rport;
  155. struct list_head *qe, *qen;
  156. bfa_trc(port->fcs, port->port_cfg.pwwn);
  157. bfa_trc(port->fcs, event);
  158. switch (event) {
  159. case BFA_FCS_PORT_SM_ONLINE:
  160. bfa_sm_set_state(port, bfa_fcs_lport_sm_online);
  161. bfa_fcs_lport_online_actions(port);
  162. break;
  163. case BFA_FCS_PORT_SM_DELETE:
  164. if (port->num_rports == 0) {
  165. bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit);
  166. bfa_fcs_lport_deleted(port);
  167. } else {
  168. bfa_sm_set_state(port, bfa_fcs_lport_sm_deleting);
  169. list_for_each_safe(qe, qen, &port->rport_q) {
  170. rport = (struct bfa_fcs_rport_s *) qe;
  171. bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
  172. }
  173. }
  174. break;
  175. case BFA_FCS_PORT_SM_DELRPORT:
  176. case BFA_FCS_PORT_SM_OFFLINE:
  177. break;
  178. default:
  179. bfa_sm_fault(port->fcs, event);
  180. }
  181. }
  182. static void
  183. bfa_fcs_lport_sm_deleting(
  184. struct bfa_fcs_lport_s *port,
  185. enum bfa_fcs_lport_event event)
  186. {
  187. bfa_trc(port->fcs, port->port_cfg.pwwn);
  188. bfa_trc(port->fcs, event);
  189. switch (event) {
  190. case BFA_FCS_PORT_SM_DELRPORT:
  191. if (port->num_rports == 0) {
  192. bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit);
  193. bfa_fcs_lport_deleted(port);
  194. }
  195. break;
  196. default:
  197. bfa_sm_fault(port->fcs, event);
  198. }
  199. }
  200. /*
  201. * fcs_port_pvt
  202. */
  203. /*
  204. * Send a LS reject
  205. */
  206. static void
  207. bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
  208. u8 reason_code, u8 reason_code_expl)
  209. {
  210. struct fchs_s fchs;
  211. struct bfa_fcxp_s *fcxp;
  212. struct bfa_rport_s *bfa_rport = NULL;
  213. int len;
  214. bfa_trc(port->fcs, rx_fchs->d_id);
  215. bfa_trc(port->fcs, rx_fchs->s_id);
  216. fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  217. if (!fcxp)
  218. return;
  219. len = fc_ls_rjt_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  220. rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
  221. rx_fchs->ox_id, reason_code, reason_code_expl);
  222. bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag,
  223. BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL,
  224. FC_MAX_PDUSZ, 0);
  225. }
  226. /*
  227. * Process incoming plogi from a remote port.
  228. */
  229. static void
  230. bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port,
  231. struct fchs_s *rx_fchs, struct fc_logi_s *plogi)
  232. {
  233. struct bfa_fcs_rport_s *rport;
  234. bfa_trc(port->fcs, rx_fchs->d_id);
  235. bfa_trc(port->fcs, rx_fchs->s_id);
  236. /*
  237. * If min cfg mode is enabled, drop any incoming PLOGIs
  238. */
  239. if (__fcs_min_cfg(port->fcs)) {
  240. bfa_trc(port->fcs, rx_fchs->s_id);
  241. return;
  242. }
  243. if (fc_plogi_parse(rx_fchs) != FC_PARSE_OK) {
  244. bfa_trc(port->fcs, rx_fchs->s_id);
  245. /*
  246. * send a LS reject
  247. */
  248. bfa_fcs_lport_send_ls_rjt(port, rx_fchs,
  249. FC_LS_RJT_RSN_PROTOCOL_ERROR,
  250. FC_LS_RJT_EXP_SPARMS_ERR_OPTIONS);
  251. return;
  252. }
  253. /*
  254. * Direct Attach P2P mode : verify address assigned by the r-port.
  255. */
  256. if ((!bfa_fcs_fabric_is_switched(port->fabric)) &&
  257. (memcmp((void *)&bfa_fcs_lport_get_pwwn(port),
  258. (void *)&plogi->port_name, sizeof(wwn_t)) < 0)) {
  259. if (BFA_FCS_PID_IS_WKA(rx_fchs->d_id)) {
  260. /* Address assigned to us cannot be a WKA */
  261. bfa_fcs_lport_send_ls_rjt(port, rx_fchs,
  262. FC_LS_RJT_RSN_PROTOCOL_ERROR,
  263. FC_LS_RJT_EXP_INVALID_NPORT_ID);
  264. return;
  265. }
  266. port->pid = rx_fchs->d_id;
  267. bfa_lps_set_n2n_pid(port->fabric->lps, rx_fchs->d_id);
  268. }
  269. /*
  270. * First, check if we know the device by pwwn.
  271. */
  272. rport = bfa_fcs_lport_get_rport_by_pwwn(port, plogi->port_name);
  273. if (rport) {
  274. /*
  275. * Direct Attach P2P mode : handle address assigned by r-port.
  276. */
  277. if ((!bfa_fcs_fabric_is_switched(port->fabric)) &&
  278. (memcmp((void *)&bfa_fcs_lport_get_pwwn(port),
  279. (void *)&plogi->port_name, sizeof(wwn_t)) < 0)) {
  280. port->pid = rx_fchs->d_id;
  281. bfa_lps_set_n2n_pid(port->fabric->lps, rx_fchs->d_id);
  282. rport->pid = rx_fchs->s_id;
  283. }
  284. bfa_fcs_rport_plogi(rport, rx_fchs, plogi);
  285. return;
  286. }
  287. /*
  288. * Next, lookup rport by PID.
  289. */
  290. rport = bfa_fcs_lport_get_rport_by_pid(port, rx_fchs->s_id);
  291. if (!rport) {
  292. /*
  293. * Inbound PLOGI from a new device.
  294. */
  295. bfa_fcs_rport_plogi_create(port, rx_fchs, plogi);
  296. return;
  297. }
  298. /*
  299. * Rport is known only by PID.
  300. */
  301. if (rport->pwwn) {
  302. /*
  303. * This is a different device with the same pid. Old device
  304. * disappeared. Send implicit LOGO to old device.
  305. */
  306. WARN_ON(rport->pwwn == plogi->port_name);
  307. bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP);
  308. /*
  309. * Inbound PLOGI from a new device (with old PID).
  310. */
  311. bfa_fcs_rport_plogi_create(port, rx_fchs, plogi);
  312. return;
  313. }
  314. /*
  315. * PLOGI crossing each other.
  316. */
  317. WARN_ON(rport->pwwn != WWN_NULL);
  318. bfa_fcs_rport_plogi(rport, rx_fchs, plogi);
  319. }
  320. /*
  321. * Process incoming ECHO.
  322. * Since it does not require a login, it is processed here.
  323. */
  324. static void
  325. bfa_fcs_lport_echo(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
  326. struct fc_echo_s *echo, u16 rx_len)
  327. {
  328. struct fchs_s fchs;
  329. struct bfa_fcxp_s *fcxp;
  330. struct bfa_rport_s *bfa_rport = NULL;
  331. int len, pyld_len;
  332. bfa_trc(port->fcs, rx_fchs->s_id);
  333. bfa_trc(port->fcs, rx_fchs->d_id);
  334. fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  335. if (!fcxp)
  336. return;
  337. len = fc_ls_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  338. rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
  339. rx_fchs->ox_id);
  340. /*
  341. * Copy the payload (if any) from the echo frame
  342. */
  343. pyld_len = rx_len - sizeof(struct fchs_s);
  344. bfa_trc(port->fcs, rx_len);
  345. bfa_trc(port->fcs, pyld_len);
  346. if (pyld_len > len)
  347. memcpy(((u8 *) bfa_fcxp_get_reqbuf(fcxp)) +
  348. sizeof(struct fc_echo_s), (echo + 1),
  349. (pyld_len - sizeof(struct fc_echo_s)));
  350. bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag,
  351. BFA_FALSE, FC_CLASS_3, pyld_len, &fchs, NULL, NULL,
  352. FC_MAX_PDUSZ, 0);
  353. }
  354. /*
  355. * Process incoming RNID.
  356. * Since it does not require a login, it is processed here.
  357. */
  358. static void
  359. bfa_fcs_lport_rnid(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
  360. struct fc_rnid_cmd_s *rnid, u16 rx_len)
  361. {
  362. struct fc_rnid_common_id_data_s common_id_data;
  363. struct fc_rnid_general_topology_data_s gen_topo_data;
  364. struct fchs_s fchs;
  365. struct bfa_fcxp_s *fcxp;
  366. struct bfa_rport_s *bfa_rport = NULL;
  367. u16 len;
  368. u32 data_format;
  369. bfa_trc(port->fcs, rx_fchs->s_id);
  370. bfa_trc(port->fcs, rx_fchs->d_id);
  371. bfa_trc(port->fcs, rx_len);
  372. fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  373. if (!fcxp)
  374. return;
  375. /*
  376. * Check Node Indentification Data Format
  377. * We only support General Topology Discovery Format.
  378. * For any other requested Data Formats, we return Common Node Id Data
  379. * only, as per FC-LS.
  380. */
  381. bfa_trc(port->fcs, rnid->node_id_data_format);
  382. if (rnid->node_id_data_format == RNID_NODEID_DATA_FORMAT_DISCOVERY) {
  383. data_format = RNID_NODEID_DATA_FORMAT_DISCOVERY;
  384. /*
  385. * Get General topology data for this port
  386. */
  387. bfa_fs_port_get_gen_topo_data(port, &gen_topo_data);
  388. } else {
  389. data_format = RNID_NODEID_DATA_FORMAT_COMMON;
  390. }
  391. /*
  392. * Copy the Node Id Info
  393. */
  394. common_id_data.port_name = bfa_fcs_lport_get_pwwn(port);
  395. common_id_data.node_name = bfa_fcs_lport_get_nwwn(port);
  396. len = fc_rnid_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  397. rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
  398. rx_fchs->ox_id, data_format, &common_id_data,
  399. &gen_topo_data);
  400. bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag,
  401. BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL,
  402. FC_MAX_PDUSZ, 0);
  403. }
  404. /*
  405. * Fill out General Topolpgy Discovery Data for RNID ELS.
  406. */
  407. static void
  408. bfa_fs_port_get_gen_topo_data(struct bfa_fcs_lport_s *port,
  409. struct fc_rnid_general_topology_data_s *gen_topo_data)
  410. {
  411. memset(gen_topo_data, 0,
  412. sizeof(struct fc_rnid_general_topology_data_s));
  413. gen_topo_data->asso_type = cpu_to_be32(RNID_ASSOCIATED_TYPE_HOST);
  414. gen_topo_data->phy_port_num = 0; /* @todo */
  415. gen_topo_data->num_attached_nodes = cpu_to_be32(1);
  416. }
  417. static void
  418. bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port)
  419. {
  420. struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
  421. char lpwwn_buf[BFA_STRING_32];
  422. bfa_trc(port->fcs, port->fabric->oper_type);
  423. __port_action[port->fabric->fab_type].init(port);
  424. __port_action[port->fabric->fab_type].online(port);
  425. wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
  426. BFA_LOG(KERN_INFO, bfad, bfa_log_level,
  427. "Logical port online: WWN = %s Role = %s\n",
  428. lpwwn_buf, "Initiator");
  429. bfad->bfad_flags |= BFAD_PORT_ONLINE;
  430. }
  431. static void
  432. bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port)
  433. {
  434. struct list_head *qe, *qen;
  435. struct bfa_fcs_rport_s *rport;
  436. struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
  437. char lpwwn_buf[BFA_STRING_32];
  438. bfa_trc(port->fcs, port->fabric->oper_type);
  439. __port_action[port->fabric->fab_type].offline(port);
  440. wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
  441. if (bfa_sm_cmp_state(port->fabric,
  442. bfa_fcs_fabric_sm_online) == BFA_TRUE)
  443. BFA_LOG(KERN_ERR, bfad, bfa_log_level,
  444. "Logical port lost fabric connectivity: WWN = %s Role = %s\n",
  445. lpwwn_buf, "Initiator");
  446. else
  447. BFA_LOG(KERN_INFO, bfad, bfa_log_level,
  448. "Logical port taken offline: WWN = %s Role = %s\n",
  449. lpwwn_buf, "Initiator");
  450. list_for_each_safe(qe, qen, &port->rport_q) {
  451. rport = (struct bfa_fcs_rport_s *) qe;
  452. bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP);
  453. }
  454. }
  455. static void
  456. bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s *port)
  457. {
  458. WARN_ON(1);
  459. }
  460. static void
  461. bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s *port)
  462. {
  463. WARN_ON(1);
  464. }
  465. static void
  466. bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s *port)
  467. {
  468. WARN_ON(1);
  469. }
  470. static void
  471. bfa_fcs_lport_abts_acc(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs)
  472. {
  473. struct fchs_s fchs;
  474. struct bfa_fcxp_s *fcxp;
  475. int len;
  476. bfa_trc(port->fcs, rx_fchs->d_id);
  477. bfa_trc(port->fcs, rx_fchs->s_id);
  478. fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  479. if (!fcxp)
  480. return;
  481. len = fc_ba_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  482. rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
  483. rx_fchs->ox_id, 0);
  484. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag,
  485. BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL,
  486. FC_MAX_PDUSZ, 0);
  487. }
  488. static void
  489. bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port)
  490. {
  491. struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
  492. char lpwwn_buf[BFA_STRING_32];
  493. wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
  494. BFA_LOG(KERN_INFO, bfad, bfa_log_level,
  495. "Logical port deleted: WWN = %s Role = %s\n",
  496. lpwwn_buf, "Initiator");
  497. /* Base port will be deleted by the OS driver */
  498. if (port->vport) {
  499. bfa_fcb_lport_delete(port->fcs->bfad, port->port_cfg.roles,
  500. port->fabric->vf_drv,
  501. port->vport ? port->vport->vport_drv : NULL);
  502. bfa_fcs_vport_delete_comp(port->vport);
  503. } else {
  504. bfa_wc_down(&port->fabric->wc);
  505. }
  506. }
  507. /*
  508. * Unsolicited frame receive handling.
  509. */
  510. void
  511. bfa_fcs_lport_uf_recv(struct bfa_fcs_lport_s *lport,
  512. struct fchs_s *fchs, u16 len)
  513. {
  514. u32 pid = fchs->s_id;
  515. struct bfa_fcs_rport_s *rport = NULL;
  516. struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1);
  517. bfa_stats(lport, uf_recvs);
  518. bfa_trc(lport->fcs, fchs->type);
  519. if (!bfa_fcs_lport_is_online(lport)) {
  520. bfa_stats(lport, uf_recv_drops);
  521. return;
  522. }
  523. /*
  524. * First, handle ELSs that donot require a login.
  525. */
  526. /*
  527. * Handle PLOGI first
  528. */
  529. if ((fchs->type == FC_TYPE_ELS) &&
  530. (els_cmd->els_code == FC_ELS_PLOGI)) {
  531. bfa_fcs_lport_plogi(lport, fchs, (struct fc_logi_s *) els_cmd);
  532. return;
  533. }
  534. /*
  535. * Handle ECHO separately.
  536. */
  537. if ((fchs->type == FC_TYPE_ELS) && (els_cmd->els_code == FC_ELS_ECHO)) {
  538. bfa_fcs_lport_echo(lport, fchs,
  539. (struct fc_echo_s *)els_cmd, len);
  540. return;
  541. }
  542. /*
  543. * Handle RNID separately.
  544. */
  545. if ((fchs->type == FC_TYPE_ELS) && (els_cmd->els_code == FC_ELS_RNID)) {
  546. bfa_fcs_lport_rnid(lport, fchs,
  547. (struct fc_rnid_cmd_s *) els_cmd, len);
  548. return;
  549. }
  550. if (fchs->type == FC_TYPE_BLS) {
  551. if ((fchs->routing == FC_RTG_BASIC_LINK) &&
  552. (fchs->cat_info == FC_CAT_ABTS))
  553. bfa_fcs_lport_abts_acc(lport, fchs);
  554. return;
  555. }
  556. /*
  557. * look for a matching remote port ID
  558. */
  559. rport = bfa_fcs_lport_get_rport_by_pid(lport, pid);
  560. if (rport) {
  561. bfa_trc(rport->fcs, fchs->s_id);
  562. bfa_trc(rport->fcs, fchs->d_id);
  563. bfa_trc(rport->fcs, fchs->type);
  564. bfa_fcs_rport_uf_recv(rport, fchs, len);
  565. return;
  566. }
  567. /*
  568. * Only handles ELS frames for now.
  569. */
  570. if (fchs->type != FC_TYPE_ELS) {
  571. bfa_trc(lport->fcs, fchs->s_id);
  572. bfa_trc(lport->fcs, fchs->d_id);
  573. /* ignore type FC_TYPE_FC_FSS */
  574. if (fchs->type != FC_TYPE_FC_FSS)
  575. bfa_sm_fault(lport->fcs, fchs->type);
  576. return;
  577. }
  578. bfa_trc(lport->fcs, els_cmd->els_code);
  579. if (els_cmd->els_code == FC_ELS_RSCN) {
  580. bfa_fcs_lport_scn_process_rscn(lport, fchs, len);
  581. return;
  582. }
  583. if (els_cmd->els_code == FC_ELS_LOGO) {
  584. /*
  585. * @todo Handle LOGO frames received.
  586. */
  587. return;
  588. }
  589. if (els_cmd->els_code == FC_ELS_PRLI) {
  590. /*
  591. * @todo Handle PRLI frames received.
  592. */
  593. return;
  594. }
  595. /*
  596. * Unhandled ELS frames. Send a LS_RJT.
  597. */
  598. bfa_fcs_lport_send_ls_rjt(lport, fchs, FC_LS_RJT_RSN_CMD_NOT_SUPP,
  599. FC_LS_RJT_EXP_NO_ADDL_INFO);
  600. }
  601. /*
  602. * PID based Lookup for a R-Port in the Port R-Port Queue
  603. */
  604. struct bfa_fcs_rport_s *
  605. bfa_fcs_lport_get_rport_by_pid(struct bfa_fcs_lport_s *port, u32 pid)
  606. {
  607. struct bfa_fcs_rport_s *rport;
  608. struct list_head *qe;
  609. list_for_each(qe, &port->rport_q) {
  610. rport = (struct bfa_fcs_rport_s *) qe;
  611. if (rport->pid == pid)
  612. return rport;
  613. }
  614. bfa_trc(port->fcs, pid);
  615. return NULL;
  616. }
  617. /*
  618. * PWWN based Lookup for a R-Port in the Port R-Port Queue
  619. */
  620. struct bfa_fcs_rport_s *
  621. bfa_fcs_lport_get_rport_by_pwwn(struct bfa_fcs_lport_s *port, wwn_t pwwn)
  622. {
  623. struct bfa_fcs_rport_s *rport;
  624. struct list_head *qe;
  625. list_for_each(qe, &port->rport_q) {
  626. rport = (struct bfa_fcs_rport_s *) qe;
  627. if (wwn_is_equal(rport->pwwn, pwwn))
  628. return rport;
  629. }
  630. bfa_trc(port->fcs, pwwn);
  631. return NULL;
  632. }
  633. /*
  634. * NWWN based Lookup for a R-Port in the Port R-Port Queue
  635. */
  636. struct bfa_fcs_rport_s *
  637. bfa_fcs_lport_get_rport_by_nwwn(struct bfa_fcs_lport_s *port, wwn_t nwwn)
  638. {
  639. struct bfa_fcs_rport_s *rport;
  640. struct list_head *qe;
  641. list_for_each(qe, &port->rport_q) {
  642. rport = (struct bfa_fcs_rport_s *) qe;
  643. if (wwn_is_equal(rport->nwwn, nwwn))
  644. return rport;
  645. }
  646. bfa_trc(port->fcs, nwwn);
  647. return NULL;
  648. }
  649. /*
  650. * Called by rport module when new rports are discovered.
  651. */
  652. void
  653. bfa_fcs_lport_add_rport(
  654. struct bfa_fcs_lport_s *port,
  655. struct bfa_fcs_rport_s *rport)
  656. {
  657. list_add_tail(&rport->qe, &port->rport_q);
  658. port->num_rports++;
  659. }
  660. /*
  661. * Called by rport module to when rports are deleted.
  662. */
  663. void
  664. bfa_fcs_lport_del_rport(
  665. struct bfa_fcs_lport_s *port,
  666. struct bfa_fcs_rport_s *rport)
  667. {
  668. WARN_ON(!bfa_q_is_on_q(&port->rport_q, rport));
  669. list_del(&rport->qe);
  670. port->num_rports--;
  671. bfa_sm_send_event(port, BFA_FCS_PORT_SM_DELRPORT);
  672. }
  673. /*
  674. * Called by fabric for base port when fabric login is complete.
  675. * Called by vport for virtual ports when FDISC is complete.
  676. */
  677. void
  678. bfa_fcs_lport_online(struct bfa_fcs_lport_s *port)
  679. {
  680. bfa_sm_send_event(port, BFA_FCS_PORT_SM_ONLINE);
  681. }
  682. /*
  683. * Called by fabric for base port when fabric goes offline.
  684. * Called by vport for virtual ports when virtual port becomes offline.
  685. */
  686. void
  687. bfa_fcs_lport_offline(struct bfa_fcs_lport_s *port)
  688. {
  689. bfa_sm_send_event(port, BFA_FCS_PORT_SM_OFFLINE);
  690. }
  691. /*
  692. * Called by fabric to delete base lport and associated resources.
  693. *
  694. * Called by vport to delete lport and associated resources. Should call
  695. * bfa_fcs_vport_delete_comp() for vports on completion.
  696. */
  697. void
  698. bfa_fcs_lport_delete(struct bfa_fcs_lport_s *port)
  699. {
  700. bfa_sm_send_event(port, BFA_FCS_PORT_SM_DELETE);
  701. }
  702. /*
  703. * Return TRUE if port is online, else return FALSE
  704. */
  705. bfa_boolean_t
  706. bfa_fcs_lport_is_online(struct bfa_fcs_lport_s *port)
  707. {
  708. return bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online);
  709. }
  710. /*
  711. * Attach time initialization of logical ports.
  712. */
  713. void
  714. bfa_fcs_lport_attach(struct bfa_fcs_lport_s *lport, struct bfa_fcs_s *fcs,
  715. u16 vf_id, struct bfa_fcs_vport_s *vport)
  716. {
  717. lport->fcs = fcs;
  718. lport->fabric = bfa_fcs_vf_lookup(fcs, vf_id);
  719. lport->vport = vport;
  720. lport->lp_tag = (vport) ? vport->lps->lp_tag :
  721. lport->fabric->lps->lp_tag;
  722. INIT_LIST_HEAD(&lport->rport_q);
  723. lport->num_rports = 0;
  724. }
  725. /*
  726. * Logical port initialization of base or virtual port.
  727. * Called by fabric for base port or by vport for virtual ports.
  728. */
  729. void
  730. bfa_fcs_lport_init(struct bfa_fcs_lport_s *lport,
  731. struct bfa_lport_cfg_s *port_cfg)
  732. {
  733. struct bfa_fcs_vport_s *vport = lport->vport;
  734. struct bfad_s *bfad = (struct bfad_s *)lport->fcs->bfad;
  735. char lpwwn_buf[BFA_STRING_32];
  736. lport->port_cfg = *port_cfg;
  737. lport->bfad_port = bfa_fcb_lport_new(lport->fcs->bfad, lport,
  738. lport->port_cfg.roles,
  739. lport->fabric->vf_drv,
  740. vport ? vport->vport_drv : NULL);
  741. wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(lport));
  742. BFA_LOG(KERN_INFO, bfad, bfa_log_level,
  743. "New logical port created: WWN = %s Role = %s\n",
  744. lpwwn_buf, "Initiator");
  745. bfa_sm_set_state(lport, bfa_fcs_lport_sm_uninit);
  746. bfa_sm_send_event(lport, BFA_FCS_PORT_SM_CREATE);
  747. }
  748. /*
  749. * fcs_lport_api
  750. */
  751. void
  752. bfa_fcs_lport_get_attr(
  753. struct bfa_fcs_lport_s *port,
  754. struct bfa_lport_attr_s *port_attr)
  755. {
  756. if (bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online))
  757. port_attr->pid = port->pid;
  758. else
  759. port_attr->pid = 0;
  760. port_attr->port_cfg = port->port_cfg;
  761. if (port->fabric) {
  762. port_attr->port_type = port->fabric->oper_type;
  763. port_attr->loopback = bfa_sm_cmp_state(port->fabric,
  764. bfa_fcs_fabric_sm_loopback);
  765. port_attr->authfail =
  766. bfa_sm_cmp_state(port->fabric,
  767. bfa_fcs_fabric_sm_auth_failed);
  768. port_attr->fabric_name = bfa_fcs_lport_get_fabric_name(port);
  769. memcpy(port_attr->fabric_ip_addr,
  770. bfa_fcs_lport_get_fabric_ipaddr(port),
  771. BFA_FCS_FABRIC_IPADDR_SZ);
  772. if (port->vport != NULL) {
  773. port_attr->port_type = BFA_PORT_TYPE_VPORT;
  774. port_attr->fpma_mac =
  775. port->vport->lps->lp_mac;
  776. } else {
  777. port_attr->fpma_mac =
  778. port->fabric->lps->lp_mac;
  779. }
  780. } else {
  781. port_attr->port_type = BFA_PORT_TYPE_UNKNOWN;
  782. port_attr->state = BFA_LPORT_UNINIT;
  783. }
  784. }
  785. /*
  786. * bfa_fcs_lport_fab port fab functions
  787. */
  788. /*
  789. * Called by port to initialize fabric services of the base port.
  790. */
  791. static void
  792. bfa_fcs_lport_fab_init(struct bfa_fcs_lport_s *port)
  793. {
  794. bfa_fcs_lport_ns_init(port);
  795. bfa_fcs_lport_scn_init(port);
  796. bfa_fcs_lport_ms_init(port);
  797. }
  798. /*
  799. * Called by port to notify transition to online state.
  800. */
  801. static void
  802. bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s *port)
  803. {
  804. bfa_fcs_lport_ns_online(port);
  805. bfa_fcs_lport_scn_online(port);
  806. }
  807. /*
  808. * Called by port to notify transition to offline state.
  809. */
  810. static void
  811. bfa_fcs_lport_fab_offline(struct bfa_fcs_lport_s *port)
  812. {
  813. bfa_fcs_lport_ns_offline(port);
  814. bfa_fcs_lport_scn_offline(port);
  815. bfa_fcs_lport_ms_offline(port);
  816. }
  817. /*
  818. * bfa_fcs_lport_n2n functions
  819. */
  820. /*
  821. * Called by fcs/port to initialize N2N topology.
  822. */
  823. static void
  824. bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s *port)
  825. {
  826. }
  827. /*
  828. * Called by fcs/port to notify transition to online state.
  829. */
  830. static void
  831. bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port)
  832. {
  833. struct bfa_fcs_lport_n2n_s *n2n_port = &port->port_topo.pn2n;
  834. struct bfa_lport_cfg_s *pcfg = &port->port_cfg;
  835. struct bfa_fcs_rport_s *rport;
  836. bfa_trc(port->fcs, pcfg->pwwn);
  837. /*
  838. * If our PWWN is > than that of the r-port, we have to initiate PLOGI
  839. * and assign an Address. if not, we need to wait for its PLOGI.
  840. *
  841. * If our PWWN is < than that of the remote port, it will send a PLOGI
  842. * with the PIDs assigned. The rport state machine take care of this
  843. * incoming PLOGI.
  844. */
  845. if (memcmp
  846. ((void *)&pcfg->pwwn, (void *)&n2n_port->rem_port_wwn,
  847. sizeof(wwn_t)) > 0) {
  848. port->pid = N2N_LOCAL_PID;
  849. bfa_lps_set_n2n_pid(port->fabric->lps, N2N_LOCAL_PID);
  850. /*
  851. * First, check if we know the device by pwwn.
  852. */
  853. rport = bfa_fcs_lport_get_rport_by_pwwn(port,
  854. n2n_port->rem_port_wwn);
  855. if (rport) {
  856. bfa_trc(port->fcs, rport->pid);
  857. bfa_trc(port->fcs, rport->pwwn);
  858. rport->pid = N2N_REMOTE_PID;
  859. bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_SEND);
  860. return;
  861. }
  862. /*
  863. * In n2n there can be only one rport. Delete the old one
  864. * whose pid should be zero, because it is offline.
  865. */
  866. if (port->num_rports > 0) {
  867. rport = bfa_fcs_lport_get_rport_by_pid(port, 0);
  868. WARN_ON(rport == NULL);
  869. if (rport) {
  870. bfa_trc(port->fcs, rport->pwwn);
  871. bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
  872. }
  873. }
  874. bfa_fcs_rport_create(port, N2N_REMOTE_PID);
  875. }
  876. }
  877. /*
  878. * Called by fcs/port to notify transition to offline state.
  879. */
  880. static void
  881. bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port)
  882. {
  883. struct bfa_fcs_lport_n2n_s *n2n_port = &port->port_topo.pn2n;
  884. bfa_trc(port->fcs, port->pid);
  885. port->pid = 0;
  886. n2n_port->rem_port_wwn = 0;
  887. n2n_port->reply_oxid = 0;
  888. }
  889. #define BFA_FCS_FDMI_CMD_MAX_RETRIES 2
  890. /*
  891. * forward declarations
  892. */
  893. static void bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg,
  894. struct bfa_fcxp_s *fcxp_alloced);
  895. static void bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg,
  896. struct bfa_fcxp_s *fcxp_alloced);
  897. static void bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg,
  898. struct bfa_fcxp_s *fcxp_alloced);
  899. static void bfa_fcs_lport_fdmi_rhba_response(void *fcsarg,
  900. struct bfa_fcxp_s *fcxp,
  901. void *cbarg,
  902. bfa_status_t req_status,
  903. u32 rsp_len,
  904. u32 resid_len,
  905. struct fchs_s *rsp_fchs);
  906. static void bfa_fcs_lport_fdmi_rprt_response(void *fcsarg,
  907. struct bfa_fcxp_s *fcxp,
  908. void *cbarg,
  909. bfa_status_t req_status,
  910. u32 rsp_len,
  911. u32 resid_len,
  912. struct fchs_s *rsp_fchs);
  913. static void bfa_fcs_lport_fdmi_rpa_response(void *fcsarg,
  914. struct bfa_fcxp_s *fcxp,
  915. void *cbarg,
  916. bfa_status_t req_status,
  917. u32 rsp_len,
  918. u32 resid_len,
  919. struct fchs_s *rsp_fchs);
  920. static void bfa_fcs_lport_fdmi_timeout(void *arg);
  921. static u16 bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi,
  922. u8 *pyld);
  923. static u16 bfa_fcs_lport_fdmi_build_rprt_pyld(struct bfa_fcs_lport_fdmi_s *fdmi,
  924. u8 *pyld);
  925. static u16 bfa_fcs_lport_fdmi_build_rpa_pyld(struct bfa_fcs_lport_fdmi_s *fdmi,
  926. u8 *pyld);
  927. static u16 bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *
  928. fdmi, u8 *pyld);
  929. static void bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi,
  930. struct bfa_fcs_fdmi_hba_attr_s *hba_attr);
  931. static void bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s *fdmi,
  932. struct bfa_fcs_fdmi_port_attr_s *port_attr);
  933. /*
  934. * fcs_fdmi_sm FCS FDMI state machine
  935. */
  936. /*
  937. * FDMI State Machine events
  938. */
  939. enum port_fdmi_event {
  940. FDMISM_EVENT_PORT_ONLINE = 1,
  941. FDMISM_EVENT_PORT_OFFLINE = 2,
  942. FDMISM_EVENT_RSP_OK = 4,
  943. FDMISM_EVENT_RSP_ERROR = 5,
  944. FDMISM_EVENT_TIMEOUT = 6,
  945. FDMISM_EVENT_RHBA_SENT = 7,
  946. FDMISM_EVENT_RPRT_SENT = 8,
  947. FDMISM_EVENT_RPA_SENT = 9,
  948. };
  949. static void bfa_fcs_lport_fdmi_sm_offline(struct bfa_fcs_lport_fdmi_s *fdmi,
  950. enum port_fdmi_event event);
  951. static void bfa_fcs_lport_fdmi_sm_sending_rhba(
  952. struct bfa_fcs_lport_fdmi_s *fdmi,
  953. enum port_fdmi_event event);
  954. static void bfa_fcs_lport_fdmi_sm_rhba(struct bfa_fcs_lport_fdmi_s *fdmi,
  955. enum port_fdmi_event event);
  956. static void bfa_fcs_lport_fdmi_sm_rhba_retry(
  957. struct bfa_fcs_lport_fdmi_s *fdmi,
  958. enum port_fdmi_event event);
  959. static void bfa_fcs_lport_fdmi_sm_sending_rprt(
  960. struct bfa_fcs_lport_fdmi_s *fdmi,
  961. enum port_fdmi_event event);
  962. static void bfa_fcs_lport_fdmi_sm_rprt(struct bfa_fcs_lport_fdmi_s *fdmi,
  963. enum port_fdmi_event event);
  964. static void bfa_fcs_lport_fdmi_sm_rprt_retry(
  965. struct bfa_fcs_lport_fdmi_s *fdmi,
  966. enum port_fdmi_event event);
  967. static void bfa_fcs_lport_fdmi_sm_sending_rpa(
  968. struct bfa_fcs_lport_fdmi_s *fdmi,
  969. enum port_fdmi_event event);
  970. static void bfa_fcs_lport_fdmi_sm_rpa(struct bfa_fcs_lport_fdmi_s *fdmi,
  971. enum port_fdmi_event event);
  972. static void bfa_fcs_lport_fdmi_sm_rpa_retry(
  973. struct bfa_fcs_lport_fdmi_s *fdmi,
  974. enum port_fdmi_event event);
  975. static void bfa_fcs_lport_fdmi_sm_online(struct bfa_fcs_lport_fdmi_s *fdmi,
  976. enum port_fdmi_event event);
  977. static void bfa_fcs_lport_fdmi_sm_disabled(
  978. struct bfa_fcs_lport_fdmi_s *fdmi,
  979. enum port_fdmi_event event);
  980. /*
  981. * Start in offline state - awaiting MS to send start.
  982. */
  983. static void
  984. bfa_fcs_lport_fdmi_sm_offline(struct bfa_fcs_lport_fdmi_s *fdmi,
  985. enum port_fdmi_event event)
  986. {
  987. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  988. bfa_trc(port->fcs, port->port_cfg.pwwn);
  989. bfa_trc(port->fcs, event);
  990. fdmi->retry_cnt = 0;
  991. switch (event) {
  992. case FDMISM_EVENT_PORT_ONLINE:
  993. if (port->vport) {
  994. /*
  995. * For Vports, register a new port.
  996. */
  997. bfa_sm_set_state(fdmi,
  998. bfa_fcs_lport_fdmi_sm_sending_rprt);
  999. bfa_fcs_lport_fdmi_send_rprt(fdmi, NULL);
  1000. } else {
  1001. /*
  1002. * For a base port, we should first register the HBA
  1003. * atribute. The HBA attribute also contains the base
  1004. * port registration.
  1005. */
  1006. bfa_sm_set_state(fdmi,
  1007. bfa_fcs_lport_fdmi_sm_sending_rhba);
  1008. bfa_fcs_lport_fdmi_send_rhba(fdmi, NULL);
  1009. }
  1010. break;
  1011. case FDMISM_EVENT_PORT_OFFLINE:
  1012. break;
  1013. default:
  1014. bfa_sm_fault(port->fcs, event);
  1015. }
  1016. }
  1017. static void
  1018. bfa_fcs_lport_fdmi_sm_sending_rhba(struct bfa_fcs_lport_fdmi_s *fdmi,
  1019. enum port_fdmi_event event)
  1020. {
  1021. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1022. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1023. bfa_trc(port->fcs, event);
  1024. switch (event) {
  1025. case FDMISM_EVENT_RHBA_SENT:
  1026. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rhba);
  1027. break;
  1028. case FDMISM_EVENT_PORT_OFFLINE:
  1029. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1030. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port),
  1031. &fdmi->fcxp_wqe);
  1032. break;
  1033. default:
  1034. bfa_sm_fault(port->fcs, event);
  1035. }
  1036. }
  1037. static void
  1038. bfa_fcs_lport_fdmi_sm_rhba(struct bfa_fcs_lport_fdmi_s *fdmi,
  1039. enum port_fdmi_event event)
  1040. {
  1041. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1042. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1043. bfa_trc(port->fcs, event);
  1044. switch (event) {
  1045. case FDMISM_EVENT_RSP_ERROR:
  1046. /*
  1047. * if max retries have not been reached, start timer for a
  1048. * delayed retry
  1049. */
  1050. if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) {
  1051. bfa_sm_set_state(fdmi,
  1052. bfa_fcs_lport_fdmi_sm_rhba_retry);
  1053. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port),
  1054. &fdmi->timer,
  1055. bfa_fcs_lport_fdmi_timeout, fdmi,
  1056. BFA_FCS_RETRY_TIMEOUT);
  1057. } else {
  1058. /*
  1059. * set state to offline
  1060. */
  1061. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1062. }
  1063. break;
  1064. case FDMISM_EVENT_RSP_OK:
  1065. /*
  1066. * Initiate Register Port Attributes
  1067. */
  1068. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rpa);
  1069. fdmi->retry_cnt = 0;
  1070. bfa_fcs_lport_fdmi_send_rpa(fdmi, NULL);
  1071. break;
  1072. case FDMISM_EVENT_PORT_OFFLINE:
  1073. bfa_fcxp_discard(fdmi->fcxp);
  1074. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1075. break;
  1076. default:
  1077. bfa_sm_fault(port->fcs, event);
  1078. }
  1079. }
  1080. static void
  1081. bfa_fcs_lport_fdmi_sm_rhba_retry(struct bfa_fcs_lport_fdmi_s *fdmi,
  1082. enum port_fdmi_event event)
  1083. {
  1084. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1085. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1086. bfa_trc(port->fcs, event);
  1087. switch (event) {
  1088. case FDMISM_EVENT_TIMEOUT:
  1089. /*
  1090. * Retry Timer Expired. Re-send
  1091. */
  1092. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rhba);
  1093. bfa_fcs_lport_fdmi_send_rhba(fdmi, NULL);
  1094. break;
  1095. case FDMISM_EVENT_PORT_OFFLINE:
  1096. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1097. bfa_timer_stop(&fdmi->timer);
  1098. break;
  1099. default:
  1100. bfa_sm_fault(port->fcs, event);
  1101. }
  1102. }
  1103. /*
  1104. * RPRT : Register Port
  1105. */
  1106. static void
  1107. bfa_fcs_lport_fdmi_sm_sending_rprt(struct bfa_fcs_lport_fdmi_s *fdmi,
  1108. enum port_fdmi_event event)
  1109. {
  1110. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1111. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1112. bfa_trc(port->fcs, event);
  1113. switch (event) {
  1114. case FDMISM_EVENT_RPRT_SENT:
  1115. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rprt);
  1116. break;
  1117. case FDMISM_EVENT_PORT_OFFLINE:
  1118. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1119. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port),
  1120. &fdmi->fcxp_wqe);
  1121. break;
  1122. default:
  1123. bfa_sm_fault(port->fcs, event);
  1124. }
  1125. }
  1126. static void
  1127. bfa_fcs_lport_fdmi_sm_rprt(struct bfa_fcs_lport_fdmi_s *fdmi,
  1128. enum port_fdmi_event event)
  1129. {
  1130. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1131. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1132. bfa_trc(port->fcs, event);
  1133. switch (event) {
  1134. case FDMISM_EVENT_RSP_ERROR:
  1135. /*
  1136. * if max retries have not been reached, start timer for a
  1137. * delayed retry
  1138. */
  1139. if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) {
  1140. bfa_sm_set_state(fdmi,
  1141. bfa_fcs_lport_fdmi_sm_rprt_retry);
  1142. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port),
  1143. &fdmi->timer,
  1144. bfa_fcs_lport_fdmi_timeout, fdmi,
  1145. BFA_FCS_RETRY_TIMEOUT);
  1146. } else {
  1147. /*
  1148. * set state to offline
  1149. */
  1150. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1151. fdmi->retry_cnt = 0;
  1152. }
  1153. break;
  1154. case FDMISM_EVENT_RSP_OK:
  1155. fdmi->retry_cnt = 0;
  1156. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_online);
  1157. break;
  1158. case FDMISM_EVENT_PORT_OFFLINE:
  1159. bfa_fcxp_discard(fdmi->fcxp);
  1160. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1161. break;
  1162. default:
  1163. bfa_sm_fault(port->fcs, event);
  1164. }
  1165. }
  1166. static void
  1167. bfa_fcs_lport_fdmi_sm_rprt_retry(struct bfa_fcs_lport_fdmi_s *fdmi,
  1168. enum port_fdmi_event event)
  1169. {
  1170. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1171. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1172. bfa_trc(port->fcs, event);
  1173. switch (event) {
  1174. case FDMISM_EVENT_TIMEOUT:
  1175. /*
  1176. * Retry Timer Expired. Re-send
  1177. */
  1178. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rprt);
  1179. bfa_fcs_lport_fdmi_send_rprt(fdmi, NULL);
  1180. break;
  1181. case FDMISM_EVENT_PORT_OFFLINE:
  1182. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1183. bfa_timer_stop(&fdmi->timer);
  1184. break;
  1185. default:
  1186. bfa_sm_fault(port->fcs, event);
  1187. }
  1188. }
  1189. /*
  1190. * Register Port Attributes
  1191. */
  1192. static void
  1193. bfa_fcs_lport_fdmi_sm_sending_rpa(struct bfa_fcs_lport_fdmi_s *fdmi,
  1194. enum port_fdmi_event event)
  1195. {
  1196. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1197. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1198. bfa_trc(port->fcs, event);
  1199. switch (event) {
  1200. case FDMISM_EVENT_RPA_SENT:
  1201. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rpa);
  1202. break;
  1203. case FDMISM_EVENT_PORT_OFFLINE:
  1204. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1205. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port),
  1206. &fdmi->fcxp_wqe);
  1207. break;
  1208. default:
  1209. bfa_sm_fault(port->fcs, event);
  1210. }
  1211. }
  1212. static void
  1213. bfa_fcs_lport_fdmi_sm_rpa(struct bfa_fcs_lport_fdmi_s *fdmi,
  1214. enum port_fdmi_event event)
  1215. {
  1216. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1217. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1218. bfa_trc(port->fcs, event);
  1219. switch (event) {
  1220. case FDMISM_EVENT_RSP_ERROR:
  1221. /*
  1222. * if max retries have not been reached, start timer for a
  1223. * delayed retry
  1224. */
  1225. if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) {
  1226. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rpa_retry);
  1227. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port),
  1228. &fdmi->timer,
  1229. bfa_fcs_lport_fdmi_timeout, fdmi,
  1230. BFA_FCS_RETRY_TIMEOUT);
  1231. } else {
  1232. /*
  1233. * set state to offline
  1234. */
  1235. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1236. fdmi->retry_cnt = 0;
  1237. }
  1238. break;
  1239. case FDMISM_EVENT_RSP_OK:
  1240. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_online);
  1241. fdmi->retry_cnt = 0;
  1242. break;
  1243. case FDMISM_EVENT_PORT_OFFLINE:
  1244. bfa_fcxp_discard(fdmi->fcxp);
  1245. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1246. break;
  1247. default:
  1248. bfa_sm_fault(port->fcs, event);
  1249. }
  1250. }
  1251. static void
  1252. bfa_fcs_lport_fdmi_sm_rpa_retry(struct bfa_fcs_lport_fdmi_s *fdmi,
  1253. enum port_fdmi_event event)
  1254. {
  1255. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1256. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1257. bfa_trc(port->fcs, event);
  1258. switch (event) {
  1259. case FDMISM_EVENT_TIMEOUT:
  1260. /*
  1261. * Retry Timer Expired. Re-send
  1262. */
  1263. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rpa);
  1264. bfa_fcs_lport_fdmi_send_rpa(fdmi, NULL);
  1265. break;
  1266. case FDMISM_EVENT_PORT_OFFLINE:
  1267. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1268. bfa_timer_stop(&fdmi->timer);
  1269. break;
  1270. default:
  1271. bfa_sm_fault(port->fcs, event);
  1272. }
  1273. }
  1274. static void
  1275. bfa_fcs_lport_fdmi_sm_online(struct bfa_fcs_lport_fdmi_s *fdmi,
  1276. enum port_fdmi_event event)
  1277. {
  1278. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1279. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1280. bfa_trc(port->fcs, event);
  1281. switch (event) {
  1282. case FDMISM_EVENT_PORT_OFFLINE:
  1283. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1284. break;
  1285. default:
  1286. bfa_sm_fault(port->fcs, event);
  1287. }
  1288. }
  1289. /*
  1290. * FDMI is disabled state.
  1291. */
  1292. static void
  1293. bfa_fcs_lport_fdmi_sm_disabled(struct bfa_fcs_lport_fdmi_s *fdmi,
  1294. enum port_fdmi_event event)
  1295. {
  1296. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1297. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1298. bfa_trc(port->fcs, event);
  1299. /* No op State. It can only be enabled at Driver Init. */
  1300. }
  1301. /*
  1302. * RHBA : Register HBA Attributes.
  1303. */
  1304. static void
  1305. bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  1306. {
  1307. struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg;
  1308. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1309. struct fchs_s fchs;
  1310. int len, attr_len;
  1311. struct bfa_fcxp_s *fcxp;
  1312. u8 *pyld;
  1313. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1314. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  1315. if (!fcxp) {
  1316. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
  1317. bfa_fcs_lport_fdmi_send_rhba, fdmi);
  1318. return;
  1319. }
  1320. fdmi->fcxp = fcxp;
  1321. pyld = bfa_fcxp_get_reqbuf(fcxp);
  1322. memset(pyld, 0, FC_MAX_PDUSZ);
  1323. len = fc_fdmi_reqhdr_build(&fchs, pyld, bfa_fcs_lport_get_fcid(port),
  1324. FDMI_RHBA);
  1325. attr_len =
  1326. bfa_fcs_lport_fdmi_build_rhba_pyld(fdmi,
  1327. (u8 *) ((struct ct_hdr_s *) pyld
  1328. + 1));
  1329. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  1330. FC_CLASS_3, (len + attr_len), &fchs,
  1331. bfa_fcs_lport_fdmi_rhba_response, (void *)fdmi,
  1332. FC_MAX_PDUSZ, FC_FCCT_TOV);
  1333. bfa_sm_send_event(fdmi, FDMISM_EVENT_RHBA_SENT);
  1334. }
  1335. static u16
  1336. bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
  1337. {
  1338. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1339. struct bfa_fcs_fdmi_hba_attr_s hba_attr;
  1340. struct bfa_fcs_fdmi_hba_attr_s *fcs_hba_attr = &hba_attr;
  1341. struct fdmi_rhba_s *rhba = (struct fdmi_rhba_s *) pyld;
  1342. struct fdmi_attr_s *attr;
  1343. u8 *curr_ptr;
  1344. u16 len, count;
  1345. u16 templen;
  1346. /*
  1347. * get hba attributes
  1348. */
  1349. bfa_fcs_fdmi_get_hbaattr(fdmi, fcs_hba_attr);
  1350. rhba->hba_id = bfa_fcs_lport_get_pwwn(port);
  1351. rhba->port_list.num_ports = cpu_to_be32(1);
  1352. rhba->port_list.port_entry = bfa_fcs_lport_get_pwwn(port);
  1353. len = sizeof(rhba->hba_id) + sizeof(rhba->port_list);
  1354. count = 0;
  1355. len += sizeof(rhba->hba_attr_blk.attr_count);
  1356. /*
  1357. * fill out the invididual entries of the HBA attrib Block
  1358. */
  1359. curr_ptr = (u8 *) &rhba->hba_attr_blk.hba_attr;
  1360. /*
  1361. * Node Name
  1362. */
  1363. attr = (struct fdmi_attr_s *) curr_ptr;
  1364. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_NODENAME);
  1365. templen = sizeof(wwn_t);
  1366. memcpy(attr->value, &bfa_fcs_lport_get_nwwn(port), templen);
  1367. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1368. len += templen;
  1369. count++;
  1370. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1371. sizeof(templen));
  1372. /*
  1373. * Manufacturer
  1374. */
  1375. attr = (struct fdmi_attr_s *) curr_ptr;
  1376. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MANUFACTURER);
  1377. templen = (u16) strlen(fcs_hba_attr->manufacturer);
  1378. memcpy(attr->value, fcs_hba_attr->manufacturer, templen);
  1379. templen = fc_roundup(templen, sizeof(u32));
  1380. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1381. len += templen;
  1382. count++;
  1383. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1384. sizeof(templen));
  1385. /*
  1386. * Serial Number
  1387. */
  1388. attr = (struct fdmi_attr_s *) curr_ptr;
  1389. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_SERIALNUM);
  1390. templen = (u16) strlen(fcs_hba_attr->serial_num);
  1391. memcpy(attr->value, fcs_hba_attr->serial_num, templen);
  1392. templen = fc_roundup(templen, sizeof(u32));
  1393. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1394. len += templen;
  1395. count++;
  1396. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1397. sizeof(templen));
  1398. /*
  1399. * Model
  1400. */
  1401. attr = (struct fdmi_attr_s *) curr_ptr;
  1402. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MODEL);
  1403. templen = (u16) strlen(fcs_hba_attr->model);
  1404. memcpy(attr->value, fcs_hba_attr->model, templen);
  1405. templen = fc_roundup(templen, sizeof(u32));
  1406. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1407. len += templen;
  1408. count++;
  1409. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1410. sizeof(templen));
  1411. /*
  1412. * Model Desc
  1413. */
  1414. attr = (struct fdmi_attr_s *) curr_ptr;
  1415. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MODEL_DESC);
  1416. templen = (u16) strlen(fcs_hba_attr->model_desc);
  1417. memcpy(attr->value, fcs_hba_attr->model_desc, templen);
  1418. templen = fc_roundup(templen, sizeof(u32));
  1419. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1420. len += templen;
  1421. count++;
  1422. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1423. sizeof(templen));
  1424. /*
  1425. * H/W Version
  1426. */
  1427. if (fcs_hba_attr->hw_version[0] != '\0') {
  1428. attr = (struct fdmi_attr_s *) curr_ptr;
  1429. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_HW_VERSION);
  1430. templen = (u16) strlen(fcs_hba_attr->hw_version);
  1431. memcpy(attr->value, fcs_hba_attr->hw_version, templen);
  1432. templen = fc_roundup(templen, sizeof(u32));
  1433. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1434. len += templen;
  1435. count++;
  1436. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1437. sizeof(templen));
  1438. }
  1439. /*
  1440. * Driver Version
  1441. */
  1442. attr = (struct fdmi_attr_s *) curr_ptr;
  1443. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_DRIVER_VERSION);
  1444. templen = (u16) strlen(fcs_hba_attr->driver_version);
  1445. memcpy(attr->value, fcs_hba_attr->driver_version, templen);
  1446. templen = fc_roundup(templen, sizeof(u32));
  1447. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1448. len += templen;;
  1449. count++;
  1450. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1451. sizeof(templen));
  1452. /*
  1453. * Option Rom Version
  1454. */
  1455. if (fcs_hba_attr->option_rom_ver[0] != '\0') {
  1456. attr = (struct fdmi_attr_s *) curr_ptr;
  1457. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_ROM_VERSION);
  1458. templen = (u16) strlen(fcs_hba_attr->option_rom_ver);
  1459. memcpy(attr->value, fcs_hba_attr->option_rom_ver, templen);
  1460. templen = fc_roundup(templen, sizeof(u32));
  1461. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1462. len += templen;
  1463. count++;
  1464. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1465. sizeof(templen));
  1466. }
  1467. /*
  1468. * f/w Version = driver version
  1469. */
  1470. attr = (struct fdmi_attr_s *) curr_ptr;
  1471. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_FW_VERSION);
  1472. templen = (u16) strlen(fcs_hba_attr->driver_version);
  1473. memcpy(attr->value, fcs_hba_attr->driver_version, templen);
  1474. templen = fc_roundup(templen, sizeof(u32));
  1475. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1476. len += templen;
  1477. count++;
  1478. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1479. sizeof(templen));
  1480. /*
  1481. * OS Name
  1482. */
  1483. if (fcs_hba_attr->os_name[0] != '\0') {
  1484. attr = (struct fdmi_attr_s *) curr_ptr;
  1485. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_OS_NAME);
  1486. templen = (u16) strlen(fcs_hba_attr->os_name);
  1487. memcpy(attr->value, fcs_hba_attr->os_name, templen);
  1488. templen = fc_roundup(templen, sizeof(u32));
  1489. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1490. len += templen;
  1491. count++;
  1492. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1493. sizeof(templen));
  1494. }
  1495. /*
  1496. * MAX_CT_PAYLOAD
  1497. */
  1498. attr = (struct fdmi_attr_s *) curr_ptr;
  1499. attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MAX_CT);
  1500. templen = sizeof(fcs_hba_attr->max_ct_pyld);
  1501. memcpy(attr->value, &fcs_hba_attr->max_ct_pyld, templen);
  1502. len += templen;
  1503. count++;
  1504. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1505. sizeof(templen));
  1506. /*
  1507. * Update size of payload
  1508. */
  1509. len += ((sizeof(attr->type) + sizeof(attr->len)) * count);
  1510. rhba->hba_attr_blk.attr_count = cpu_to_be32(count);
  1511. return len;
  1512. }
  1513. static void
  1514. bfa_fcs_lport_fdmi_rhba_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  1515. void *cbarg, bfa_status_t req_status,
  1516. u32 rsp_len, u32 resid_len,
  1517. struct fchs_s *rsp_fchs)
  1518. {
  1519. struct bfa_fcs_lport_fdmi_s *fdmi =
  1520. (struct bfa_fcs_lport_fdmi_s *) cbarg;
  1521. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1522. struct ct_hdr_s *cthdr = NULL;
  1523. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1524. /*
  1525. * Sanity Checks
  1526. */
  1527. if (req_status != BFA_STATUS_OK) {
  1528. bfa_trc(port->fcs, req_status);
  1529. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
  1530. return;
  1531. }
  1532. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  1533. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  1534. if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  1535. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK);
  1536. return;
  1537. }
  1538. bfa_trc(port->fcs, cthdr->reason_code);
  1539. bfa_trc(port->fcs, cthdr->exp_code);
  1540. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
  1541. }
  1542. /*
  1543. * RPRT : Register Port
  1544. */
  1545. static void
  1546. bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  1547. {
  1548. struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg;
  1549. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1550. struct fchs_s fchs;
  1551. u16 len, attr_len;
  1552. struct bfa_fcxp_s *fcxp;
  1553. u8 *pyld;
  1554. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1555. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  1556. if (!fcxp) {
  1557. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
  1558. bfa_fcs_lport_fdmi_send_rprt, fdmi);
  1559. return;
  1560. }
  1561. fdmi->fcxp = fcxp;
  1562. pyld = bfa_fcxp_get_reqbuf(fcxp);
  1563. memset(pyld, 0, FC_MAX_PDUSZ);
  1564. len = fc_fdmi_reqhdr_build(&fchs, pyld, bfa_fcs_lport_get_fcid(port),
  1565. FDMI_RPRT);
  1566. attr_len =
  1567. bfa_fcs_lport_fdmi_build_rprt_pyld(fdmi,
  1568. (u8 *) ((struct ct_hdr_s *) pyld
  1569. + 1));
  1570. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  1571. FC_CLASS_3, len + attr_len, &fchs,
  1572. bfa_fcs_lport_fdmi_rprt_response, (void *)fdmi,
  1573. FC_MAX_PDUSZ, FC_FCCT_TOV);
  1574. bfa_sm_send_event(fdmi, FDMISM_EVENT_RPRT_SENT);
  1575. }
  1576. /*
  1577. * This routine builds Port Attribute Block that used in RPA, RPRT commands.
  1578. */
  1579. static u16
  1580. bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *fdmi,
  1581. u8 *pyld)
  1582. {
  1583. struct bfa_fcs_fdmi_port_attr_s fcs_port_attr;
  1584. struct fdmi_port_attr_s *port_attrib = (struct fdmi_port_attr_s *) pyld;
  1585. struct fdmi_attr_s *attr;
  1586. u8 *curr_ptr;
  1587. u16 len;
  1588. u8 count = 0;
  1589. u16 templen;
  1590. /*
  1591. * get port attributes
  1592. */
  1593. bfa_fcs_fdmi_get_portattr(fdmi, &fcs_port_attr);
  1594. len = sizeof(port_attrib->attr_count);
  1595. /*
  1596. * fill out the invididual entries
  1597. */
  1598. curr_ptr = (u8 *) &port_attrib->port_attr;
  1599. /*
  1600. * FC4 Types
  1601. */
  1602. attr = (struct fdmi_attr_s *) curr_ptr;
  1603. attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_FC4_TYPES);
  1604. templen = sizeof(fcs_port_attr.supp_fc4_types);
  1605. memcpy(attr->value, fcs_port_attr.supp_fc4_types, templen);
  1606. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1607. len += templen;
  1608. ++count;
  1609. attr->len =
  1610. cpu_to_be16(templen + sizeof(attr->type) +
  1611. sizeof(templen));
  1612. /*
  1613. * Supported Speed
  1614. */
  1615. attr = (struct fdmi_attr_s *) curr_ptr;
  1616. attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_SUPP_SPEED);
  1617. templen = sizeof(fcs_port_attr.supp_speed);
  1618. memcpy(attr->value, &fcs_port_attr.supp_speed, templen);
  1619. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1620. len += templen;
  1621. ++count;
  1622. attr->len =
  1623. cpu_to_be16(templen + sizeof(attr->type) +
  1624. sizeof(templen));
  1625. /*
  1626. * current Port Speed
  1627. */
  1628. attr = (struct fdmi_attr_s *) curr_ptr;
  1629. attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_SPEED);
  1630. templen = sizeof(fcs_port_attr.curr_speed);
  1631. memcpy(attr->value, &fcs_port_attr.curr_speed, templen);
  1632. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1633. len += templen;
  1634. ++count;
  1635. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1636. sizeof(templen));
  1637. /*
  1638. * max frame size
  1639. */
  1640. attr = (struct fdmi_attr_s *) curr_ptr;
  1641. attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_FRAME_SIZE);
  1642. templen = sizeof(fcs_port_attr.max_frm_size);
  1643. memcpy(attr->value, &fcs_port_attr.max_frm_size, templen);
  1644. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1645. len += templen;
  1646. ++count;
  1647. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1648. sizeof(templen));
  1649. /*
  1650. * OS Device Name
  1651. */
  1652. if (fcs_port_attr.os_device_name[0] != '\0') {
  1653. attr = (struct fdmi_attr_s *) curr_ptr;
  1654. attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_DEV_NAME);
  1655. templen = (u16) strlen(fcs_port_attr.os_device_name);
  1656. memcpy(attr->value, fcs_port_attr.os_device_name, templen);
  1657. templen = fc_roundup(templen, sizeof(u32));
  1658. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1659. len += templen;
  1660. ++count;
  1661. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1662. sizeof(templen));
  1663. }
  1664. /*
  1665. * Host Name
  1666. */
  1667. if (fcs_port_attr.host_name[0] != '\0') {
  1668. attr = (struct fdmi_attr_s *) curr_ptr;
  1669. attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_HOST_NAME);
  1670. templen = (u16) strlen(fcs_port_attr.host_name);
  1671. memcpy(attr->value, fcs_port_attr.host_name, templen);
  1672. templen = fc_roundup(templen, sizeof(u32));
  1673. curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
  1674. len += templen;
  1675. ++count;
  1676. attr->len = cpu_to_be16(templen + sizeof(attr->type) +
  1677. sizeof(templen));
  1678. }
  1679. /*
  1680. * Update size of payload
  1681. */
  1682. port_attrib->attr_count = cpu_to_be32(count);
  1683. len += ((sizeof(attr->type) + sizeof(attr->len)) * count);
  1684. return len;
  1685. }
  1686. static u16
  1687. bfa_fcs_lport_fdmi_build_rprt_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
  1688. {
  1689. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1690. struct fdmi_rprt_s *rprt = (struct fdmi_rprt_s *) pyld;
  1691. u16 len;
  1692. rprt->hba_id = bfa_fcs_lport_get_pwwn(bfa_fcs_get_base_port(port->fcs));
  1693. rprt->port_name = bfa_fcs_lport_get_pwwn(port);
  1694. len = bfa_fcs_lport_fdmi_build_portattr_block(fdmi,
  1695. (u8 *) &rprt->port_attr_blk);
  1696. len += sizeof(rprt->hba_id) + sizeof(rprt->port_name);
  1697. return len;
  1698. }
  1699. static void
  1700. bfa_fcs_lport_fdmi_rprt_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  1701. void *cbarg, bfa_status_t req_status,
  1702. u32 rsp_len, u32 resid_len,
  1703. struct fchs_s *rsp_fchs)
  1704. {
  1705. struct bfa_fcs_lport_fdmi_s *fdmi =
  1706. (struct bfa_fcs_lport_fdmi_s *) cbarg;
  1707. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1708. struct ct_hdr_s *cthdr = NULL;
  1709. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1710. /*
  1711. * Sanity Checks
  1712. */
  1713. if (req_status != BFA_STATUS_OK) {
  1714. bfa_trc(port->fcs, req_status);
  1715. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
  1716. return;
  1717. }
  1718. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  1719. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  1720. if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  1721. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK);
  1722. return;
  1723. }
  1724. bfa_trc(port->fcs, cthdr->reason_code);
  1725. bfa_trc(port->fcs, cthdr->exp_code);
  1726. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
  1727. }
  1728. /*
  1729. * RPA : Register Port Attributes.
  1730. */
  1731. static void
  1732. bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  1733. {
  1734. struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg;
  1735. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1736. struct fchs_s fchs;
  1737. u16 len, attr_len;
  1738. struct bfa_fcxp_s *fcxp;
  1739. u8 *pyld;
  1740. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1741. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  1742. if (!fcxp) {
  1743. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
  1744. bfa_fcs_lport_fdmi_send_rpa, fdmi);
  1745. return;
  1746. }
  1747. fdmi->fcxp = fcxp;
  1748. pyld = bfa_fcxp_get_reqbuf(fcxp);
  1749. memset(pyld, 0, FC_MAX_PDUSZ);
  1750. len = fc_fdmi_reqhdr_build(&fchs, pyld, bfa_fcs_lport_get_fcid(port),
  1751. FDMI_RPA);
  1752. attr_len = bfa_fcs_lport_fdmi_build_rpa_pyld(fdmi,
  1753. (u8 *) ((struct ct_hdr_s *) pyld + 1));
  1754. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  1755. FC_CLASS_3, len + attr_len, &fchs,
  1756. bfa_fcs_lport_fdmi_rpa_response, (void *)fdmi,
  1757. FC_MAX_PDUSZ, FC_FCCT_TOV);
  1758. bfa_sm_send_event(fdmi, FDMISM_EVENT_RPA_SENT);
  1759. }
  1760. static u16
  1761. bfa_fcs_lport_fdmi_build_rpa_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
  1762. {
  1763. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1764. struct fdmi_rpa_s *rpa = (struct fdmi_rpa_s *) pyld;
  1765. u16 len;
  1766. rpa->port_name = bfa_fcs_lport_get_pwwn(port);
  1767. len = bfa_fcs_lport_fdmi_build_portattr_block(fdmi,
  1768. (u8 *) &rpa->port_attr_blk);
  1769. len += sizeof(rpa->port_name);
  1770. return len;
  1771. }
  1772. static void
  1773. bfa_fcs_lport_fdmi_rpa_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  1774. void *cbarg, bfa_status_t req_status, u32 rsp_len,
  1775. u32 resid_len, struct fchs_s *rsp_fchs)
  1776. {
  1777. struct bfa_fcs_lport_fdmi_s *fdmi =
  1778. (struct bfa_fcs_lport_fdmi_s *) cbarg;
  1779. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1780. struct ct_hdr_s *cthdr = NULL;
  1781. bfa_trc(port->fcs, port->port_cfg.pwwn);
  1782. /*
  1783. * Sanity Checks
  1784. */
  1785. if (req_status != BFA_STATUS_OK) {
  1786. bfa_trc(port->fcs, req_status);
  1787. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
  1788. return;
  1789. }
  1790. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  1791. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  1792. if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  1793. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK);
  1794. return;
  1795. }
  1796. bfa_trc(port->fcs, cthdr->reason_code);
  1797. bfa_trc(port->fcs, cthdr->exp_code);
  1798. bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
  1799. }
  1800. static void
  1801. bfa_fcs_lport_fdmi_timeout(void *arg)
  1802. {
  1803. struct bfa_fcs_lport_fdmi_s *fdmi = (struct bfa_fcs_lport_fdmi_s *) arg;
  1804. bfa_sm_send_event(fdmi, FDMISM_EVENT_TIMEOUT);
  1805. }
  1806. static void
  1807. bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi,
  1808. struct bfa_fcs_fdmi_hba_attr_s *hba_attr)
  1809. {
  1810. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1811. struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info;
  1812. memset(hba_attr, 0, sizeof(struct bfa_fcs_fdmi_hba_attr_s));
  1813. bfa_ioc_get_adapter_manufacturer(&port->fcs->bfa->ioc,
  1814. hba_attr->manufacturer);
  1815. bfa_ioc_get_adapter_serial_num(&port->fcs->bfa->ioc,
  1816. hba_attr->serial_num);
  1817. bfa_ioc_get_adapter_model(&port->fcs->bfa->ioc,
  1818. hba_attr->model);
  1819. bfa_ioc_get_adapter_model(&port->fcs->bfa->ioc,
  1820. hba_attr->model_desc);
  1821. bfa_ioc_get_pci_chip_rev(&port->fcs->bfa->ioc,
  1822. hba_attr->hw_version);
  1823. bfa_ioc_get_adapter_optrom_ver(&port->fcs->bfa->ioc,
  1824. hba_attr->option_rom_ver);
  1825. bfa_ioc_get_adapter_fw_ver(&port->fcs->bfa->ioc,
  1826. hba_attr->fw_version);
  1827. strncpy(hba_attr->driver_version, (char *)driver_info->version,
  1828. sizeof(hba_attr->driver_version));
  1829. strncpy(hba_attr->os_name, driver_info->host_os_name,
  1830. sizeof(hba_attr->os_name));
  1831. /*
  1832. * If there is a patch level, append it
  1833. * to the os name along with a separator
  1834. */
  1835. if (driver_info->host_os_patch[0] != '\0') {
  1836. strncat(hba_attr->os_name, BFA_FCS_PORT_SYMBNAME_SEPARATOR,
  1837. sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR));
  1838. strncat(hba_attr->os_name, driver_info->host_os_patch,
  1839. sizeof(driver_info->host_os_patch));
  1840. }
  1841. hba_attr->max_ct_pyld = cpu_to_be32(FC_MAX_PDUSZ);
  1842. }
  1843. static void
  1844. bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s *fdmi,
  1845. struct bfa_fcs_fdmi_port_attr_s *port_attr)
  1846. {
  1847. struct bfa_fcs_lport_s *port = fdmi->ms->port;
  1848. struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info;
  1849. struct bfa_port_attr_s pport_attr;
  1850. memset(port_attr, 0, sizeof(struct bfa_fcs_fdmi_port_attr_s));
  1851. /*
  1852. * get pport attributes from hal
  1853. */
  1854. bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);
  1855. /*
  1856. * get FC4 type Bitmask
  1857. */
  1858. fc_get_fc4type_bitmask(FC_TYPE_FCP, port_attr->supp_fc4_types);
  1859. /*
  1860. * Supported Speeds
  1861. */
  1862. port_attr->supp_speed = cpu_to_be32(BFA_FCS_FDMI_SUPORTED_SPEEDS);
  1863. /*
  1864. * Current Speed
  1865. */
  1866. port_attr->curr_speed = cpu_to_be32(pport_attr.speed);
  1867. /*
  1868. * Max PDU Size.
  1869. */
  1870. port_attr->max_frm_size = cpu_to_be32(FC_MAX_PDUSZ);
  1871. /*
  1872. * OS device Name
  1873. */
  1874. strncpy(port_attr->os_device_name, (char *)driver_info->os_device_name,
  1875. sizeof(port_attr->os_device_name));
  1876. /*
  1877. * Host name
  1878. */
  1879. strncpy(port_attr->host_name, (char *)driver_info->host_machine_name,
  1880. sizeof(port_attr->host_name));
  1881. }
  1882. void
  1883. bfa_fcs_lport_fdmi_init(struct bfa_fcs_lport_ms_s *ms)
  1884. {
  1885. struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi;
  1886. fdmi->ms = ms;
  1887. if (ms->port->fcs->fdmi_enabled)
  1888. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
  1889. else
  1890. bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_disabled);
  1891. }
  1892. void
  1893. bfa_fcs_lport_fdmi_offline(struct bfa_fcs_lport_ms_s *ms)
  1894. {
  1895. struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi;
  1896. fdmi->ms = ms;
  1897. bfa_sm_send_event(fdmi, FDMISM_EVENT_PORT_OFFLINE);
  1898. }
  1899. void
  1900. bfa_fcs_lport_fdmi_online(struct bfa_fcs_lport_ms_s *ms)
  1901. {
  1902. struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi;
  1903. fdmi->ms = ms;
  1904. bfa_sm_send_event(fdmi, FDMISM_EVENT_PORT_ONLINE);
  1905. }
  1906. #define BFA_FCS_MS_CMD_MAX_RETRIES 2
  1907. /*
  1908. * forward declarations
  1909. */
  1910. static void bfa_fcs_lport_ms_send_plogi(void *ms_cbarg,
  1911. struct bfa_fcxp_s *fcxp_alloced);
  1912. static void bfa_fcs_lport_ms_timeout(void *arg);
  1913. static void bfa_fcs_lport_ms_plogi_response(void *fcsarg,
  1914. struct bfa_fcxp_s *fcxp,
  1915. void *cbarg,
  1916. bfa_status_t req_status,
  1917. u32 rsp_len,
  1918. u32 resid_len,
  1919. struct fchs_s *rsp_fchs);
  1920. static void bfa_fcs_lport_ms_send_gmal(void *ms_cbarg,
  1921. struct bfa_fcxp_s *fcxp_alloced);
  1922. static void bfa_fcs_lport_ms_gmal_response(void *fcsarg,
  1923. struct bfa_fcxp_s *fcxp,
  1924. void *cbarg,
  1925. bfa_status_t req_status,
  1926. u32 rsp_len,
  1927. u32 resid_len,
  1928. struct fchs_s *rsp_fchs);
  1929. static void bfa_fcs_lport_ms_send_gfn(void *ms_cbarg,
  1930. struct bfa_fcxp_s *fcxp_alloced);
  1931. static void bfa_fcs_lport_ms_gfn_response(void *fcsarg,
  1932. struct bfa_fcxp_s *fcxp,
  1933. void *cbarg,
  1934. bfa_status_t req_status,
  1935. u32 rsp_len,
  1936. u32 resid_len,
  1937. struct fchs_s *rsp_fchs);
  1938. /*
  1939. * fcs_ms_sm FCS MS state machine
  1940. */
  1941. /*
  1942. * MS State Machine events
  1943. */
  1944. enum port_ms_event {
  1945. MSSM_EVENT_PORT_ONLINE = 1,
  1946. MSSM_EVENT_PORT_OFFLINE = 2,
  1947. MSSM_EVENT_RSP_OK = 3,
  1948. MSSM_EVENT_RSP_ERROR = 4,
  1949. MSSM_EVENT_TIMEOUT = 5,
  1950. MSSM_EVENT_FCXP_SENT = 6,
  1951. MSSM_EVENT_PORT_FABRIC_RSCN = 7
  1952. };
  1953. static void bfa_fcs_lport_ms_sm_offline(struct bfa_fcs_lport_ms_s *ms,
  1954. enum port_ms_event event);
  1955. static void bfa_fcs_lport_ms_sm_plogi_sending(struct bfa_fcs_lport_ms_s *ms,
  1956. enum port_ms_event event);
  1957. static void bfa_fcs_lport_ms_sm_plogi(struct bfa_fcs_lport_ms_s *ms,
  1958. enum port_ms_event event);
  1959. static void bfa_fcs_lport_ms_sm_plogi_retry(struct bfa_fcs_lport_ms_s *ms,
  1960. enum port_ms_event event);
  1961. static void bfa_fcs_lport_ms_sm_gmal_sending(struct bfa_fcs_lport_ms_s *ms,
  1962. enum port_ms_event event);
  1963. static void bfa_fcs_lport_ms_sm_gmal(struct bfa_fcs_lport_ms_s *ms,
  1964. enum port_ms_event event);
  1965. static void bfa_fcs_lport_ms_sm_gmal_retry(struct bfa_fcs_lport_ms_s *ms,
  1966. enum port_ms_event event);
  1967. static void bfa_fcs_lport_ms_sm_gfn_sending(struct bfa_fcs_lport_ms_s *ms,
  1968. enum port_ms_event event);
  1969. static void bfa_fcs_lport_ms_sm_gfn(struct bfa_fcs_lport_ms_s *ms,
  1970. enum port_ms_event event);
  1971. static void bfa_fcs_lport_ms_sm_gfn_retry(struct bfa_fcs_lport_ms_s *ms,
  1972. enum port_ms_event event);
  1973. static void bfa_fcs_lport_ms_sm_online(struct bfa_fcs_lport_ms_s *ms,
  1974. enum port_ms_event event);
  1975. /*
  1976. * Start in offline state - awaiting NS to send start.
  1977. */
  1978. static void
  1979. bfa_fcs_lport_ms_sm_offline(struct bfa_fcs_lport_ms_s *ms,
  1980. enum port_ms_event event)
  1981. {
  1982. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  1983. bfa_trc(ms->port->fcs, event);
  1984. switch (event) {
  1985. case MSSM_EVENT_PORT_ONLINE:
  1986. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_sending);
  1987. bfa_fcs_lport_ms_send_plogi(ms, NULL);
  1988. break;
  1989. case MSSM_EVENT_PORT_OFFLINE:
  1990. break;
  1991. default:
  1992. bfa_sm_fault(ms->port->fcs, event);
  1993. }
  1994. }
  1995. static void
  1996. bfa_fcs_lport_ms_sm_plogi_sending(struct bfa_fcs_lport_ms_s *ms,
  1997. enum port_ms_event event)
  1998. {
  1999. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2000. bfa_trc(ms->port->fcs, event);
  2001. switch (event) {
  2002. case MSSM_EVENT_FCXP_SENT:
  2003. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi);
  2004. break;
  2005. case MSSM_EVENT_PORT_OFFLINE:
  2006. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2007. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
  2008. &ms->fcxp_wqe);
  2009. break;
  2010. default:
  2011. bfa_sm_fault(ms->port->fcs, event);
  2012. }
  2013. }
  2014. static void
  2015. bfa_fcs_lport_ms_sm_plogi(struct bfa_fcs_lport_ms_s *ms,
  2016. enum port_ms_event event)
  2017. {
  2018. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2019. bfa_trc(ms->port->fcs, event);
  2020. switch (event) {
  2021. case MSSM_EVENT_RSP_ERROR:
  2022. /*
  2023. * Start timer for a delayed retry
  2024. */
  2025. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_retry);
  2026. ms->port->stats.ms_retries++;
  2027. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
  2028. &ms->timer, bfa_fcs_lport_ms_timeout, ms,
  2029. BFA_FCS_RETRY_TIMEOUT);
  2030. break;
  2031. case MSSM_EVENT_RSP_OK:
  2032. /*
  2033. * since plogi is done, now invoke MS related sub-modules
  2034. */
  2035. bfa_fcs_lport_fdmi_online(ms);
  2036. /*
  2037. * if this is a Vport, go to online state.
  2038. */
  2039. if (ms->port->vport) {
  2040. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online);
  2041. break;
  2042. }
  2043. /*
  2044. * For a base port we need to get the
  2045. * switch's IP address.
  2046. */
  2047. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_sending);
  2048. bfa_fcs_lport_ms_send_gmal(ms, NULL);
  2049. break;
  2050. case MSSM_EVENT_PORT_OFFLINE:
  2051. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2052. bfa_fcxp_discard(ms->fcxp);
  2053. break;
  2054. default:
  2055. bfa_sm_fault(ms->port->fcs, event);
  2056. }
  2057. }
  2058. static void
  2059. bfa_fcs_lport_ms_sm_plogi_retry(struct bfa_fcs_lport_ms_s *ms,
  2060. enum port_ms_event event)
  2061. {
  2062. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2063. bfa_trc(ms->port->fcs, event);
  2064. switch (event) {
  2065. case MSSM_EVENT_TIMEOUT:
  2066. /*
  2067. * Retry Timer Expired. Re-send
  2068. */
  2069. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_sending);
  2070. bfa_fcs_lport_ms_send_plogi(ms, NULL);
  2071. break;
  2072. case MSSM_EVENT_PORT_OFFLINE:
  2073. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2074. bfa_timer_stop(&ms->timer);
  2075. break;
  2076. default:
  2077. bfa_sm_fault(ms->port->fcs, event);
  2078. }
  2079. }
  2080. static void
  2081. bfa_fcs_lport_ms_sm_online(struct bfa_fcs_lport_ms_s *ms,
  2082. enum port_ms_event event)
  2083. {
  2084. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2085. bfa_trc(ms->port->fcs, event);
  2086. switch (event) {
  2087. case MSSM_EVENT_PORT_OFFLINE:
  2088. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2089. break;
  2090. case MSSM_EVENT_PORT_FABRIC_RSCN:
  2091. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending);
  2092. ms->retry_cnt = 0;
  2093. bfa_fcs_lport_ms_send_gfn(ms, NULL);
  2094. break;
  2095. default:
  2096. bfa_sm_fault(ms->port->fcs, event);
  2097. }
  2098. }
  2099. static void
  2100. bfa_fcs_lport_ms_sm_gmal_sending(struct bfa_fcs_lport_ms_s *ms,
  2101. enum port_ms_event event)
  2102. {
  2103. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2104. bfa_trc(ms->port->fcs, event);
  2105. switch (event) {
  2106. case MSSM_EVENT_FCXP_SENT:
  2107. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal);
  2108. break;
  2109. case MSSM_EVENT_PORT_OFFLINE:
  2110. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2111. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
  2112. &ms->fcxp_wqe);
  2113. break;
  2114. default:
  2115. bfa_sm_fault(ms->port->fcs, event);
  2116. }
  2117. }
  2118. static void
  2119. bfa_fcs_lport_ms_sm_gmal(struct bfa_fcs_lport_ms_s *ms,
  2120. enum port_ms_event event)
  2121. {
  2122. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2123. bfa_trc(ms->port->fcs, event);
  2124. switch (event) {
  2125. case MSSM_EVENT_RSP_ERROR:
  2126. /*
  2127. * Start timer for a delayed retry
  2128. */
  2129. if (ms->retry_cnt++ < BFA_FCS_MS_CMD_MAX_RETRIES) {
  2130. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_retry);
  2131. ms->port->stats.ms_retries++;
  2132. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
  2133. &ms->timer, bfa_fcs_lport_ms_timeout, ms,
  2134. BFA_FCS_RETRY_TIMEOUT);
  2135. } else {
  2136. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending);
  2137. bfa_fcs_lport_ms_send_gfn(ms, NULL);
  2138. ms->retry_cnt = 0;
  2139. }
  2140. break;
  2141. case MSSM_EVENT_RSP_OK:
  2142. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending);
  2143. bfa_fcs_lport_ms_send_gfn(ms, NULL);
  2144. break;
  2145. case MSSM_EVENT_PORT_OFFLINE:
  2146. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2147. bfa_fcxp_discard(ms->fcxp);
  2148. break;
  2149. default:
  2150. bfa_sm_fault(ms->port->fcs, event);
  2151. }
  2152. }
  2153. static void
  2154. bfa_fcs_lport_ms_sm_gmal_retry(struct bfa_fcs_lport_ms_s *ms,
  2155. enum port_ms_event event)
  2156. {
  2157. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2158. bfa_trc(ms->port->fcs, event);
  2159. switch (event) {
  2160. case MSSM_EVENT_TIMEOUT:
  2161. /*
  2162. * Retry Timer Expired. Re-send
  2163. */
  2164. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_sending);
  2165. bfa_fcs_lport_ms_send_gmal(ms, NULL);
  2166. break;
  2167. case MSSM_EVENT_PORT_OFFLINE:
  2168. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2169. bfa_timer_stop(&ms->timer);
  2170. break;
  2171. default:
  2172. bfa_sm_fault(ms->port->fcs, event);
  2173. }
  2174. }
  2175. /*
  2176. * ms_pvt MS local functions
  2177. */
  2178. static void
  2179. bfa_fcs_lport_ms_send_gmal(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  2180. {
  2181. struct bfa_fcs_lport_ms_s *ms = ms_cbarg;
  2182. bfa_fcs_lport_t *port = ms->port;
  2183. struct fchs_s fchs;
  2184. int len;
  2185. struct bfa_fcxp_s *fcxp;
  2186. bfa_trc(port->fcs, port->pid);
  2187. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  2188. if (!fcxp) {
  2189. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
  2190. bfa_fcs_lport_ms_send_gmal, ms);
  2191. return;
  2192. }
  2193. ms->fcxp = fcxp;
  2194. len = fc_gmal_req_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  2195. bfa_fcs_lport_get_fcid(port),
  2196. port->fabric->lps->pr_nwwn);
  2197. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  2198. FC_CLASS_3, len, &fchs,
  2199. bfa_fcs_lport_ms_gmal_response, (void *)ms,
  2200. FC_MAX_PDUSZ, FC_FCCT_TOV);
  2201. bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT);
  2202. }
  2203. static void
  2204. bfa_fcs_lport_ms_gmal_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  2205. void *cbarg, bfa_status_t req_status,
  2206. u32 rsp_len, u32 resid_len,
  2207. struct fchs_s *rsp_fchs)
  2208. {
  2209. struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg;
  2210. bfa_fcs_lport_t *port = ms->port;
  2211. struct ct_hdr_s *cthdr = NULL;
  2212. struct fcgs_gmal_resp_s *gmal_resp;
  2213. struct fcgs_gmal_entry_s *gmal_entry;
  2214. u32 num_entries;
  2215. u8 *rsp_str;
  2216. bfa_trc(port->fcs, req_status);
  2217. bfa_trc(port->fcs, port->port_cfg.pwwn);
  2218. /*
  2219. * Sanity Checks
  2220. */
  2221. if (req_status != BFA_STATUS_OK) {
  2222. bfa_trc(port->fcs, req_status);
  2223. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2224. return;
  2225. }
  2226. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  2227. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  2228. if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  2229. gmal_resp = (struct fcgs_gmal_resp_s *)(cthdr + 1);
  2230. num_entries = be32_to_cpu(gmal_resp->ms_len);
  2231. if (num_entries == 0) {
  2232. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2233. return;
  2234. }
  2235. /*
  2236. * The response could contain multiple Entries.
  2237. * Entries for SNMP interface, etc.
  2238. * We look for the entry with a telnet prefix.
  2239. * First "http://" entry refers to IP addr
  2240. */
  2241. gmal_entry = (struct fcgs_gmal_entry_s *)gmal_resp->ms_ma;
  2242. while (num_entries > 0) {
  2243. if (strncmp(gmal_entry->prefix,
  2244. CT_GMAL_RESP_PREFIX_HTTP,
  2245. sizeof(gmal_entry->prefix)) == 0) {
  2246. /*
  2247. * if the IP address is terminating with a '/',
  2248. * remove it.
  2249. * Byte 0 consists of the length of the string.
  2250. */
  2251. rsp_str = &(gmal_entry->prefix[0]);
  2252. if (rsp_str[gmal_entry->len-1] == '/')
  2253. rsp_str[gmal_entry->len-1] = 0;
  2254. /* copy IP Address to fabric */
  2255. strncpy(bfa_fcs_lport_get_fabric_ipaddr(port),
  2256. gmal_entry->ip_addr,
  2257. BFA_FCS_FABRIC_IPADDR_SZ);
  2258. break;
  2259. } else {
  2260. --num_entries;
  2261. ++gmal_entry;
  2262. }
  2263. }
  2264. bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK);
  2265. return;
  2266. }
  2267. bfa_trc(port->fcs, cthdr->reason_code);
  2268. bfa_trc(port->fcs, cthdr->exp_code);
  2269. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2270. }
  2271. static void
  2272. bfa_fcs_lport_ms_sm_gfn_sending(struct bfa_fcs_lport_ms_s *ms,
  2273. enum port_ms_event event)
  2274. {
  2275. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2276. bfa_trc(ms->port->fcs, event);
  2277. switch (event) {
  2278. case MSSM_EVENT_FCXP_SENT:
  2279. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn);
  2280. break;
  2281. case MSSM_EVENT_PORT_OFFLINE:
  2282. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2283. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
  2284. &ms->fcxp_wqe);
  2285. break;
  2286. default:
  2287. bfa_sm_fault(ms->port->fcs, event);
  2288. }
  2289. }
  2290. static void
  2291. bfa_fcs_lport_ms_sm_gfn(struct bfa_fcs_lport_ms_s *ms,
  2292. enum port_ms_event event)
  2293. {
  2294. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2295. bfa_trc(ms->port->fcs, event);
  2296. switch (event) {
  2297. case MSSM_EVENT_RSP_ERROR:
  2298. /*
  2299. * Start timer for a delayed retry
  2300. */
  2301. if (ms->retry_cnt++ < BFA_FCS_MS_CMD_MAX_RETRIES) {
  2302. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_retry);
  2303. ms->port->stats.ms_retries++;
  2304. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
  2305. &ms->timer, bfa_fcs_lport_ms_timeout, ms,
  2306. BFA_FCS_RETRY_TIMEOUT);
  2307. } else {
  2308. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online);
  2309. ms->retry_cnt = 0;
  2310. }
  2311. break;
  2312. case MSSM_EVENT_RSP_OK:
  2313. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online);
  2314. break;
  2315. case MSSM_EVENT_PORT_OFFLINE:
  2316. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2317. bfa_fcxp_discard(ms->fcxp);
  2318. break;
  2319. default:
  2320. bfa_sm_fault(ms->port->fcs, event);
  2321. }
  2322. }
  2323. static void
  2324. bfa_fcs_lport_ms_sm_gfn_retry(struct bfa_fcs_lport_ms_s *ms,
  2325. enum port_ms_event event)
  2326. {
  2327. bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
  2328. bfa_trc(ms->port->fcs, event);
  2329. switch (event) {
  2330. case MSSM_EVENT_TIMEOUT:
  2331. /*
  2332. * Retry Timer Expired. Re-send
  2333. */
  2334. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending);
  2335. bfa_fcs_lport_ms_send_gfn(ms, NULL);
  2336. break;
  2337. case MSSM_EVENT_PORT_OFFLINE:
  2338. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2339. bfa_timer_stop(&ms->timer);
  2340. break;
  2341. default:
  2342. bfa_sm_fault(ms->port->fcs, event);
  2343. }
  2344. }
  2345. /*
  2346. * ms_pvt MS local functions
  2347. */
  2348. static void
  2349. bfa_fcs_lport_ms_send_gfn(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  2350. {
  2351. struct bfa_fcs_lport_ms_s *ms = ms_cbarg;
  2352. bfa_fcs_lport_t *port = ms->port;
  2353. struct fchs_s fchs;
  2354. int len;
  2355. struct bfa_fcxp_s *fcxp;
  2356. bfa_trc(port->fcs, port->pid);
  2357. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  2358. if (!fcxp) {
  2359. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
  2360. bfa_fcs_lport_ms_send_gfn, ms);
  2361. return;
  2362. }
  2363. ms->fcxp = fcxp;
  2364. len = fc_gfn_req_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  2365. bfa_fcs_lport_get_fcid(port),
  2366. port->fabric->lps->pr_nwwn);
  2367. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  2368. FC_CLASS_3, len, &fchs,
  2369. bfa_fcs_lport_ms_gfn_response, (void *)ms,
  2370. FC_MAX_PDUSZ, FC_FCCT_TOV);
  2371. bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT);
  2372. }
  2373. static void
  2374. bfa_fcs_lport_ms_gfn_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  2375. void *cbarg, bfa_status_t req_status, u32 rsp_len,
  2376. u32 resid_len, struct fchs_s *rsp_fchs)
  2377. {
  2378. struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg;
  2379. bfa_fcs_lport_t *port = ms->port;
  2380. struct ct_hdr_s *cthdr = NULL;
  2381. wwn_t *gfn_resp;
  2382. bfa_trc(port->fcs, req_status);
  2383. bfa_trc(port->fcs, port->port_cfg.pwwn);
  2384. /*
  2385. * Sanity Checks
  2386. */
  2387. if (req_status != BFA_STATUS_OK) {
  2388. bfa_trc(port->fcs, req_status);
  2389. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2390. return;
  2391. }
  2392. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  2393. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  2394. if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  2395. gfn_resp = (wwn_t *)(cthdr + 1);
  2396. /* check if it has actually changed */
  2397. if ((memcmp((void *)&bfa_fcs_lport_get_fabric_name(port),
  2398. gfn_resp, sizeof(wwn_t)) != 0)) {
  2399. bfa_fcs_fabric_set_fabric_name(port->fabric, *gfn_resp);
  2400. }
  2401. bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK);
  2402. return;
  2403. }
  2404. bfa_trc(port->fcs, cthdr->reason_code);
  2405. bfa_trc(port->fcs, cthdr->exp_code);
  2406. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2407. }
  2408. /*
  2409. * ms_pvt MS local functions
  2410. */
  2411. static void
  2412. bfa_fcs_lport_ms_send_plogi(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  2413. {
  2414. struct bfa_fcs_lport_ms_s *ms = ms_cbarg;
  2415. struct bfa_fcs_lport_s *port = ms->port;
  2416. struct fchs_s fchs;
  2417. int len;
  2418. struct bfa_fcxp_s *fcxp;
  2419. bfa_trc(port->fcs, port->pid);
  2420. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  2421. if (!fcxp) {
  2422. port->stats.ms_plogi_alloc_wait++;
  2423. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
  2424. bfa_fcs_lport_ms_send_plogi, ms);
  2425. return;
  2426. }
  2427. ms->fcxp = fcxp;
  2428. len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  2429. bfa_hton3b(FC_MGMT_SERVER),
  2430. bfa_fcs_lport_get_fcid(port), 0,
  2431. port->port_cfg.pwwn, port->port_cfg.nwwn,
  2432. bfa_fcport_get_maxfrsize(port->fcs->bfa));
  2433. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  2434. FC_CLASS_3, len, &fchs,
  2435. bfa_fcs_lport_ms_plogi_response, (void *)ms,
  2436. FC_MAX_PDUSZ, FC_ELS_TOV);
  2437. port->stats.ms_plogi_sent++;
  2438. bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT);
  2439. }
  2440. static void
  2441. bfa_fcs_lport_ms_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  2442. void *cbarg, bfa_status_t req_status,
  2443. u32 rsp_len, u32 resid_len, struct fchs_s *rsp_fchs)
  2444. {
  2445. struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg;
  2446. struct bfa_fcs_lport_s *port = ms->port;
  2447. struct fc_els_cmd_s *els_cmd;
  2448. struct fc_ls_rjt_s *ls_rjt;
  2449. bfa_trc(port->fcs, req_status);
  2450. bfa_trc(port->fcs, port->port_cfg.pwwn);
  2451. /*
  2452. * Sanity Checks
  2453. */
  2454. if (req_status != BFA_STATUS_OK) {
  2455. port->stats.ms_plogi_rsp_err++;
  2456. bfa_trc(port->fcs, req_status);
  2457. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2458. return;
  2459. }
  2460. els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
  2461. switch (els_cmd->els_code) {
  2462. case FC_ELS_ACC:
  2463. if (rsp_len < sizeof(struct fc_logi_s)) {
  2464. bfa_trc(port->fcs, rsp_len);
  2465. port->stats.ms_plogi_acc_err++;
  2466. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2467. break;
  2468. }
  2469. port->stats.ms_plogi_accepts++;
  2470. bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK);
  2471. break;
  2472. case FC_ELS_LS_RJT:
  2473. ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
  2474. bfa_trc(port->fcs, ls_rjt->reason_code);
  2475. bfa_trc(port->fcs, ls_rjt->reason_code_expl);
  2476. port->stats.ms_rejects++;
  2477. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2478. break;
  2479. default:
  2480. port->stats.ms_plogi_unknown_rsp++;
  2481. bfa_trc(port->fcs, els_cmd->els_code);
  2482. bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
  2483. }
  2484. }
  2485. static void
  2486. bfa_fcs_lport_ms_timeout(void *arg)
  2487. {
  2488. struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) arg;
  2489. ms->port->stats.ms_timeouts++;
  2490. bfa_sm_send_event(ms, MSSM_EVENT_TIMEOUT);
  2491. }
  2492. void
  2493. bfa_fcs_lport_ms_init(struct bfa_fcs_lport_s *port)
  2494. {
  2495. struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port);
  2496. ms->port = port;
  2497. bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
  2498. /*
  2499. * Invoke init routines of sub modules.
  2500. */
  2501. bfa_fcs_lport_fdmi_init(ms);
  2502. }
  2503. void
  2504. bfa_fcs_lport_ms_offline(struct bfa_fcs_lport_s *port)
  2505. {
  2506. struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port);
  2507. ms->port = port;
  2508. bfa_sm_send_event(ms, MSSM_EVENT_PORT_OFFLINE);
  2509. bfa_fcs_lport_fdmi_offline(ms);
  2510. }
  2511. void
  2512. bfa_fcs_lport_ms_online(struct bfa_fcs_lport_s *port)
  2513. {
  2514. struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port);
  2515. ms->port = port;
  2516. bfa_sm_send_event(ms, MSSM_EVENT_PORT_ONLINE);
  2517. }
  2518. void
  2519. bfa_fcs_lport_ms_fabric_rscn(struct bfa_fcs_lport_s *port)
  2520. {
  2521. struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port);
  2522. /* todo. Handle this only when in Online state */
  2523. if (bfa_sm_cmp_state(ms, bfa_fcs_lport_ms_sm_online))
  2524. bfa_sm_send_event(ms, MSSM_EVENT_PORT_FABRIC_RSCN);
  2525. }
  2526. /*
  2527. * @page ns_sm_info VPORT NS State Machine
  2528. *
  2529. * @section ns_sm_interactions VPORT NS State Machine Interactions
  2530. *
  2531. * @section ns_sm VPORT NS State Machine
  2532. * img ns_sm.jpg
  2533. */
  2534. /*
  2535. * forward declarations
  2536. */
  2537. static void bfa_fcs_lport_ns_send_plogi(void *ns_cbarg,
  2538. struct bfa_fcxp_s *fcxp_alloced);
  2539. static void bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg,
  2540. struct bfa_fcxp_s *fcxp_alloced);
  2541. static void bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg,
  2542. struct bfa_fcxp_s *fcxp_alloced);
  2543. static void bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg,
  2544. struct bfa_fcxp_s *fcxp_alloced);
  2545. static void bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg,
  2546. struct bfa_fcxp_s *fcxp_alloced);
  2547. static void bfa_fcs_lport_ns_timeout(void *arg);
  2548. static void bfa_fcs_lport_ns_plogi_response(void *fcsarg,
  2549. struct bfa_fcxp_s *fcxp,
  2550. void *cbarg,
  2551. bfa_status_t req_status,
  2552. u32 rsp_len,
  2553. u32 resid_len,
  2554. struct fchs_s *rsp_fchs);
  2555. static void bfa_fcs_lport_ns_rspn_id_response(void *fcsarg,
  2556. struct bfa_fcxp_s *fcxp,
  2557. void *cbarg,
  2558. bfa_status_t req_status,
  2559. u32 rsp_len,
  2560. u32 resid_len,
  2561. struct fchs_s *rsp_fchs);
  2562. static void bfa_fcs_lport_ns_rft_id_response(void *fcsarg,
  2563. struct bfa_fcxp_s *fcxp,
  2564. void *cbarg,
  2565. bfa_status_t req_status,
  2566. u32 rsp_len,
  2567. u32 resid_len,
  2568. struct fchs_s *rsp_fchs);
  2569. static void bfa_fcs_lport_ns_rff_id_response(void *fcsarg,
  2570. struct bfa_fcxp_s *fcxp,
  2571. void *cbarg,
  2572. bfa_status_t req_status,
  2573. u32 rsp_len,
  2574. u32 resid_len,
  2575. struct fchs_s *rsp_fchs);
  2576. static void bfa_fcs_lport_ns_gid_ft_response(void *fcsarg,
  2577. struct bfa_fcxp_s *fcxp,
  2578. void *cbarg,
  2579. bfa_status_t req_status,
  2580. u32 rsp_len,
  2581. u32 resid_len,
  2582. struct fchs_s *rsp_fchs);
  2583. static void bfa_fcs_lport_ns_process_gidft_pids(
  2584. struct bfa_fcs_lport_s *port,
  2585. u32 *pid_buf, u32 n_pids);
  2586. static void bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port);
  2587. /*
  2588. * fcs_ns_sm FCS nameserver interface state machine
  2589. */
  2590. /*
  2591. * VPort NS State Machine events
  2592. */
  2593. enum vport_ns_event {
  2594. NSSM_EVENT_PORT_ONLINE = 1,
  2595. NSSM_EVENT_PORT_OFFLINE = 2,
  2596. NSSM_EVENT_PLOGI_SENT = 3,
  2597. NSSM_EVENT_RSP_OK = 4,
  2598. NSSM_EVENT_RSP_ERROR = 5,
  2599. NSSM_EVENT_TIMEOUT = 6,
  2600. NSSM_EVENT_NS_QUERY = 7,
  2601. NSSM_EVENT_RSPNID_SENT = 8,
  2602. NSSM_EVENT_RFTID_SENT = 9,
  2603. NSSM_EVENT_RFFID_SENT = 10,
  2604. NSSM_EVENT_GIDFT_SENT = 11,
  2605. };
  2606. static void bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns,
  2607. enum vport_ns_event event);
  2608. static void bfa_fcs_lport_ns_sm_plogi_sending(struct bfa_fcs_lport_ns_s *ns,
  2609. enum vport_ns_event event);
  2610. static void bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s *ns,
  2611. enum vport_ns_event event);
  2612. static void bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s *ns,
  2613. enum vport_ns_event event);
  2614. static void bfa_fcs_lport_ns_sm_sending_rspn_id(
  2615. struct bfa_fcs_lport_ns_s *ns,
  2616. enum vport_ns_event event);
  2617. static void bfa_fcs_lport_ns_sm_rspn_id(struct bfa_fcs_lport_ns_s *ns,
  2618. enum vport_ns_event event);
  2619. static void bfa_fcs_lport_ns_sm_rspn_id_retry(struct bfa_fcs_lport_ns_s *ns,
  2620. enum vport_ns_event event);
  2621. static void bfa_fcs_lport_ns_sm_sending_rft_id(
  2622. struct bfa_fcs_lport_ns_s *ns,
  2623. enum vport_ns_event event);
  2624. static void bfa_fcs_lport_ns_sm_rft_id_retry(struct bfa_fcs_lport_ns_s *ns,
  2625. enum vport_ns_event event);
  2626. static void bfa_fcs_lport_ns_sm_rft_id(struct bfa_fcs_lport_ns_s *ns,
  2627. enum vport_ns_event event);
  2628. static void bfa_fcs_lport_ns_sm_sending_rff_id(
  2629. struct bfa_fcs_lport_ns_s *ns,
  2630. enum vport_ns_event event);
  2631. static void bfa_fcs_lport_ns_sm_rff_id_retry(struct bfa_fcs_lport_ns_s *ns,
  2632. enum vport_ns_event event);
  2633. static void bfa_fcs_lport_ns_sm_rff_id(struct bfa_fcs_lport_ns_s *ns,
  2634. enum vport_ns_event event);
  2635. static void bfa_fcs_lport_ns_sm_sending_gid_ft(
  2636. struct bfa_fcs_lport_ns_s *ns,
  2637. enum vport_ns_event event);
  2638. static void bfa_fcs_lport_ns_sm_gid_ft(struct bfa_fcs_lport_ns_s *ns,
  2639. enum vport_ns_event event);
  2640. static void bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s *ns,
  2641. enum vport_ns_event event);
  2642. static void bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns,
  2643. enum vport_ns_event event);
  2644. /*
  2645. * Start in offline state - awaiting linkup
  2646. */
  2647. static void
  2648. bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns,
  2649. enum vport_ns_event event)
  2650. {
  2651. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2652. bfa_trc(ns->port->fcs, event);
  2653. switch (event) {
  2654. case NSSM_EVENT_PORT_ONLINE:
  2655. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_sending);
  2656. bfa_fcs_lport_ns_send_plogi(ns, NULL);
  2657. break;
  2658. case NSSM_EVENT_PORT_OFFLINE:
  2659. break;
  2660. default:
  2661. bfa_sm_fault(ns->port->fcs, event);
  2662. }
  2663. }
  2664. static void
  2665. bfa_fcs_lport_ns_sm_plogi_sending(struct bfa_fcs_lport_ns_s *ns,
  2666. enum vport_ns_event event)
  2667. {
  2668. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2669. bfa_trc(ns->port->fcs, event);
  2670. switch (event) {
  2671. case NSSM_EVENT_PLOGI_SENT:
  2672. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi);
  2673. break;
  2674. case NSSM_EVENT_PORT_OFFLINE:
  2675. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2676. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2677. &ns->fcxp_wqe);
  2678. break;
  2679. default:
  2680. bfa_sm_fault(ns->port->fcs, event);
  2681. }
  2682. }
  2683. static void
  2684. bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s *ns,
  2685. enum vport_ns_event event)
  2686. {
  2687. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2688. bfa_trc(ns->port->fcs, event);
  2689. switch (event) {
  2690. case NSSM_EVENT_RSP_ERROR:
  2691. /*
  2692. * Start timer for a delayed retry
  2693. */
  2694. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_retry);
  2695. ns->port->stats.ns_retries++;
  2696. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2697. &ns->timer, bfa_fcs_lport_ns_timeout, ns,
  2698. BFA_FCS_RETRY_TIMEOUT);
  2699. break;
  2700. case NSSM_EVENT_RSP_OK:
  2701. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id);
  2702. bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
  2703. break;
  2704. case NSSM_EVENT_PORT_OFFLINE:
  2705. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2706. bfa_fcxp_discard(ns->fcxp);
  2707. break;
  2708. default:
  2709. bfa_sm_fault(ns->port->fcs, event);
  2710. }
  2711. }
  2712. static void
  2713. bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s *ns,
  2714. enum vport_ns_event event)
  2715. {
  2716. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2717. bfa_trc(ns->port->fcs, event);
  2718. switch (event) {
  2719. case NSSM_EVENT_TIMEOUT:
  2720. /*
  2721. * Retry Timer Expired. Re-send
  2722. */
  2723. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_sending);
  2724. bfa_fcs_lport_ns_send_plogi(ns, NULL);
  2725. break;
  2726. case NSSM_EVENT_PORT_OFFLINE:
  2727. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2728. bfa_timer_stop(&ns->timer);
  2729. break;
  2730. default:
  2731. bfa_sm_fault(ns->port->fcs, event);
  2732. }
  2733. }
  2734. static void
  2735. bfa_fcs_lport_ns_sm_sending_rspn_id(struct bfa_fcs_lport_ns_s *ns,
  2736. enum vport_ns_event event)
  2737. {
  2738. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2739. bfa_trc(ns->port->fcs, event);
  2740. switch (event) {
  2741. case NSSM_EVENT_RSPNID_SENT:
  2742. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rspn_id);
  2743. break;
  2744. case NSSM_EVENT_PORT_OFFLINE:
  2745. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2746. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2747. &ns->fcxp_wqe);
  2748. break;
  2749. default:
  2750. bfa_sm_fault(ns->port->fcs, event);
  2751. }
  2752. }
  2753. static void
  2754. bfa_fcs_lport_ns_sm_rspn_id(struct bfa_fcs_lport_ns_s *ns,
  2755. enum vport_ns_event event)
  2756. {
  2757. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2758. bfa_trc(ns->port->fcs, event);
  2759. switch (event) {
  2760. case NSSM_EVENT_RSP_ERROR:
  2761. /*
  2762. * Start timer for a delayed retry
  2763. */
  2764. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rspn_id_retry);
  2765. ns->port->stats.ns_retries++;
  2766. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2767. &ns->timer, bfa_fcs_lport_ns_timeout, ns,
  2768. BFA_FCS_RETRY_TIMEOUT);
  2769. break;
  2770. case NSSM_EVENT_RSP_OK:
  2771. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rft_id);
  2772. bfa_fcs_lport_ns_send_rft_id(ns, NULL);
  2773. break;
  2774. case NSSM_EVENT_PORT_OFFLINE:
  2775. bfa_fcxp_discard(ns->fcxp);
  2776. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2777. break;
  2778. default:
  2779. bfa_sm_fault(ns->port->fcs, event);
  2780. }
  2781. }
  2782. static void
  2783. bfa_fcs_lport_ns_sm_rspn_id_retry(struct bfa_fcs_lport_ns_s *ns,
  2784. enum vport_ns_event event)
  2785. {
  2786. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2787. bfa_trc(ns->port->fcs, event);
  2788. switch (event) {
  2789. case NSSM_EVENT_TIMEOUT:
  2790. /*
  2791. * Retry Timer Expired. Re-send
  2792. */
  2793. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id);
  2794. bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
  2795. break;
  2796. case NSSM_EVENT_PORT_OFFLINE:
  2797. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2798. bfa_timer_stop(&ns->timer);
  2799. break;
  2800. default:
  2801. bfa_sm_fault(ns->port->fcs, event);
  2802. }
  2803. }
  2804. static void
  2805. bfa_fcs_lport_ns_sm_sending_rft_id(struct bfa_fcs_lport_ns_s *ns,
  2806. enum vport_ns_event event)
  2807. {
  2808. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2809. bfa_trc(ns->port->fcs, event);
  2810. switch (event) {
  2811. case NSSM_EVENT_RFTID_SENT:
  2812. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rft_id);
  2813. break;
  2814. case NSSM_EVENT_PORT_OFFLINE:
  2815. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2816. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2817. &ns->fcxp_wqe);
  2818. break;
  2819. default:
  2820. bfa_sm_fault(ns->port->fcs, event);
  2821. }
  2822. }
  2823. static void
  2824. bfa_fcs_lport_ns_sm_rft_id(struct bfa_fcs_lport_ns_s *ns,
  2825. enum vport_ns_event event)
  2826. {
  2827. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2828. bfa_trc(ns->port->fcs, event);
  2829. switch (event) {
  2830. case NSSM_EVENT_RSP_OK:
  2831. /* Now move to register FC4 Features */
  2832. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rff_id);
  2833. bfa_fcs_lport_ns_send_rff_id(ns, NULL);
  2834. break;
  2835. case NSSM_EVENT_RSP_ERROR:
  2836. /*
  2837. * Start timer for a delayed retry
  2838. */
  2839. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rft_id_retry);
  2840. ns->port->stats.ns_retries++;
  2841. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2842. &ns->timer, bfa_fcs_lport_ns_timeout, ns,
  2843. BFA_FCS_RETRY_TIMEOUT);
  2844. break;
  2845. case NSSM_EVENT_PORT_OFFLINE:
  2846. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2847. bfa_fcxp_discard(ns->fcxp);
  2848. break;
  2849. default:
  2850. bfa_sm_fault(ns->port->fcs, event);
  2851. }
  2852. }
  2853. static void
  2854. bfa_fcs_lport_ns_sm_rft_id_retry(struct bfa_fcs_lport_ns_s *ns,
  2855. enum vport_ns_event event)
  2856. {
  2857. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2858. bfa_trc(ns->port->fcs, event);
  2859. switch (event) {
  2860. case NSSM_EVENT_TIMEOUT:
  2861. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rft_id);
  2862. bfa_fcs_lport_ns_send_rft_id(ns, NULL);
  2863. break;
  2864. case NSSM_EVENT_PORT_OFFLINE:
  2865. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2866. bfa_timer_stop(&ns->timer);
  2867. break;
  2868. default:
  2869. bfa_sm_fault(ns->port->fcs, event);
  2870. }
  2871. }
  2872. static void
  2873. bfa_fcs_lport_ns_sm_sending_rff_id(struct bfa_fcs_lport_ns_s *ns,
  2874. enum vport_ns_event event)
  2875. {
  2876. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2877. bfa_trc(ns->port->fcs, event);
  2878. switch (event) {
  2879. case NSSM_EVENT_RFFID_SENT:
  2880. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rff_id);
  2881. break;
  2882. case NSSM_EVENT_PORT_OFFLINE:
  2883. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2884. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2885. &ns->fcxp_wqe);
  2886. break;
  2887. default:
  2888. bfa_sm_fault(ns->port->fcs, event);
  2889. }
  2890. }
  2891. static void
  2892. bfa_fcs_lport_ns_sm_rff_id(struct bfa_fcs_lport_ns_s *ns,
  2893. enum vport_ns_event event)
  2894. {
  2895. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2896. bfa_trc(ns->port->fcs, event);
  2897. switch (event) {
  2898. case NSSM_EVENT_RSP_OK:
  2899. /*
  2900. * If min cfg mode is enabled, we donot initiate rport
  2901. * discovery with the fabric. Instead, we will retrieve the
  2902. * boot targets from HAL/FW.
  2903. */
  2904. if (__fcs_min_cfg(ns->port->fcs)) {
  2905. bfa_fcs_lport_ns_boot_target_disc(ns->port);
  2906. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_online);
  2907. return;
  2908. }
  2909. /*
  2910. * If the port role is Initiator Mode issue NS query.
  2911. * If it is Target Mode, skip this and go to online.
  2912. */
  2913. if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) {
  2914. bfa_sm_set_state(ns,
  2915. bfa_fcs_lport_ns_sm_sending_gid_ft);
  2916. bfa_fcs_lport_ns_send_gid_ft(ns, NULL);
  2917. }
  2918. /*
  2919. * kick off mgmt srvr state machine
  2920. */
  2921. bfa_fcs_lport_ms_online(ns->port);
  2922. break;
  2923. case NSSM_EVENT_RSP_ERROR:
  2924. /*
  2925. * Start timer for a delayed retry
  2926. */
  2927. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rff_id_retry);
  2928. ns->port->stats.ns_retries++;
  2929. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2930. &ns->timer, bfa_fcs_lport_ns_timeout, ns,
  2931. BFA_FCS_RETRY_TIMEOUT);
  2932. break;
  2933. case NSSM_EVENT_PORT_OFFLINE:
  2934. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2935. bfa_fcxp_discard(ns->fcxp);
  2936. break;
  2937. default:
  2938. bfa_sm_fault(ns->port->fcs, event);
  2939. }
  2940. }
  2941. static void
  2942. bfa_fcs_lport_ns_sm_rff_id_retry(struct bfa_fcs_lport_ns_s *ns,
  2943. enum vport_ns_event event)
  2944. {
  2945. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2946. bfa_trc(ns->port->fcs, event);
  2947. switch (event) {
  2948. case NSSM_EVENT_TIMEOUT:
  2949. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rff_id);
  2950. bfa_fcs_lport_ns_send_rff_id(ns, NULL);
  2951. break;
  2952. case NSSM_EVENT_PORT_OFFLINE:
  2953. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2954. bfa_timer_stop(&ns->timer);
  2955. break;
  2956. default:
  2957. bfa_sm_fault(ns->port->fcs, event);
  2958. }
  2959. }
  2960. static void
  2961. bfa_fcs_lport_ns_sm_sending_gid_ft(struct bfa_fcs_lport_ns_s *ns,
  2962. enum vport_ns_event event)
  2963. {
  2964. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2965. bfa_trc(ns->port->fcs, event);
  2966. switch (event) {
  2967. case NSSM_EVENT_GIDFT_SENT:
  2968. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_gid_ft);
  2969. break;
  2970. case NSSM_EVENT_PORT_OFFLINE:
  2971. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  2972. bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2973. &ns->fcxp_wqe);
  2974. break;
  2975. default:
  2976. bfa_sm_fault(ns->port->fcs, event);
  2977. }
  2978. }
  2979. static void
  2980. bfa_fcs_lport_ns_sm_gid_ft(struct bfa_fcs_lport_ns_s *ns,
  2981. enum vport_ns_event event)
  2982. {
  2983. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  2984. bfa_trc(ns->port->fcs, event);
  2985. switch (event) {
  2986. case NSSM_EVENT_RSP_OK:
  2987. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_online);
  2988. break;
  2989. case NSSM_EVENT_RSP_ERROR:
  2990. /*
  2991. * TBD: for certain reject codes, we don't need to retry
  2992. */
  2993. /*
  2994. * Start timer for a delayed retry
  2995. */
  2996. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_gid_ft_retry);
  2997. ns->port->stats.ns_retries++;
  2998. bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
  2999. &ns->timer, bfa_fcs_lport_ns_timeout, ns,
  3000. BFA_FCS_RETRY_TIMEOUT);
  3001. break;
  3002. case NSSM_EVENT_PORT_OFFLINE:
  3003. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  3004. bfa_fcxp_discard(ns->fcxp);
  3005. break;
  3006. case NSSM_EVENT_NS_QUERY:
  3007. break;
  3008. default:
  3009. bfa_sm_fault(ns->port->fcs, event);
  3010. }
  3011. }
  3012. static void
  3013. bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s *ns,
  3014. enum vport_ns_event event)
  3015. {
  3016. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  3017. bfa_trc(ns->port->fcs, event);
  3018. switch (event) {
  3019. case NSSM_EVENT_TIMEOUT:
  3020. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_gid_ft);
  3021. bfa_fcs_lport_ns_send_gid_ft(ns, NULL);
  3022. break;
  3023. case NSSM_EVENT_PORT_OFFLINE:
  3024. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  3025. bfa_timer_stop(&ns->timer);
  3026. break;
  3027. default:
  3028. bfa_sm_fault(ns->port->fcs, event);
  3029. }
  3030. }
  3031. static void
  3032. bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns,
  3033. enum vport_ns_event event)
  3034. {
  3035. bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
  3036. bfa_trc(ns->port->fcs, event);
  3037. switch (event) {
  3038. case NSSM_EVENT_PORT_OFFLINE:
  3039. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  3040. break;
  3041. case NSSM_EVENT_NS_QUERY:
  3042. /*
  3043. * If the port role is Initiator Mode issue NS query.
  3044. * If it is Target Mode, skip this and go to online.
  3045. */
  3046. if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) {
  3047. bfa_sm_set_state(ns,
  3048. bfa_fcs_lport_ns_sm_sending_gid_ft);
  3049. bfa_fcs_lport_ns_send_gid_ft(ns, NULL);
  3050. };
  3051. break;
  3052. default:
  3053. bfa_sm_fault(ns->port->fcs, event);
  3054. }
  3055. }
  3056. /*
  3057. * ns_pvt Nameserver local functions
  3058. */
  3059. static void
  3060. bfa_fcs_lport_ns_send_plogi(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  3061. {
  3062. struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
  3063. struct bfa_fcs_lport_s *port = ns->port;
  3064. struct fchs_s fchs;
  3065. int len;
  3066. struct bfa_fcxp_s *fcxp;
  3067. bfa_trc(port->fcs, port->pid);
  3068. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  3069. if (!fcxp) {
  3070. port->stats.ns_plogi_alloc_wait++;
  3071. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
  3072. bfa_fcs_lport_ns_send_plogi, ns);
  3073. return;
  3074. }
  3075. ns->fcxp = fcxp;
  3076. len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  3077. bfa_hton3b(FC_NAME_SERVER),
  3078. bfa_fcs_lport_get_fcid(port), 0,
  3079. port->port_cfg.pwwn, port->port_cfg.nwwn,
  3080. bfa_fcport_get_maxfrsize(port->fcs->bfa));
  3081. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  3082. FC_CLASS_3, len, &fchs,
  3083. bfa_fcs_lport_ns_plogi_response, (void *)ns,
  3084. FC_MAX_PDUSZ, FC_ELS_TOV);
  3085. port->stats.ns_plogi_sent++;
  3086. bfa_sm_send_event(ns, NSSM_EVENT_PLOGI_SENT);
  3087. }
  3088. static void
  3089. bfa_fcs_lport_ns_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  3090. void *cbarg, bfa_status_t req_status, u32 rsp_len,
  3091. u32 resid_len, struct fchs_s *rsp_fchs)
  3092. {
  3093. struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
  3094. struct bfa_fcs_lport_s *port = ns->port;
  3095. /* struct fc_logi_s *plogi_resp; */
  3096. struct fc_els_cmd_s *els_cmd;
  3097. struct fc_ls_rjt_s *ls_rjt;
  3098. bfa_trc(port->fcs, req_status);
  3099. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3100. /*
  3101. * Sanity Checks
  3102. */
  3103. if (req_status != BFA_STATUS_OK) {
  3104. bfa_trc(port->fcs, req_status);
  3105. port->stats.ns_plogi_rsp_err++;
  3106. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3107. return;
  3108. }
  3109. els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
  3110. switch (els_cmd->els_code) {
  3111. case FC_ELS_ACC:
  3112. if (rsp_len < sizeof(struct fc_logi_s)) {
  3113. bfa_trc(port->fcs, rsp_len);
  3114. port->stats.ns_plogi_acc_err++;
  3115. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3116. break;
  3117. }
  3118. port->stats.ns_plogi_accepts++;
  3119. bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
  3120. break;
  3121. case FC_ELS_LS_RJT:
  3122. ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
  3123. bfa_trc(port->fcs, ls_rjt->reason_code);
  3124. bfa_trc(port->fcs, ls_rjt->reason_code_expl);
  3125. port->stats.ns_rejects++;
  3126. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3127. break;
  3128. default:
  3129. port->stats.ns_plogi_unknown_rsp++;
  3130. bfa_trc(port->fcs, els_cmd->els_code);
  3131. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3132. }
  3133. }
  3134. /*
  3135. * Register the symbolic port name.
  3136. */
  3137. static void
  3138. bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  3139. {
  3140. struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
  3141. struct bfa_fcs_lport_s *port = ns->port;
  3142. struct fchs_s fchs;
  3143. int len;
  3144. struct bfa_fcxp_s *fcxp;
  3145. u8 symbl[256];
  3146. u8 *psymbl = &symbl[0];
  3147. memset(symbl, 0, sizeof(symbl));
  3148. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3149. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  3150. if (!fcxp) {
  3151. port->stats.ns_rspnid_alloc_wait++;
  3152. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
  3153. bfa_fcs_lport_ns_send_rspn_id, ns);
  3154. return;
  3155. }
  3156. ns->fcxp = fcxp;
  3157. /*
  3158. * for V-Port, form a Port Symbolic Name
  3159. */
  3160. if (port->vport) {
  3161. /*
  3162. * For Vports, we append the vport's port symbolic name
  3163. * to that of the base port.
  3164. */
  3165. strncpy((char *)psymbl,
  3166. (char *) &
  3167. (bfa_fcs_lport_get_psym_name
  3168. (bfa_fcs_get_base_port(port->fcs))),
  3169. strlen((char *) &
  3170. bfa_fcs_lport_get_psym_name(bfa_fcs_get_base_port
  3171. (port->fcs))));
  3172. /* Ensure we have a null terminating string. */
  3173. ((char *)psymbl)[strlen((char *) &
  3174. bfa_fcs_lport_get_psym_name(bfa_fcs_get_base_port
  3175. (port->fcs)))] = 0;
  3176. strncat((char *)psymbl,
  3177. (char *) &(bfa_fcs_lport_get_psym_name(port)),
  3178. strlen((char *) &bfa_fcs_lport_get_psym_name(port)));
  3179. } else {
  3180. psymbl = (u8 *) &(bfa_fcs_lport_get_psym_name(port));
  3181. }
  3182. len = fc_rspnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  3183. bfa_fcs_lport_get_fcid(port), 0, psymbl);
  3184. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  3185. FC_CLASS_3, len, &fchs,
  3186. bfa_fcs_lport_ns_rspn_id_response, (void *)ns,
  3187. FC_MAX_PDUSZ, FC_FCCT_TOV);
  3188. port->stats.ns_rspnid_sent++;
  3189. bfa_sm_send_event(ns, NSSM_EVENT_RSPNID_SENT);
  3190. }
  3191. static void
  3192. bfa_fcs_lport_ns_rspn_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  3193. void *cbarg, bfa_status_t req_status,
  3194. u32 rsp_len, u32 resid_len,
  3195. struct fchs_s *rsp_fchs)
  3196. {
  3197. struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
  3198. struct bfa_fcs_lport_s *port = ns->port;
  3199. struct ct_hdr_s *cthdr = NULL;
  3200. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3201. /*
  3202. * Sanity Checks
  3203. */
  3204. if (req_status != BFA_STATUS_OK) {
  3205. bfa_trc(port->fcs, req_status);
  3206. port->stats.ns_rspnid_rsp_err++;
  3207. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3208. return;
  3209. }
  3210. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  3211. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  3212. if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  3213. port->stats.ns_rspnid_accepts++;
  3214. bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
  3215. return;
  3216. }
  3217. port->stats.ns_rspnid_rejects++;
  3218. bfa_trc(port->fcs, cthdr->reason_code);
  3219. bfa_trc(port->fcs, cthdr->exp_code);
  3220. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3221. }
  3222. /*
  3223. * Register FC4-Types
  3224. */
  3225. static void
  3226. bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  3227. {
  3228. struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
  3229. struct bfa_fcs_lport_s *port = ns->port;
  3230. struct fchs_s fchs;
  3231. int len;
  3232. struct bfa_fcxp_s *fcxp;
  3233. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3234. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  3235. if (!fcxp) {
  3236. port->stats.ns_rftid_alloc_wait++;
  3237. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
  3238. bfa_fcs_lport_ns_send_rft_id, ns);
  3239. return;
  3240. }
  3241. ns->fcxp = fcxp;
  3242. len = fc_rftid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  3243. bfa_fcs_lport_get_fcid(port), 0, port->port_cfg.roles);
  3244. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  3245. FC_CLASS_3, len, &fchs,
  3246. bfa_fcs_lport_ns_rft_id_response, (void *)ns,
  3247. FC_MAX_PDUSZ, FC_FCCT_TOV);
  3248. port->stats.ns_rftid_sent++;
  3249. bfa_sm_send_event(ns, NSSM_EVENT_RFTID_SENT);
  3250. }
  3251. static void
  3252. bfa_fcs_lport_ns_rft_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  3253. void *cbarg, bfa_status_t req_status,
  3254. u32 rsp_len, u32 resid_len,
  3255. struct fchs_s *rsp_fchs)
  3256. {
  3257. struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
  3258. struct bfa_fcs_lport_s *port = ns->port;
  3259. struct ct_hdr_s *cthdr = NULL;
  3260. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3261. /*
  3262. * Sanity Checks
  3263. */
  3264. if (req_status != BFA_STATUS_OK) {
  3265. bfa_trc(port->fcs, req_status);
  3266. port->stats.ns_rftid_rsp_err++;
  3267. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3268. return;
  3269. }
  3270. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  3271. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  3272. if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  3273. port->stats.ns_rftid_accepts++;
  3274. bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
  3275. return;
  3276. }
  3277. port->stats.ns_rftid_rejects++;
  3278. bfa_trc(port->fcs, cthdr->reason_code);
  3279. bfa_trc(port->fcs, cthdr->exp_code);
  3280. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3281. }
  3282. /*
  3283. * Register FC4-Features : Should be done after RFT_ID
  3284. */
  3285. static void
  3286. bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  3287. {
  3288. struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
  3289. struct bfa_fcs_lport_s *port = ns->port;
  3290. struct fchs_s fchs;
  3291. int len;
  3292. struct bfa_fcxp_s *fcxp;
  3293. u8 fc4_ftrs = 0;
  3294. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3295. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  3296. if (!fcxp) {
  3297. port->stats.ns_rffid_alloc_wait++;
  3298. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
  3299. bfa_fcs_lport_ns_send_rff_id, ns);
  3300. return;
  3301. }
  3302. ns->fcxp = fcxp;
  3303. if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port))
  3304. fc4_ftrs = FC_GS_FCP_FC4_FEATURE_INITIATOR;
  3305. len = fc_rffid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  3306. bfa_fcs_lport_get_fcid(port), 0,
  3307. FC_TYPE_FCP, fc4_ftrs);
  3308. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  3309. FC_CLASS_3, len, &fchs,
  3310. bfa_fcs_lport_ns_rff_id_response, (void *)ns,
  3311. FC_MAX_PDUSZ, FC_FCCT_TOV);
  3312. port->stats.ns_rffid_sent++;
  3313. bfa_sm_send_event(ns, NSSM_EVENT_RFFID_SENT);
  3314. }
  3315. static void
  3316. bfa_fcs_lport_ns_rff_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  3317. void *cbarg, bfa_status_t req_status,
  3318. u32 rsp_len, u32 resid_len,
  3319. struct fchs_s *rsp_fchs)
  3320. {
  3321. struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
  3322. struct bfa_fcs_lport_s *port = ns->port;
  3323. struct ct_hdr_s *cthdr = NULL;
  3324. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3325. /*
  3326. * Sanity Checks
  3327. */
  3328. if (req_status != BFA_STATUS_OK) {
  3329. bfa_trc(port->fcs, req_status);
  3330. port->stats.ns_rffid_rsp_err++;
  3331. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3332. return;
  3333. }
  3334. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  3335. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  3336. if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  3337. port->stats.ns_rffid_accepts++;
  3338. bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
  3339. return;
  3340. }
  3341. port->stats.ns_rffid_rejects++;
  3342. bfa_trc(port->fcs, cthdr->reason_code);
  3343. bfa_trc(port->fcs, cthdr->exp_code);
  3344. if (cthdr->reason_code == CT_RSN_NOT_SUPP) {
  3345. /* if this command is not supported, we don't retry */
  3346. bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
  3347. } else
  3348. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3349. }
  3350. /*
  3351. * Query Fabric for FC4-Types Devices.
  3352. *
  3353. * TBD : Need to use a local (FCS private) response buffer, since the response
  3354. * can be larger than 2K.
  3355. */
  3356. static void
  3357. bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  3358. {
  3359. struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
  3360. struct bfa_fcs_lport_s *port = ns->port;
  3361. struct fchs_s fchs;
  3362. int len;
  3363. struct bfa_fcxp_s *fcxp;
  3364. bfa_trc(port->fcs, port->pid);
  3365. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  3366. if (!fcxp) {
  3367. port->stats.ns_gidft_alloc_wait++;
  3368. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
  3369. bfa_fcs_lport_ns_send_gid_ft, ns);
  3370. return;
  3371. }
  3372. ns->fcxp = fcxp;
  3373. /*
  3374. * This query is only initiated for FCP initiator mode.
  3375. */
  3376. len = fc_gid_ft_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  3377. ns->port->pid, FC_TYPE_FCP);
  3378. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  3379. FC_CLASS_3, len, &fchs,
  3380. bfa_fcs_lport_ns_gid_ft_response, (void *)ns,
  3381. bfa_fcxp_get_maxrsp(port->fcs->bfa), FC_FCCT_TOV);
  3382. port->stats.ns_gidft_sent++;
  3383. bfa_sm_send_event(ns, NSSM_EVENT_GIDFT_SENT);
  3384. }
  3385. static void
  3386. bfa_fcs_lport_ns_gid_ft_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  3387. void *cbarg, bfa_status_t req_status,
  3388. u32 rsp_len, u32 resid_len,
  3389. struct fchs_s *rsp_fchs)
  3390. {
  3391. struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
  3392. struct bfa_fcs_lport_s *port = ns->port;
  3393. struct ct_hdr_s *cthdr = NULL;
  3394. u32 n_pids;
  3395. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3396. /*
  3397. * Sanity Checks
  3398. */
  3399. if (req_status != BFA_STATUS_OK) {
  3400. bfa_trc(port->fcs, req_status);
  3401. port->stats.ns_gidft_rsp_err++;
  3402. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3403. return;
  3404. }
  3405. if (resid_len != 0) {
  3406. /*
  3407. * TBD : we will need to allocate a larger buffer & retry the
  3408. * command
  3409. */
  3410. bfa_trc(port->fcs, rsp_len);
  3411. bfa_trc(port->fcs, resid_len);
  3412. return;
  3413. }
  3414. cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
  3415. cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
  3416. switch (cthdr->cmd_rsp_code) {
  3417. case CT_RSP_ACCEPT:
  3418. port->stats.ns_gidft_accepts++;
  3419. n_pids = (fc_get_ctresp_pyld_len(rsp_len) / sizeof(u32));
  3420. bfa_trc(port->fcs, n_pids);
  3421. bfa_fcs_lport_ns_process_gidft_pids(port,
  3422. (u32 *) (cthdr + 1),
  3423. n_pids);
  3424. bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
  3425. break;
  3426. case CT_RSP_REJECT:
  3427. /*
  3428. * Check the reason code & explanation.
  3429. * There may not have been any FC4 devices in the fabric
  3430. */
  3431. port->stats.ns_gidft_rejects++;
  3432. bfa_trc(port->fcs, cthdr->reason_code);
  3433. bfa_trc(port->fcs, cthdr->exp_code);
  3434. if ((cthdr->reason_code == CT_RSN_UNABLE_TO_PERF)
  3435. && (cthdr->exp_code == CT_NS_EXP_FT_NOT_REG)) {
  3436. bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
  3437. } else {
  3438. /*
  3439. * for all other errors, retry
  3440. */
  3441. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3442. }
  3443. break;
  3444. default:
  3445. port->stats.ns_gidft_unknown_rsp++;
  3446. bfa_trc(port->fcs, cthdr->cmd_rsp_code);
  3447. bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
  3448. }
  3449. }
  3450. /*
  3451. * This routine will be called by bfa_timer on timer timeouts.
  3452. *
  3453. * param[in] port - pointer to bfa_fcs_lport_t.
  3454. *
  3455. * return
  3456. * void
  3457. *
  3458. * Special Considerations:
  3459. *
  3460. * note
  3461. */
  3462. static void
  3463. bfa_fcs_lport_ns_timeout(void *arg)
  3464. {
  3465. struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) arg;
  3466. ns->port->stats.ns_timeouts++;
  3467. bfa_sm_send_event(ns, NSSM_EVENT_TIMEOUT);
  3468. }
  3469. /*
  3470. * Process the PID list in GID_FT response
  3471. */
  3472. static void
  3473. bfa_fcs_lport_ns_process_gidft_pids(struct bfa_fcs_lport_s *port, u32 *pid_buf,
  3474. u32 n_pids)
  3475. {
  3476. struct fcgs_gidft_resp_s *gidft_entry;
  3477. struct bfa_fcs_rport_s *rport;
  3478. u32 ii;
  3479. for (ii = 0; ii < n_pids; ii++) {
  3480. gidft_entry = (struct fcgs_gidft_resp_s *) &pid_buf[ii];
  3481. if (gidft_entry->pid == port->pid)
  3482. continue;
  3483. /*
  3484. * Check if this rport already exists
  3485. */
  3486. rport = bfa_fcs_lport_get_rport_by_pid(port, gidft_entry->pid);
  3487. if (rport == NULL) {
  3488. /*
  3489. * this is a new device. create rport
  3490. */
  3491. rport = bfa_fcs_rport_create(port, gidft_entry->pid);
  3492. } else {
  3493. /*
  3494. * this rport already exists
  3495. */
  3496. bfa_fcs_rport_scn(rport);
  3497. }
  3498. bfa_trc(port->fcs, gidft_entry->pid);
  3499. /*
  3500. * if the last entry bit is set, bail out.
  3501. */
  3502. if (gidft_entry->last)
  3503. return;
  3504. }
  3505. }
  3506. /*
  3507. * fcs_ns_public FCS nameserver public interfaces
  3508. */
  3509. /*
  3510. * Functions called by port/fab.
  3511. * These will send relevant Events to the ns state machine.
  3512. */
  3513. void
  3514. bfa_fcs_lport_ns_init(struct bfa_fcs_lport_s *port)
  3515. {
  3516. struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
  3517. ns->port = port;
  3518. bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
  3519. }
  3520. void
  3521. bfa_fcs_lport_ns_offline(struct bfa_fcs_lport_s *port)
  3522. {
  3523. struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
  3524. ns->port = port;
  3525. bfa_sm_send_event(ns, NSSM_EVENT_PORT_OFFLINE);
  3526. }
  3527. void
  3528. bfa_fcs_lport_ns_online(struct bfa_fcs_lport_s *port)
  3529. {
  3530. struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
  3531. ns->port = port;
  3532. bfa_sm_send_event(ns, NSSM_EVENT_PORT_ONLINE);
  3533. }
  3534. void
  3535. bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port)
  3536. {
  3537. struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
  3538. bfa_trc(port->fcs, port->pid);
  3539. bfa_sm_send_event(ns, NSSM_EVENT_NS_QUERY);
  3540. }
  3541. static void
  3542. bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port)
  3543. {
  3544. struct bfa_fcs_rport_s *rport;
  3545. u8 nwwns;
  3546. wwn_t wwns[BFA_PREBOOT_BOOTLUN_MAX];
  3547. int ii;
  3548. bfa_iocfc_get_bootwwns(port->fcs->bfa, &nwwns, wwns);
  3549. for (ii = 0 ; ii < nwwns; ++ii) {
  3550. rport = bfa_fcs_rport_create_by_wwn(port, wwns[ii]);
  3551. WARN_ON(!rport);
  3552. }
  3553. }
  3554. /*
  3555. * FCS SCN
  3556. */
  3557. #define FC_QOS_RSCN_EVENT 0x0c
  3558. #define FC_FABRIC_NAME_RSCN_EVENT 0x0d
  3559. /*
  3560. * forward declarations
  3561. */
  3562. static void bfa_fcs_lport_scn_send_scr(void *scn_cbarg,
  3563. struct bfa_fcxp_s *fcxp_alloced);
  3564. static void bfa_fcs_lport_scn_scr_response(void *fcsarg,
  3565. struct bfa_fcxp_s *fcxp,
  3566. void *cbarg,
  3567. bfa_status_t req_status,
  3568. u32 rsp_len,
  3569. u32 resid_len,
  3570. struct fchs_s *rsp_fchs);
  3571. static void bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s *port,
  3572. struct fchs_s *rx_fchs);
  3573. static void bfa_fcs_lport_scn_timeout(void *arg);
  3574. /*
  3575. * fcs_scm_sm FCS SCN state machine
  3576. */
  3577. /*
  3578. * VPort SCN State Machine events
  3579. */
  3580. enum port_scn_event {
  3581. SCNSM_EVENT_PORT_ONLINE = 1,
  3582. SCNSM_EVENT_PORT_OFFLINE = 2,
  3583. SCNSM_EVENT_RSP_OK = 3,
  3584. SCNSM_EVENT_RSP_ERROR = 4,
  3585. SCNSM_EVENT_TIMEOUT = 5,
  3586. SCNSM_EVENT_SCR_SENT = 6,
  3587. };
  3588. static void bfa_fcs_lport_scn_sm_offline(struct bfa_fcs_lport_scn_s *scn,
  3589. enum port_scn_event event);
  3590. static void bfa_fcs_lport_scn_sm_sending_scr(
  3591. struct bfa_fcs_lport_scn_s *scn,
  3592. enum port_scn_event event);
  3593. static void bfa_fcs_lport_scn_sm_scr(struct bfa_fcs_lport_scn_s *scn,
  3594. enum port_scn_event event);
  3595. static void bfa_fcs_lport_scn_sm_scr_retry(struct bfa_fcs_lport_scn_s *scn,
  3596. enum port_scn_event event);
  3597. static void bfa_fcs_lport_scn_sm_online(struct bfa_fcs_lport_scn_s *scn,
  3598. enum port_scn_event event);
  3599. /*
  3600. * Starting state - awaiting link up.
  3601. */
  3602. static void
  3603. bfa_fcs_lport_scn_sm_offline(struct bfa_fcs_lport_scn_s *scn,
  3604. enum port_scn_event event)
  3605. {
  3606. switch (event) {
  3607. case SCNSM_EVENT_PORT_ONLINE:
  3608. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_sending_scr);
  3609. bfa_fcs_lport_scn_send_scr(scn, NULL);
  3610. break;
  3611. case SCNSM_EVENT_PORT_OFFLINE:
  3612. break;
  3613. default:
  3614. bfa_sm_fault(scn->port->fcs, event);
  3615. }
  3616. }
  3617. static void
  3618. bfa_fcs_lport_scn_sm_sending_scr(struct bfa_fcs_lport_scn_s *scn,
  3619. enum port_scn_event event)
  3620. {
  3621. switch (event) {
  3622. case SCNSM_EVENT_SCR_SENT:
  3623. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_scr);
  3624. break;
  3625. case SCNSM_EVENT_PORT_OFFLINE:
  3626. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
  3627. bfa_fcxp_walloc_cancel(scn->port->fcs->bfa, &scn->fcxp_wqe);
  3628. break;
  3629. default:
  3630. bfa_sm_fault(scn->port->fcs, event);
  3631. }
  3632. }
  3633. static void
  3634. bfa_fcs_lport_scn_sm_scr(struct bfa_fcs_lport_scn_s *scn,
  3635. enum port_scn_event event)
  3636. {
  3637. struct bfa_fcs_lport_s *port = scn->port;
  3638. switch (event) {
  3639. case SCNSM_EVENT_RSP_OK:
  3640. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_online);
  3641. break;
  3642. case SCNSM_EVENT_RSP_ERROR:
  3643. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_scr_retry);
  3644. bfa_timer_start(port->fcs->bfa, &scn->timer,
  3645. bfa_fcs_lport_scn_timeout, scn,
  3646. BFA_FCS_RETRY_TIMEOUT);
  3647. break;
  3648. case SCNSM_EVENT_PORT_OFFLINE:
  3649. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
  3650. bfa_fcxp_discard(scn->fcxp);
  3651. break;
  3652. default:
  3653. bfa_sm_fault(port->fcs, event);
  3654. }
  3655. }
  3656. static void
  3657. bfa_fcs_lport_scn_sm_scr_retry(struct bfa_fcs_lport_scn_s *scn,
  3658. enum port_scn_event event)
  3659. {
  3660. switch (event) {
  3661. case SCNSM_EVENT_TIMEOUT:
  3662. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_sending_scr);
  3663. bfa_fcs_lport_scn_send_scr(scn, NULL);
  3664. break;
  3665. case SCNSM_EVENT_PORT_OFFLINE:
  3666. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
  3667. bfa_timer_stop(&scn->timer);
  3668. break;
  3669. default:
  3670. bfa_sm_fault(scn->port->fcs, event);
  3671. }
  3672. }
  3673. static void
  3674. bfa_fcs_lport_scn_sm_online(struct bfa_fcs_lport_scn_s *scn,
  3675. enum port_scn_event event)
  3676. {
  3677. switch (event) {
  3678. case SCNSM_EVENT_PORT_OFFLINE:
  3679. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
  3680. break;
  3681. default:
  3682. bfa_sm_fault(scn->port->fcs, event);
  3683. }
  3684. }
  3685. /*
  3686. * fcs_scn_private FCS SCN private functions
  3687. */
  3688. /*
  3689. * This routine will be called to send a SCR command.
  3690. */
  3691. static void
  3692. bfa_fcs_lport_scn_send_scr(void *scn_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  3693. {
  3694. struct bfa_fcs_lport_scn_s *scn = scn_cbarg;
  3695. struct bfa_fcs_lport_s *port = scn->port;
  3696. struct fchs_s fchs;
  3697. int len;
  3698. struct bfa_fcxp_s *fcxp;
  3699. bfa_trc(port->fcs, port->pid);
  3700. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3701. fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  3702. if (!fcxp) {
  3703. bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &scn->fcxp_wqe,
  3704. bfa_fcs_lport_scn_send_scr, scn);
  3705. return;
  3706. }
  3707. scn->fcxp = fcxp;
  3708. /* Handle VU registrations for Base port only */
  3709. if ((!port->vport) && bfa_ioc_get_fcmode(&port->fcs->bfa->ioc)) {
  3710. len = fc_scr_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  3711. port->fabric->lps->brcd_switch,
  3712. port->pid, 0);
  3713. } else {
  3714. len = fc_scr_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  3715. BFA_FALSE,
  3716. port->pid, 0);
  3717. }
  3718. bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
  3719. FC_CLASS_3, len, &fchs,
  3720. bfa_fcs_lport_scn_scr_response,
  3721. (void *)scn, FC_MAX_PDUSZ, FC_ELS_TOV);
  3722. bfa_sm_send_event(scn, SCNSM_EVENT_SCR_SENT);
  3723. }
  3724. static void
  3725. bfa_fcs_lport_scn_scr_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
  3726. void *cbarg, bfa_status_t req_status, u32 rsp_len,
  3727. u32 resid_len, struct fchs_s *rsp_fchs)
  3728. {
  3729. struct bfa_fcs_lport_scn_s *scn = (struct bfa_fcs_lport_scn_s *) cbarg;
  3730. struct bfa_fcs_lport_s *port = scn->port;
  3731. struct fc_els_cmd_s *els_cmd;
  3732. struct fc_ls_rjt_s *ls_rjt;
  3733. bfa_trc(port->fcs, port->port_cfg.pwwn);
  3734. /*
  3735. * Sanity Checks
  3736. */
  3737. if (req_status != BFA_STATUS_OK) {
  3738. bfa_trc(port->fcs, req_status);
  3739. bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR);
  3740. return;
  3741. }
  3742. els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
  3743. switch (els_cmd->els_code) {
  3744. case FC_ELS_ACC:
  3745. bfa_sm_send_event(scn, SCNSM_EVENT_RSP_OK);
  3746. break;
  3747. case FC_ELS_LS_RJT:
  3748. ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
  3749. bfa_trc(port->fcs, ls_rjt->reason_code);
  3750. bfa_trc(port->fcs, ls_rjt->reason_code_expl);
  3751. bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR);
  3752. break;
  3753. default:
  3754. bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR);
  3755. }
  3756. }
  3757. /*
  3758. * Send a LS Accept
  3759. */
  3760. static void
  3761. bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s *port,
  3762. struct fchs_s *rx_fchs)
  3763. {
  3764. struct fchs_s fchs;
  3765. struct bfa_fcxp_s *fcxp;
  3766. struct bfa_rport_s *bfa_rport = NULL;
  3767. int len;
  3768. bfa_trc(port->fcs, rx_fchs->s_id);
  3769. fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  3770. if (!fcxp)
  3771. return;
  3772. len = fc_ls_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  3773. rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
  3774. rx_fchs->ox_id);
  3775. bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag,
  3776. BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL,
  3777. FC_MAX_PDUSZ, 0);
  3778. }
  3779. /*
  3780. * This routine will be called by bfa_timer on timer timeouts.
  3781. *
  3782. * param[in] vport - pointer to bfa_fcs_lport_t.
  3783. * param[out] vport_status - pointer to return vport status in
  3784. *
  3785. * return
  3786. * void
  3787. *
  3788. * Special Considerations:
  3789. *
  3790. * note
  3791. */
  3792. static void
  3793. bfa_fcs_lport_scn_timeout(void *arg)
  3794. {
  3795. struct bfa_fcs_lport_scn_s *scn = (struct bfa_fcs_lport_scn_s *) arg;
  3796. bfa_sm_send_event(scn, SCNSM_EVENT_TIMEOUT);
  3797. }
  3798. /*
  3799. * fcs_scn_public FCS state change notification public interfaces
  3800. */
  3801. /*
  3802. * Functions called by port/fab
  3803. */
  3804. void
  3805. bfa_fcs_lport_scn_init(struct bfa_fcs_lport_s *port)
  3806. {
  3807. struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port);
  3808. scn->port = port;
  3809. bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
  3810. }
  3811. void
  3812. bfa_fcs_lport_scn_offline(struct bfa_fcs_lport_s *port)
  3813. {
  3814. struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port);
  3815. scn->port = port;
  3816. bfa_sm_send_event(scn, SCNSM_EVENT_PORT_OFFLINE);
  3817. }
  3818. void
  3819. bfa_fcs_lport_scn_online(struct bfa_fcs_lport_s *port)
  3820. {
  3821. struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port);
  3822. scn->port = port;
  3823. bfa_sm_send_event(scn, SCNSM_EVENT_PORT_ONLINE);
  3824. }
  3825. static void
  3826. bfa_fcs_lport_scn_portid_rscn(struct bfa_fcs_lport_s *port, u32 rpid)
  3827. {
  3828. struct bfa_fcs_rport_s *rport;
  3829. bfa_trc(port->fcs, rpid);
  3830. /*
  3831. * If this is an unknown device, then it just came online.
  3832. * Otherwise let rport handle the RSCN event.
  3833. */
  3834. rport = bfa_fcs_lport_get_rport_by_pid(port, rpid);
  3835. if (rport == NULL) {
  3836. /*
  3837. * If min cfg mode is enabled, we donot need to
  3838. * discover any new rports.
  3839. */
  3840. if (!__fcs_min_cfg(port->fcs))
  3841. rport = bfa_fcs_rport_create(port, rpid);
  3842. } else
  3843. bfa_fcs_rport_scn(rport);
  3844. }
  3845. /*
  3846. * rscn format based PID comparison
  3847. */
  3848. #define __fc_pid_match(__c0, __c1, __fmt) \
  3849. (((__fmt) == FC_RSCN_FORMAT_FABRIC) || \
  3850. (((__fmt) == FC_RSCN_FORMAT_DOMAIN) && \
  3851. ((__c0)[0] == (__c1)[0])) || \
  3852. (((__fmt) == FC_RSCN_FORMAT_AREA) && \
  3853. ((__c0)[0] == (__c1)[0]) && \
  3854. ((__c0)[1] == (__c1)[1])))
  3855. static void
  3856. bfa_fcs_lport_scn_multiport_rscn(struct bfa_fcs_lport_s *port,
  3857. enum fc_rscn_format format,
  3858. u32 rscn_pid)
  3859. {
  3860. struct bfa_fcs_rport_s *rport;
  3861. struct list_head *qe, *qe_next;
  3862. u8 *c0, *c1;
  3863. bfa_trc(port->fcs, format);
  3864. bfa_trc(port->fcs, rscn_pid);
  3865. c0 = (u8 *) &rscn_pid;
  3866. list_for_each_safe(qe, qe_next, &port->rport_q) {
  3867. rport = (struct bfa_fcs_rport_s *) qe;
  3868. c1 = (u8 *) &rport->pid;
  3869. if (__fc_pid_match(c0, c1, format))
  3870. bfa_fcs_rport_scn(rport);
  3871. }
  3872. }
  3873. void
  3874. bfa_fcs_lport_scn_process_rscn(struct bfa_fcs_lport_s *port,
  3875. struct fchs_s *fchs, u32 len)
  3876. {
  3877. struct fc_rscn_pl_s *rscn = (struct fc_rscn_pl_s *) (fchs + 1);
  3878. int num_entries;
  3879. u32 rscn_pid;
  3880. bfa_boolean_t nsquery = BFA_FALSE, found;
  3881. int i = 0, j;
  3882. num_entries =
  3883. (be16_to_cpu(rscn->payldlen) -
  3884. sizeof(u32)) / sizeof(rscn->event[0]);
  3885. bfa_trc(port->fcs, num_entries);
  3886. port->stats.num_rscn++;
  3887. bfa_fcs_lport_scn_send_ls_acc(port, fchs);
  3888. for (i = 0; i < num_entries; i++) {
  3889. rscn_pid = rscn->event[i].portid;
  3890. bfa_trc(port->fcs, rscn->event[i].format);
  3891. bfa_trc(port->fcs, rscn_pid);
  3892. /* check for duplicate entries in the list */
  3893. found = BFA_FALSE;
  3894. for (j = 0; j < i; j++) {
  3895. if (rscn->event[j].portid == rscn_pid) {
  3896. found = BFA_TRUE;
  3897. break;
  3898. }
  3899. }
  3900. /* if found in down the list, pid has been already processed */
  3901. if (found) {
  3902. bfa_trc(port->fcs, rscn_pid);
  3903. continue;
  3904. }
  3905. switch (rscn->event[i].format) {
  3906. case FC_RSCN_FORMAT_PORTID:
  3907. if (rscn->event[i].qualifier == FC_QOS_RSCN_EVENT) {
  3908. /*
  3909. * Ignore this event.
  3910. * f/w would have processed it
  3911. */
  3912. bfa_trc(port->fcs, rscn_pid);
  3913. } else {
  3914. port->stats.num_portid_rscn++;
  3915. bfa_fcs_lport_scn_portid_rscn(port, rscn_pid);
  3916. }
  3917. break;
  3918. case FC_RSCN_FORMAT_FABRIC:
  3919. if (rscn->event[i].qualifier ==
  3920. FC_FABRIC_NAME_RSCN_EVENT) {
  3921. bfa_fcs_lport_ms_fabric_rscn(port);
  3922. break;
  3923. }
  3924. /* !!!!!!!!! Fall Through !!!!!!!!!!!!! */
  3925. case FC_RSCN_FORMAT_AREA:
  3926. case FC_RSCN_FORMAT_DOMAIN:
  3927. nsquery = BFA_TRUE;
  3928. bfa_fcs_lport_scn_multiport_rscn(port,
  3929. rscn->event[i].format,
  3930. rscn_pid);
  3931. break;
  3932. default:
  3933. WARN_ON(1);
  3934. nsquery = BFA_TRUE;
  3935. }
  3936. }
  3937. /*
  3938. * If any of area, domain or fabric RSCN is received, do a fresh
  3939. * discovery to find new devices.
  3940. */
  3941. if (nsquery)
  3942. bfa_fcs_lport_ns_query(port);
  3943. }
  3944. /*
  3945. * BFA FCS port
  3946. */
  3947. /*
  3948. * fcs_port_api BFA FCS port API
  3949. */
  3950. struct bfa_fcs_lport_s *
  3951. bfa_fcs_get_base_port(struct bfa_fcs_s *fcs)
  3952. {
  3953. return &fcs->fabric.bport;
  3954. }
  3955. wwn_t
  3956. bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn, int index,
  3957. int nrports, bfa_boolean_t bwwn)
  3958. {
  3959. struct list_head *qh, *qe;
  3960. struct bfa_fcs_rport_s *rport = NULL;
  3961. int i;
  3962. struct bfa_fcs_s *fcs;
  3963. if (port == NULL || nrports == 0)
  3964. return (wwn_t) 0;
  3965. fcs = port->fcs;
  3966. bfa_trc(fcs, (u32) nrports);
  3967. i = 0;
  3968. qh = &port->rport_q;
  3969. qe = bfa_q_first(qh);
  3970. while ((qe != qh) && (i < nrports)) {
  3971. rport = (struct bfa_fcs_rport_s *) qe;
  3972. if (bfa_ntoh3b(rport->pid) > 0xFFF000) {
  3973. qe = bfa_q_next(qe);
  3974. bfa_trc(fcs, (u32) rport->pwwn);
  3975. bfa_trc(fcs, rport->pid);
  3976. bfa_trc(fcs, i);
  3977. continue;
  3978. }
  3979. if (bwwn) {
  3980. if (!memcmp(&wwn, &rport->pwwn, 8))
  3981. break;
  3982. } else {
  3983. if (i == index)
  3984. break;
  3985. }
  3986. i++;
  3987. qe = bfa_q_next(qe);
  3988. }
  3989. bfa_trc(fcs, i);
  3990. if (rport)
  3991. return rport->pwwn;
  3992. else
  3993. return (wwn_t) 0;
  3994. }
  3995. void
  3996. bfa_fcs_lport_get_rports(struct bfa_fcs_lport_s *port,
  3997. wwn_t rport_wwns[], int *nrports)
  3998. {
  3999. struct list_head *qh, *qe;
  4000. struct bfa_fcs_rport_s *rport = NULL;
  4001. int i;
  4002. struct bfa_fcs_s *fcs;
  4003. if (port == NULL || rport_wwns == NULL || *nrports == 0)
  4004. return;
  4005. fcs = port->fcs;
  4006. bfa_trc(fcs, (u32) *nrports);
  4007. i = 0;
  4008. qh = &port->rport_q;
  4009. qe = bfa_q_first(qh);
  4010. while ((qe != qh) && (i < *nrports)) {
  4011. rport = (struct bfa_fcs_rport_s *) qe;
  4012. if (bfa_ntoh3b(rport->pid) > 0xFFF000) {
  4013. qe = bfa_q_next(qe);
  4014. bfa_trc(fcs, (u32) rport->pwwn);
  4015. bfa_trc(fcs, rport->pid);
  4016. bfa_trc(fcs, i);
  4017. continue;
  4018. }
  4019. rport_wwns[i] = rport->pwwn;
  4020. i++;
  4021. qe = bfa_q_next(qe);
  4022. }
  4023. bfa_trc(fcs, i);
  4024. *nrports = i;
  4025. }
  4026. /*
  4027. * Iterate's through all the rport's in the given port to
  4028. * determine the maximum operating speed.
  4029. *
  4030. * !!!! To be used in TRL Functionality only !!!!
  4031. */
  4032. bfa_port_speed_t
  4033. bfa_fcs_lport_get_rport_max_speed(bfa_fcs_lport_t *port)
  4034. {
  4035. struct list_head *qh, *qe;
  4036. struct bfa_fcs_rport_s *rport = NULL;
  4037. struct bfa_fcs_s *fcs;
  4038. bfa_port_speed_t max_speed = 0;
  4039. struct bfa_port_attr_s port_attr;
  4040. bfa_port_speed_t port_speed, rport_speed;
  4041. bfa_boolean_t trl_enabled = bfa_fcport_is_ratelim(port->fcs->bfa);
  4042. if (port == NULL)
  4043. return 0;
  4044. fcs = port->fcs;
  4045. /* Get Physical port's current speed */
  4046. bfa_fcport_get_attr(port->fcs->bfa, &port_attr);
  4047. port_speed = port_attr.speed;
  4048. bfa_trc(fcs, port_speed);
  4049. qh = &port->rport_q;
  4050. qe = bfa_q_first(qh);
  4051. while (qe != qh) {
  4052. rport = (struct bfa_fcs_rport_s *) qe;
  4053. if ((bfa_ntoh3b(rport->pid) > 0xFFF000) ||
  4054. (bfa_fcs_rport_get_state(rport) ==
  4055. BFA_RPORT_OFFLINE)) {
  4056. qe = bfa_q_next(qe);
  4057. continue;
  4058. }
  4059. rport_speed = rport->rpf.rpsc_speed;
  4060. if ((trl_enabled) && (rport_speed ==
  4061. BFA_PORT_SPEED_UNKNOWN)) {
  4062. /* Use default ratelim speed setting */
  4063. rport_speed =
  4064. bfa_fcport_get_ratelim_speed(port->fcs->bfa);
  4065. }
  4066. if ((rport_speed == BFA_PORT_SPEED_8GBPS) ||
  4067. (rport_speed > port_speed)) {
  4068. max_speed = rport_speed;
  4069. break;
  4070. } else if (rport_speed > max_speed) {
  4071. max_speed = rport_speed;
  4072. }
  4073. qe = bfa_q_next(qe);
  4074. }
  4075. bfa_trc(fcs, max_speed);
  4076. return max_speed;
  4077. }
  4078. struct bfa_fcs_lport_s *
  4079. bfa_fcs_lookup_port(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t lpwwn)
  4080. {
  4081. struct bfa_fcs_vport_s *vport;
  4082. bfa_fcs_vf_t *vf;
  4083. WARN_ON(fcs == NULL);
  4084. vf = bfa_fcs_vf_lookup(fcs, vf_id);
  4085. if (vf == NULL) {
  4086. bfa_trc(fcs, vf_id);
  4087. return NULL;
  4088. }
  4089. if (!lpwwn || (vf->bport.port_cfg.pwwn == lpwwn))
  4090. return &vf->bport;
  4091. vport = bfa_fcs_fabric_vport_lookup(vf, lpwwn);
  4092. if (vport)
  4093. return &vport->lport;
  4094. return NULL;
  4095. }
  4096. /*
  4097. * API corresponding to NPIV_VPORT_GETINFO.
  4098. */
  4099. void
  4100. bfa_fcs_lport_get_info(struct bfa_fcs_lport_s *port,
  4101. struct bfa_lport_info_s *port_info)
  4102. {
  4103. bfa_trc(port->fcs, port->fabric->fabric_name);
  4104. if (port->vport == NULL) {
  4105. /*
  4106. * This is a Physical port
  4107. */
  4108. port_info->port_type = BFA_LPORT_TYPE_PHYSICAL;
  4109. /*
  4110. * @todo : need to fix the state & reason
  4111. */
  4112. port_info->port_state = 0;
  4113. port_info->offline_reason = 0;
  4114. port_info->port_wwn = bfa_fcs_lport_get_pwwn(port);
  4115. port_info->node_wwn = bfa_fcs_lport_get_nwwn(port);
  4116. port_info->max_vports_supp =
  4117. bfa_lps_get_max_vport(port->fcs->bfa);
  4118. port_info->num_vports_inuse =
  4119. port->fabric->num_vports;
  4120. port_info->max_rports_supp = BFA_FCS_MAX_RPORTS_SUPP;
  4121. port_info->num_rports_inuse = port->num_rports;
  4122. } else {
  4123. /*
  4124. * This is a virtual port
  4125. */
  4126. port_info->port_type = BFA_LPORT_TYPE_VIRTUAL;
  4127. /*
  4128. * @todo : need to fix the state & reason
  4129. */
  4130. port_info->port_state = 0;
  4131. port_info->offline_reason = 0;
  4132. port_info->port_wwn = bfa_fcs_lport_get_pwwn(port);
  4133. port_info->node_wwn = bfa_fcs_lport_get_nwwn(port);
  4134. }
  4135. }
  4136. void
  4137. bfa_fcs_lport_get_stats(struct bfa_fcs_lport_s *fcs_port,
  4138. struct bfa_lport_stats_s *port_stats)
  4139. {
  4140. *port_stats = fcs_port->stats;
  4141. }
  4142. void
  4143. bfa_fcs_lport_clear_stats(struct bfa_fcs_lport_s *fcs_port)
  4144. {
  4145. memset(&fcs_port->stats, 0, sizeof(struct bfa_lport_stats_s));
  4146. }
  4147. /*
  4148. * FCS virtual port state machine
  4149. */
  4150. #define __vport_fcs(__vp) ((__vp)->lport.fcs)
  4151. #define __vport_pwwn(__vp) ((__vp)->lport.port_cfg.pwwn)
  4152. #define __vport_nwwn(__vp) ((__vp)->lport.port_cfg.nwwn)
  4153. #define __vport_bfa(__vp) ((__vp)->lport.fcs->bfa)
  4154. #define __vport_fcid(__vp) ((__vp)->lport.pid)
  4155. #define __vport_fabric(__vp) ((__vp)->lport.fabric)
  4156. #define __vport_vfid(__vp) ((__vp)->lport.fabric->vf_id)
  4157. #define BFA_FCS_VPORT_MAX_RETRIES 5
  4158. /*
  4159. * Forward declarations
  4160. */
  4161. static void bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport);
  4162. static void bfa_fcs_vport_timeout(void *vport_arg);
  4163. static void bfa_fcs_vport_do_logo(struct bfa_fcs_vport_s *vport);
  4164. static void bfa_fcs_vport_free(struct bfa_fcs_vport_s *vport);
  4165. /*
  4166. * fcs_vport_sm FCS virtual port state machine
  4167. */
  4168. /*
  4169. * VPort State Machine events
  4170. */
  4171. enum bfa_fcs_vport_event {
  4172. BFA_FCS_VPORT_SM_CREATE = 1, /* vport create event */
  4173. BFA_FCS_VPORT_SM_DELETE = 2, /* vport delete event */
  4174. BFA_FCS_VPORT_SM_START = 3, /* vport start request */
  4175. BFA_FCS_VPORT_SM_STOP = 4, /* stop: unsupported */
  4176. BFA_FCS_VPORT_SM_ONLINE = 5, /* fabric online */
  4177. BFA_FCS_VPORT_SM_OFFLINE = 6, /* fabric offline event */
  4178. BFA_FCS_VPORT_SM_FRMSENT = 7, /* fdisc/logo sent events */
  4179. BFA_FCS_VPORT_SM_RSP_OK = 8, /* good response */
  4180. BFA_FCS_VPORT_SM_RSP_ERROR = 9, /* error/bad response */
  4181. BFA_FCS_VPORT_SM_TIMEOUT = 10, /* delay timer event */
  4182. BFA_FCS_VPORT_SM_DELCOMP = 11, /* lport delete completion */
  4183. BFA_FCS_VPORT_SM_RSP_DUP_WWN = 12, /* Dup wnn error*/
  4184. BFA_FCS_VPORT_SM_RSP_FAILED = 13, /* non-retryable failure */
  4185. };
  4186. static void bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s *vport,
  4187. enum bfa_fcs_vport_event event);
  4188. static void bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s *vport,
  4189. enum bfa_fcs_vport_event event);
  4190. static void bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s *vport,
  4191. enum bfa_fcs_vport_event event);
  4192. static void bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s *vport,
  4193. enum bfa_fcs_vport_event event);
  4194. static void bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s *vport,
  4195. enum bfa_fcs_vport_event event);
  4196. static void bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s *vport,
  4197. enum bfa_fcs_vport_event event);
  4198. static void bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s *vport,
  4199. enum bfa_fcs_vport_event event);
  4200. static void bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s *vport,
  4201. enum bfa_fcs_vport_event event);
  4202. static void bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport,
  4203. enum bfa_fcs_vport_event event);
  4204. static void bfa_fcs_vport_sm_error(struct bfa_fcs_vport_s *vport,
  4205. enum bfa_fcs_vport_event event);
  4206. static struct bfa_sm_table_s vport_sm_table[] = {
  4207. {BFA_SM(bfa_fcs_vport_sm_uninit), BFA_FCS_VPORT_UNINIT},
  4208. {BFA_SM(bfa_fcs_vport_sm_created), BFA_FCS_VPORT_CREATED},
  4209. {BFA_SM(bfa_fcs_vport_sm_offline), BFA_FCS_VPORT_OFFLINE},
  4210. {BFA_SM(bfa_fcs_vport_sm_fdisc), BFA_FCS_VPORT_FDISC},
  4211. {BFA_SM(bfa_fcs_vport_sm_fdisc_retry), BFA_FCS_VPORT_FDISC_RETRY},
  4212. {BFA_SM(bfa_fcs_vport_sm_online), BFA_FCS_VPORT_ONLINE},
  4213. {BFA_SM(bfa_fcs_vport_sm_deleting), BFA_FCS_VPORT_DELETING},
  4214. {BFA_SM(bfa_fcs_vport_sm_cleanup), BFA_FCS_VPORT_CLEANUP},
  4215. {BFA_SM(bfa_fcs_vport_sm_logo), BFA_FCS_VPORT_LOGO},
  4216. {BFA_SM(bfa_fcs_vport_sm_error), BFA_FCS_VPORT_ERROR}
  4217. };
  4218. /*
  4219. * Beginning state.
  4220. */
  4221. static void
  4222. bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s *vport,
  4223. enum bfa_fcs_vport_event event)
  4224. {
  4225. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4226. bfa_trc(__vport_fcs(vport), event);
  4227. switch (event) {
  4228. case BFA_FCS_VPORT_SM_CREATE:
  4229. bfa_sm_set_state(vport, bfa_fcs_vport_sm_created);
  4230. bfa_fcs_fabric_addvport(__vport_fabric(vport), vport);
  4231. break;
  4232. default:
  4233. bfa_sm_fault(__vport_fcs(vport), event);
  4234. }
  4235. }
  4236. /*
  4237. * Created state - a start event is required to start up the state machine.
  4238. */
  4239. static void
  4240. bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s *vport,
  4241. enum bfa_fcs_vport_event event)
  4242. {
  4243. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4244. bfa_trc(__vport_fcs(vport), event);
  4245. switch (event) {
  4246. case BFA_FCS_VPORT_SM_START:
  4247. if (bfa_sm_cmp_state(__vport_fabric(vport),
  4248. bfa_fcs_fabric_sm_online)
  4249. && bfa_fcs_fabric_npiv_capable(__vport_fabric(vport))) {
  4250. bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc);
  4251. bfa_fcs_vport_do_fdisc(vport);
  4252. } else {
  4253. /*
  4254. * Fabric is offline or not NPIV capable, stay in
  4255. * offline state.
  4256. */
  4257. vport->vport_stats.fab_no_npiv++;
  4258. bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
  4259. }
  4260. break;
  4261. case BFA_FCS_VPORT_SM_DELETE:
  4262. bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
  4263. bfa_fcs_lport_delete(&vport->lport);
  4264. break;
  4265. case BFA_FCS_VPORT_SM_ONLINE:
  4266. case BFA_FCS_VPORT_SM_OFFLINE:
  4267. /*
  4268. * Ignore ONLINE/OFFLINE events from fabric
  4269. * till vport is started.
  4270. */
  4271. break;
  4272. default:
  4273. bfa_sm_fault(__vport_fcs(vport), event);
  4274. }
  4275. }
  4276. /*
  4277. * Offline state - awaiting ONLINE event from fabric SM.
  4278. */
  4279. static void
  4280. bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s *vport,
  4281. enum bfa_fcs_vport_event event)
  4282. {
  4283. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4284. bfa_trc(__vport_fcs(vport), event);
  4285. switch (event) {
  4286. case BFA_FCS_VPORT_SM_DELETE:
  4287. bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
  4288. bfa_fcs_lport_delete(&vport->lport);
  4289. break;
  4290. case BFA_FCS_VPORT_SM_ONLINE:
  4291. bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc);
  4292. vport->fdisc_retries = 0;
  4293. bfa_fcs_vport_do_fdisc(vport);
  4294. break;
  4295. case BFA_FCS_VPORT_SM_OFFLINE:
  4296. /*
  4297. * This can happen if the vport couldn't be initialzied
  4298. * due the fact that the npiv was not enabled on the switch.
  4299. * In that case we will put the vport in offline state.
  4300. * However, the link can go down and cause the this event to
  4301. * be sent when we are already offline. Ignore it.
  4302. */
  4303. break;
  4304. default:
  4305. bfa_sm_fault(__vport_fcs(vport), event);
  4306. }
  4307. }
  4308. /*
  4309. * FDISC is sent and awaiting reply from fabric.
  4310. */
  4311. static void
  4312. bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s *vport,
  4313. enum bfa_fcs_vport_event event)
  4314. {
  4315. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4316. bfa_trc(__vport_fcs(vport), event);
  4317. switch (event) {
  4318. case BFA_FCS_VPORT_SM_DELETE:
  4319. bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
  4320. bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
  4321. bfa_fcs_lport_delete(&vport->lport);
  4322. break;
  4323. case BFA_FCS_VPORT_SM_OFFLINE:
  4324. bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
  4325. bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
  4326. break;
  4327. case BFA_FCS_VPORT_SM_RSP_OK:
  4328. bfa_sm_set_state(vport, bfa_fcs_vport_sm_online);
  4329. bfa_fcs_lport_online(&vport->lport);
  4330. break;
  4331. case BFA_FCS_VPORT_SM_RSP_ERROR:
  4332. bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc_retry);
  4333. bfa_timer_start(__vport_bfa(vport), &vport->timer,
  4334. bfa_fcs_vport_timeout, vport,
  4335. BFA_FCS_RETRY_TIMEOUT);
  4336. break;
  4337. case BFA_FCS_VPORT_SM_RSP_FAILED:
  4338. bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
  4339. break;
  4340. case BFA_FCS_VPORT_SM_RSP_DUP_WWN:
  4341. bfa_sm_set_state(vport, bfa_fcs_vport_sm_error);
  4342. break;
  4343. default:
  4344. bfa_sm_fault(__vport_fcs(vport), event);
  4345. }
  4346. }
  4347. /*
  4348. * FDISC attempt failed - a timer is active to retry FDISC.
  4349. */
  4350. static void
  4351. bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s *vport,
  4352. enum bfa_fcs_vport_event event)
  4353. {
  4354. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4355. bfa_trc(__vport_fcs(vport), event);
  4356. switch (event) {
  4357. case BFA_FCS_VPORT_SM_DELETE:
  4358. bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
  4359. bfa_timer_stop(&vport->timer);
  4360. bfa_fcs_lport_delete(&vport->lport);
  4361. break;
  4362. case BFA_FCS_VPORT_SM_OFFLINE:
  4363. bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
  4364. bfa_timer_stop(&vport->timer);
  4365. break;
  4366. case BFA_FCS_VPORT_SM_TIMEOUT:
  4367. bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc);
  4368. vport->vport_stats.fdisc_retries++;
  4369. vport->fdisc_retries++;
  4370. bfa_fcs_vport_do_fdisc(vport);
  4371. break;
  4372. default:
  4373. bfa_sm_fault(__vport_fcs(vport), event);
  4374. }
  4375. }
  4376. /*
  4377. * Vport is online (FDISC is complete).
  4378. */
  4379. static void
  4380. bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s *vport,
  4381. enum bfa_fcs_vport_event event)
  4382. {
  4383. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4384. bfa_trc(__vport_fcs(vport), event);
  4385. switch (event) {
  4386. case BFA_FCS_VPORT_SM_DELETE:
  4387. bfa_sm_set_state(vport, bfa_fcs_vport_sm_deleting);
  4388. bfa_fcs_lport_delete(&vport->lport);
  4389. break;
  4390. case BFA_FCS_VPORT_SM_OFFLINE:
  4391. bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
  4392. bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
  4393. bfa_fcs_lport_offline(&vport->lport);
  4394. break;
  4395. default:
  4396. bfa_sm_fault(__vport_fcs(vport), event);
  4397. }
  4398. }
  4399. /*
  4400. * Vport is being deleted - awaiting lport delete completion to send
  4401. * LOGO to fabric.
  4402. */
  4403. static void
  4404. bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s *vport,
  4405. enum bfa_fcs_vport_event event)
  4406. {
  4407. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4408. bfa_trc(__vport_fcs(vport), event);
  4409. switch (event) {
  4410. case BFA_FCS_VPORT_SM_DELETE:
  4411. break;
  4412. case BFA_FCS_VPORT_SM_DELCOMP:
  4413. bfa_sm_set_state(vport, bfa_fcs_vport_sm_logo);
  4414. bfa_fcs_vport_do_logo(vport);
  4415. break;
  4416. case BFA_FCS_VPORT_SM_OFFLINE:
  4417. bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
  4418. break;
  4419. default:
  4420. bfa_sm_fault(__vport_fcs(vport), event);
  4421. }
  4422. }
  4423. /*
  4424. * Error State.
  4425. * This state will be set when the Vport Creation fails due
  4426. * to errors like Dup WWN. In this state only operation allowed
  4427. * is a Vport Delete.
  4428. */
  4429. static void
  4430. bfa_fcs_vport_sm_error(struct bfa_fcs_vport_s *vport,
  4431. enum bfa_fcs_vport_event event)
  4432. {
  4433. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4434. bfa_trc(__vport_fcs(vport), event);
  4435. switch (event) {
  4436. case BFA_FCS_VPORT_SM_DELETE:
  4437. bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
  4438. bfa_fcs_lport_delete(&vport->lport);
  4439. break;
  4440. default:
  4441. bfa_trc(__vport_fcs(vport), event);
  4442. }
  4443. }
  4444. /*
  4445. * Lport cleanup is in progress since vport is being deleted. Fabric is
  4446. * offline, so no LOGO is needed to complete vport deletion.
  4447. */
  4448. static void
  4449. bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s *vport,
  4450. enum bfa_fcs_vport_event event)
  4451. {
  4452. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4453. bfa_trc(__vport_fcs(vport), event);
  4454. switch (event) {
  4455. case BFA_FCS_VPORT_SM_DELCOMP:
  4456. bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit);
  4457. bfa_fcs_vport_free(vport);
  4458. break;
  4459. case BFA_FCS_VPORT_SM_DELETE:
  4460. break;
  4461. default:
  4462. bfa_sm_fault(__vport_fcs(vport), event);
  4463. }
  4464. }
  4465. /*
  4466. * LOGO is sent to fabric. Vport delete is in progress. Lport delete cleanup
  4467. * is done.
  4468. */
  4469. static void
  4470. bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport,
  4471. enum bfa_fcs_vport_event event)
  4472. {
  4473. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4474. bfa_trc(__vport_fcs(vport), event);
  4475. switch (event) {
  4476. case BFA_FCS_VPORT_SM_OFFLINE:
  4477. bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
  4478. /*
  4479. * !!! fall through !!!
  4480. */
  4481. case BFA_FCS_VPORT_SM_RSP_OK:
  4482. case BFA_FCS_VPORT_SM_RSP_ERROR:
  4483. bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit);
  4484. bfa_fcs_vport_free(vport);
  4485. break;
  4486. case BFA_FCS_VPORT_SM_DELETE:
  4487. break;
  4488. default:
  4489. bfa_sm_fault(__vport_fcs(vport), event);
  4490. }
  4491. }
  4492. /*
  4493. * fcs_vport_private FCS virtual port private functions
  4494. */
  4495. /*
  4496. * This routine will be called to send a FDISC command.
  4497. */
  4498. static void
  4499. bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport)
  4500. {
  4501. bfa_lps_fdisc(vport->lps, vport,
  4502. bfa_fcport_get_maxfrsize(__vport_bfa(vport)),
  4503. __vport_pwwn(vport), __vport_nwwn(vport));
  4504. vport->vport_stats.fdisc_sent++;
  4505. }
  4506. static void
  4507. bfa_fcs_vport_fdisc_rejected(struct bfa_fcs_vport_s *vport)
  4508. {
  4509. u8 lsrjt_rsn = vport->lps->lsrjt_rsn;
  4510. u8 lsrjt_expl = vport->lps->lsrjt_expl;
  4511. bfa_trc(__vport_fcs(vport), lsrjt_rsn);
  4512. bfa_trc(__vport_fcs(vport), lsrjt_expl);
  4513. /* For certain reason codes, we don't want to retry. */
  4514. switch (vport->lps->lsrjt_expl) {
  4515. case FC_LS_RJT_EXP_INV_PORT_NAME: /* by brocade */
  4516. case FC_LS_RJT_EXP_INVALID_NPORT_ID: /* by Cisco */
  4517. if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
  4518. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
  4519. else
  4520. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_DUP_WWN);
  4521. break;
  4522. case FC_LS_RJT_EXP_INSUFF_RES:
  4523. /*
  4524. * This means max logins per port/switch setting on the
  4525. * switch was exceeded.
  4526. */
  4527. if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
  4528. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
  4529. else
  4530. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_FAILED);
  4531. break;
  4532. default:
  4533. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
  4534. }
  4535. }
  4536. /*
  4537. * Called to send a logout to the fabric. Used when a V-Port is
  4538. * deleted/stopped.
  4539. */
  4540. static void
  4541. bfa_fcs_vport_do_logo(struct bfa_fcs_vport_s *vport)
  4542. {
  4543. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4544. vport->vport_stats.logo_sent++;
  4545. bfa_lps_fdisclogo(vport->lps);
  4546. }
  4547. /*
  4548. * This routine will be called by bfa_timer on timer timeouts.
  4549. *
  4550. * param[in] vport - pointer to bfa_fcs_vport_t.
  4551. * param[out] vport_status - pointer to return vport status in
  4552. *
  4553. * return
  4554. * void
  4555. *
  4556. * Special Considerations:
  4557. *
  4558. * note
  4559. */
  4560. static void
  4561. bfa_fcs_vport_timeout(void *vport_arg)
  4562. {
  4563. struct bfa_fcs_vport_s *vport = (struct bfa_fcs_vport_s *) vport_arg;
  4564. vport->vport_stats.fdisc_timeouts++;
  4565. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_TIMEOUT);
  4566. }
  4567. static void
  4568. bfa_fcs_vport_free(struct bfa_fcs_vport_s *vport)
  4569. {
  4570. struct bfad_vport_s *vport_drv =
  4571. (struct bfad_vport_s *)vport->vport_drv;
  4572. bfa_fcs_fabric_delvport(__vport_fabric(vport), vport);
  4573. if (vport_drv->comp_del)
  4574. complete(vport_drv->comp_del);
  4575. bfa_lps_delete(vport->lps);
  4576. }
  4577. /*
  4578. * fcs_vport_public FCS virtual port public interfaces
  4579. */
  4580. /*
  4581. * Online notification from fabric SM.
  4582. */
  4583. void
  4584. bfa_fcs_vport_online(struct bfa_fcs_vport_s *vport)
  4585. {
  4586. vport->vport_stats.fab_online++;
  4587. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_ONLINE);
  4588. }
  4589. /*
  4590. * Offline notification from fabric SM.
  4591. */
  4592. void
  4593. bfa_fcs_vport_offline(struct bfa_fcs_vport_s *vport)
  4594. {
  4595. vport->vport_stats.fab_offline++;
  4596. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_OFFLINE);
  4597. }
  4598. /*
  4599. * Cleanup notification from fabric SM on link timer expiry.
  4600. */
  4601. void
  4602. bfa_fcs_vport_cleanup(struct bfa_fcs_vport_s *vport)
  4603. {
  4604. vport->vport_stats.fab_cleanup++;
  4605. }
  4606. /*
  4607. * delete notification from fabric SM. To be invoked from within FCS.
  4608. */
  4609. void
  4610. bfa_fcs_vport_fcs_delete(struct bfa_fcs_vport_s *vport)
  4611. {
  4612. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELETE);
  4613. }
  4614. /*
  4615. * Delete completion callback from associated lport
  4616. */
  4617. void
  4618. bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s *vport)
  4619. {
  4620. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELCOMP);
  4621. }
  4622. /*
  4623. * fcs_vport_api Virtual port API
  4624. */
  4625. /*
  4626. * Use this function to instantiate a new FCS vport object. This
  4627. * function will not trigger any HW initialization process (which will be
  4628. * done in vport_start() call)
  4629. *
  4630. * param[in] vport - pointer to bfa_fcs_vport_t. This space
  4631. * needs to be allocated by the driver.
  4632. * param[in] fcs - FCS instance
  4633. * param[in] vport_cfg - vport configuration
  4634. * param[in] vf_id - VF_ID if vport is created within a VF.
  4635. * FC_VF_ID_NULL to specify base fabric.
  4636. * param[in] vport_drv - Opaque handle back to the driver's vport
  4637. * structure
  4638. *
  4639. * retval BFA_STATUS_OK - on success.
  4640. * retval BFA_STATUS_FAILED - on failure.
  4641. */
  4642. bfa_status_t
  4643. bfa_fcs_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
  4644. u16 vf_id, struct bfa_lport_cfg_s *vport_cfg,
  4645. struct bfad_vport_s *vport_drv)
  4646. {
  4647. if (vport_cfg->pwwn == 0)
  4648. return BFA_STATUS_INVALID_WWN;
  4649. if (bfa_fcs_lport_get_pwwn(&fcs->fabric.bport) == vport_cfg->pwwn)
  4650. return BFA_STATUS_VPORT_WWN_BP;
  4651. if (bfa_fcs_vport_lookup(fcs, vf_id, vport_cfg->pwwn) != NULL)
  4652. return BFA_STATUS_VPORT_EXISTS;
  4653. if (fcs->fabric.num_vports ==
  4654. bfa_lps_get_max_vport(fcs->bfa))
  4655. return BFA_STATUS_VPORT_MAX;
  4656. vport->lps = bfa_lps_alloc(fcs->bfa);
  4657. if (!vport->lps)
  4658. return BFA_STATUS_VPORT_MAX;
  4659. vport->vport_drv = vport_drv;
  4660. vport_cfg->preboot_vp = BFA_FALSE;
  4661. bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit);
  4662. bfa_fcs_lport_attach(&vport->lport, fcs, vf_id, vport);
  4663. bfa_fcs_lport_init(&vport->lport, vport_cfg);
  4664. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_CREATE);
  4665. return BFA_STATUS_OK;
  4666. }
  4667. /*
  4668. * Use this function to instantiate a new FCS PBC vport object. This
  4669. * function will not trigger any HW initialization process (which will be
  4670. * done in vport_start() call)
  4671. *
  4672. * param[in] vport - pointer to bfa_fcs_vport_t. This space
  4673. * needs to be allocated by the driver.
  4674. * param[in] fcs - FCS instance
  4675. * param[in] vport_cfg - vport configuration
  4676. * param[in] vf_id - VF_ID if vport is created within a VF.
  4677. * FC_VF_ID_NULL to specify base fabric.
  4678. * param[in] vport_drv - Opaque handle back to the driver's vport
  4679. * structure
  4680. *
  4681. * retval BFA_STATUS_OK - on success.
  4682. * retval BFA_STATUS_FAILED - on failure.
  4683. */
  4684. bfa_status_t
  4685. bfa_fcs_pbc_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
  4686. u16 vf_id, struct bfa_lport_cfg_s *vport_cfg,
  4687. struct bfad_vport_s *vport_drv)
  4688. {
  4689. bfa_status_t rc;
  4690. rc = bfa_fcs_vport_create(vport, fcs, vf_id, vport_cfg, vport_drv);
  4691. vport->lport.port_cfg.preboot_vp = BFA_TRUE;
  4692. return rc;
  4693. }
  4694. /*
  4695. * Use this function to findout if this is a pbc vport or not.
  4696. *
  4697. * @param[in] vport - pointer to bfa_fcs_vport_t.
  4698. *
  4699. * @returns None
  4700. */
  4701. bfa_boolean_t
  4702. bfa_fcs_is_pbc_vport(struct bfa_fcs_vport_s *vport)
  4703. {
  4704. if (vport && (vport->lport.port_cfg.preboot_vp == BFA_TRUE))
  4705. return BFA_TRUE;
  4706. else
  4707. return BFA_FALSE;
  4708. }
  4709. /*
  4710. * Use this function initialize the vport.
  4711. *
  4712. * @param[in] vport - pointer to bfa_fcs_vport_t.
  4713. *
  4714. * @returns None
  4715. */
  4716. bfa_status_t
  4717. bfa_fcs_vport_start(struct bfa_fcs_vport_s *vport)
  4718. {
  4719. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_START);
  4720. return BFA_STATUS_OK;
  4721. }
  4722. /*
  4723. * Use this function quiese the vport object. This function will return
  4724. * immediately, when the vport is actually stopped, the
  4725. * bfa_drv_vport_stop_cb() will be called.
  4726. *
  4727. * param[in] vport - pointer to bfa_fcs_vport_t.
  4728. *
  4729. * return None
  4730. */
  4731. bfa_status_t
  4732. bfa_fcs_vport_stop(struct bfa_fcs_vport_s *vport)
  4733. {
  4734. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOP);
  4735. return BFA_STATUS_OK;
  4736. }
  4737. /*
  4738. * Use this function to delete a vport object. Fabric object should
  4739. * be stopped before this function call.
  4740. *
  4741. * !!!!!!! Donot invoke this from within FCS !!!!!!!
  4742. *
  4743. * param[in] vport - pointer to bfa_fcs_vport_t.
  4744. *
  4745. * return None
  4746. */
  4747. bfa_status_t
  4748. bfa_fcs_vport_delete(struct bfa_fcs_vport_s *vport)
  4749. {
  4750. if (vport->lport.port_cfg.preboot_vp)
  4751. return BFA_STATUS_PBC;
  4752. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELETE);
  4753. return BFA_STATUS_OK;
  4754. }
  4755. /*
  4756. * Use this function to get vport's current status info.
  4757. *
  4758. * param[in] vport pointer to bfa_fcs_vport_t.
  4759. * param[out] attr pointer to return vport attributes
  4760. *
  4761. * return None
  4762. */
  4763. void
  4764. bfa_fcs_vport_get_attr(struct bfa_fcs_vport_s *vport,
  4765. struct bfa_vport_attr_s *attr)
  4766. {
  4767. if (vport == NULL || attr == NULL)
  4768. return;
  4769. memset(attr, 0, sizeof(struct bfa_vport_attr_s));
  4770. bfa_fcs_lport_get_attr(&vport->lport, &attr->port_attr);
  4771. attr->vport_state = bfa_sm_to_state(vport_sm_table, vport->sm);
  4772. }
  4773. /*
  4774. * Lookup a virtual port. Excludes base port from lookup.
  4775. */
  4776. struct bfa_fcs_vport_s *
  4777. bfa_fcs_vport_lookup(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t vpwwn)
  4778. {
  4779. struct bfa_fcs_vport_s *vport;
  4780. struct bfa_fcs_fabric_s *fabric;
  4781. bfa_trc(fcs, vf_id);
  4782. bfa_trc(fcs, vpwwn);
  4783. fabric = bfa_fcs_vf_lookup(fcs, vf_id);
  4784. if (!fabric) {
  4785. bfa_trc(fcs, vf_id);
  4786. return NULL;
  4787. }
  4788. vport = bfa_fcs_fabric_vport_lookup(fabric, vpwwn);
  4789. return vport;
  4790. }
  4791. /*
  4792. * FDISC Response
  4793. */
  4794. void
  4795. bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status)
  4796. {
  4797. struct bfa_fcs_vport_s *vport = uarg;
  4798. bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
  4799. bfa_trc(__vport_fcs(vport), status);
  4800. switch (status) {
  4801. case BFA_STATUS_OK:
  4802. /*
  4803. * Initialize the V-Port fields
  4804. */
  4805. __vport_fcid(vport) = vport->lps->lp_pid;
  4806. vport->vport_stats.fdisc_accepts++;
  4807. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_OK);
  4808. break;
  4809. case BFA_STATUS_INVALID_MAC:
  4810. /* Only for CNA */
  4811. vport->vport_stats.fdisc_acc_bad++;
  4812. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
  4813. break;
  4814. case BFA_STATUS_EPROTOCOL:
  4815. switch (vport->lps->ext_status) {
  4816. case BFA_EPROTO_BAD_ACCEPT:
  4817. vport->vport_stats.fdisc_acc_bad++;
  4818. break;
  4819. case BFA_EPROTO_UNKNOWN_RSP:
  4820. vport->vport_stats.fdisc_unknown_rsp++;
  4821. break;
  4822. default:
  4823. break;
  4824. }
  4825. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
  4826. break;
  4827. case BFA_STATUS_FABRIC_RJT:
  4828. vport->vport_stats.fdisc_rejects++;
  4829. bfa_fcs_vport_fdisc_rejected(vport);
  4830. break;
  4831. default:
  4832. vport->vport_stats.fdisc_rsp_err++;
  4833. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
  4834. }
  4835. }
  4836. /*
  4837. * LOGO response
  4838. */
  4839. void
  4840. bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg)
  4841. {
  4842. struct bfa_fcs_vport_s *vport = uarg;
  4843. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_OK);
  4844. }
  4845. /*
  4846. * Received clear virtual link
  4847. */
  4848. void
  4849. bfa_cb_lps_cvl_event(void *bfad, void *uarg)
  4850. {
  4851. struct bfa_fcs_vport_s *vport = uarg;
  4852. /* Send an Offline followed by an ONLINE */
  4853. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_OFFLINE);
  4854. bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_ONLINE);
  4855. }