ibmvfc.c 138 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053
  1. /*
  2. * ibmvfc.c -- driver for IBM Power Virtual Fibre Channel Adapter
  3. *
  4. * Written By: Brian King <brking@linux.vnet.ibm.com>, IBM Corporation
  5. *
  6. * Copyright (C) IBM Corporation, 2008
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. *
  22. */
  23. #include <linux/module.h>
  24. #include <linux/moduleparam.h>
  25. #include <linux/dma-mapping.h>
  26. #include <linux/dmapool.h>
  27. #include <linux/delay.h>
  28. #include <linux/interrupt.h>
  29. #include <linux/kthread.h>
  30. #include <linux/slab.h>
  31. #include <linux/of.h>
  32. #include <linux/pm.h>
  33. #include <linux/stringify.h>
  34. #include <asm/firmware.h>
  35. #include <asm/irq.h>
  36. #include <asm/vio.h>
  37. #include <scsi/scsi.h>
  38. #include <scsi/scsi_cmnd.h>
  39. #include <scsi/scsi_host.h>
  40. #include <scsi/scsi_device.h>
  41. #include <scsi/scsi_tcq.h>
  42. #include <scsi/scsi_transport_fc.h>
  43. #include <scsi/scsi_bsg_fc.h>
  44. #include "ibmvfc.h"
  45. static unsigned int init_timeout = IBMVFC_INIT_TIMEOUT;
  46. static unsigned int default_timeout = IBMVFC_DEFAULT_TIMEOUT;
  47. static unsigned int max_lun = IBMVFC_MAX_LUN;
  48. static unsigned int max_targets = IBMVFC_MAX_TARGETS;
  49. static unsigned int max_requests = IBMVFC_MAX_REQUESTS_DEFAULT;
  50. static unsigned int disc_threads = IBMVFC_MAX_DISC_THREADS;
  51. static unsigned int ibmvfc_debug = IBMVFC_DEBUG;
  52. static unsigned int log_level = IBMVFC_DEFAULT_LOG_LEVEL;
  53. static LIST_HEAD(ibmvfc_head);
  54. static DEFINE_SPINLOCK(ibmvfc_driver_lock);
  55. static struct scsi_transport_template *ibmvfc_transport_template;
  56. MODULE_DESCRIPTION("IBM Virtual Fibre Channel Driver");
  57. MODULE_AUTHOR("Brian King <brking@linux.vnet.ibm.com>");
  58. MODULE_LICENSE("GPL");
  59. MODULE_VERSION(IBMVFC_DRIVER_VERSION);
  60. module_param_named(init_timeout, init_timeout, uint, S_IRUGO | S_IWUSR);
  61. MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds. "
  62. "[Default=" __stringify(IBMVFC_INIT_TIMEOUT) "]");
  63. module_param_named(default_timeout, default_timeout, uint, S_IRUGO | S_IWUSR);
  64. MODULE_PARM_DESC(default_timeout,
  65. "Default timeout in seconds for initialization and EH commands. "
  66. "[Default=" __stringify(IBMVFC_DEFAULT_TIMEOUT) "]");
  67. module_param_named(max_requests, max_requests, uint, S_IRUGO);
  68. MODULE_PARM_DESC(max_requests, "Maximum requests for this adapter. "
  69. "[Default=" __stringify(IBMVFC_MAX_REQUESTS_DEFAULT) "]");
  70. module_param_named(max_lun, max_lun, uint, S_IRUGO);
  71. MODULE_PARM_DESC(max_lun, "Maximum allowed LUN. "
  72. "[Default=" __stringify(IBMVFC_MAX_LUN) "]");
  73. module_param_named(max_targets, max_targets, uint, S_IRUGO);
  74. MODULE_PARM_DESC(max_targets, "Maximum allowed targets. "
  75. "[Default=" __stringify(IBMVFC_MAX_TARGETS) "]");
  76. module_param_named(disc_threads, disc_threads, uint, S_IRUGO);
  77. MODULE_PARM_DESC(disc_threads, "Number of device discovery threads to use. "
  78. "[Default=" __stringify(IBMVFC_MAX_DISC_THREADS) "]");
  79. module_param_named(debug, ibmvfc_debug, uint, S_IRUGO | S_IWUSR);
  80. MODULE_PARM_DESC(debug, "Enable driver debug information. "
  81. "[Default=" __stringify(IBMVFC_DEBUG) "]");
  82. module_param_named(log_level, log_level, uint, 0);
  83. MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver. "
  84. "[Default=" __stringify(IBMVFC_DEFAULT_LOG_LEVEL) "]");
  85. static const struct {
  86. u16 status;
  87. u16 error;
  88. u8 result;
  89. u8 retry;
  90. int log;
  91. char *name;
  92. } cmd_status [] = {
  93. { IBMVFC_FABRIC_MAPPED, IBMVFC_UNABLE_TO_ESTABLISH, DID_ERROR, 1, 1, "unable to establish" },
  94. { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_FAULT, DID_OK, 1, 0, "transport fault" },
  95. { IBMVFC_FABRIC_MAPPED, IBMVFC_CMD_TIMEOUT, DID_TIME_OUT, 1, 1, "command timeout" },
  96. { IBMVFC_FABRIC_MAPPED, IBMVFC_ENETDOWN, DID_TRANSPORT_DISRUPTED, 1, 1, "network down" },
  97. { IBMVFC_FABRIC_MAPPED, IBMVFC_HW_FAILURE, DID_ERROR, 1, 1, "hardware failure" },
  98. { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_DOWN_ERR, DID_REQUEUE, 0, 0, "link down" },
  99. { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_DEAD_ERR, DID_ERROR, 0, 0, "link dead" },
  100. { IBMVFC_FABRIC_MAPPED, IBMVFC_UNABLE_TO_REGISTER, DID_ERROR, 1, 1, "unable to register" },
  101. { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_BUSY, DID_BUS_BUSY, 1, 0, "transport busy" },
  102. { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_DEAD, DID_ERROR, 0, 1, "transport dead" },
  103. { IBMVFC_FABRIC_MAPPED, IBMVFC_CONFIG_ERROR, DID_ERROR, 1, 1, "configuration error" },
  104. { IBMVFC_FABRIC_MAPPED, IBMVFC_NAME_SERVER_FAIL, DID_ERROR, 1, 1, "name server failure" },
  105. { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_HALTED, DID_REQUEUE, 1, 0, "link halted" },
  106. { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_GENERAL, DID_OK, 1, 0, "general transport error" },
  107. { IBMVFC_VIOS_FAILURE, IBMVFC_CRQ_FAILURE, DID_REQUEUE, 1, 1, "CRQ failure" },
  108. { IBMVFC_VIOS_FAILURE, IBMVFC_SW_FAILURE, DID_ERROR, 0, 1, "software failure" },
  109. { IBMVFC_VIOS_FAILURE, IBMVFC_INVALID_PARAMETER, DID_ERROR, 0, 1, "invalid parameter" },
  110. { IBMVFC_VIOS_FAILURE, IBMVFC_MISSING_PARAMETER, DID_ERROR, 0, 1, "missing parameter" },
  111. { IBMVFC_VIOS_FAILURE, IBMVFC_HOST_IO_BUS, DID_ERROR, 1, 1, "host I/O bus failure" },
  112. { IBMVFC_VIOS_FAILURE, IBMVFC_TRANS_CANCELLED, DID_ERROR, 0, 1, "transaction cancelled" },
  113. { IBMVFC_VIOS_FAILURE, IBMVFC_TRANS_CANCELLED_IMPLICIT, DID_ERROR, 0, 1, "transaction cancelled implicit" },
  114. { IBMVFC_VIOS_FAILURE, IBMVFC_INSUFFICIENT_RESOURCE, DID_REQUEUE, 1, 1, "insufficient resources" },
  115. { IBMVFC_VIOS_FAILURE, IBMVFC_PLOGI_REQUIRED, DID_ERROR, 0, 1, "port login required" },
  116. { IBMVFC_VIOS_FAILURE, IBMVFC_COMMAND_FAILED, DID_ERROR, 1, 1, "command failed" },
  117. { IBMVFC_FC_FAILURE, IBMVFC_INVALID_ELS_CMD_CODE, DID_ERROR, 0, 1, "invalid ELS command code" },
  118. { IBMVFC_FC_FAILURE, IBMVFC_INVALID_VERSION, DID_ERROR, 0, 1, "invalid version level" },
  119. { IBMVFC_FC_FAILURE, IBMVFC_LOGICAL_ERROR, DID_ERROR, 1, 1, "logical error" },
  120. { IBMVFC_FC_FAILURE, IBMVFC_INVALID_CT_IU_SIZE, DID_ERROR, 0, 1, "invalid CT_IU size" },
  121. { IBMVFC_FC_FAILURE, IBMVFC_LOGICAL_BUSY, DID_REQUEUE, 1, 0, "logical busy" },
  122. { IBMVFC_FC_FAILURE, IBMVFC_PROTOCOL_ERROR, DID_ERROR, 1, 1, "protocol error" },
  123. { IBMVFC_FC_FAILURE, IBMVFC_UNABLE_TO_PERFORM_REQ, DID_ERROR, 1, 1, "unable to perform request" },
  124. { IBMVFC_FC_FAILURE, IBMVFC_CMD_NOT_SUPPORTED, DID_ERROR, 0, 0, "command not supported" },
  125. { IBMVFC_FC_FAILURE, IBMVFC_SERVER_NOT_AVAIL, DID_ERROR, 0, 1, "server not available" },
  126. { IBMVFC_FC_FAILURE, IBMVFC_CMD_IN_PROGRESS, DID_ERROR, 0, 1, "command already in progress" },
  127. { IBMVFC_FC_FAILURE, IBMVFC_VENDOR_SPECIFIC, DID_ERROR, 1, 1, "vendor specific" },
  128. { IBMVFC_FC_SCSI_ERROR, 0, DID_OK, 1, 0, "SCSI error" },
  129. };
  130. static void ibmvfc_npiv_login(struct ibmvfc_host *);
  131. static void ibmvfc_tgt_send_prli(struct ibmvfc_target *);
  132. static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *);
  133. static void ibmvfc_tgt_query_target(struct ibmvfc_target *);
  134. static void ibmvfc_npiv_logout(struct ibmvfc_host *);
  135. static const char *unknown_error = "unknown error";
  136. #ifdef CONFIG_SCSI_IBMVFC_TRACE
  137. /**
  138. * ibmvfc_trc_start - Log a start trace entry
  139. * @evt: ibmvfc event struct
  140. *
  141. **/
  142. static void ibmvfc_trc_start(struct ibmvfc_event *evt)
  143. {
  144. struct ibmvfc_host *vhost = evt->vhost;
  145. struct ibmvfc_cmd *vfc_cmd = &evt->iu.cmd;
  146. struct ibmvfc_mad_common *mad = &evt->iu.mad_common;
  147. struct ibmvfc_trace_entry *entry;
  148. entry = &vhost->trace[vhost->trace_index++];
  149. entry->evt = evt;
  150. entry->time = jiffies;
  151. entry->fmt = evt->crq.format;
  152. entry->type = IBMVFC_TRC_START;
  153. switch (entry->fmt) {
  154. case IBMVFC_CMD_FORMAT:
  155. entry->op_code = vfc_cmd->iu.cdb[0];
  156. entry->scsi_id = vfc_cmd->tgt_scsi_id;
  157. entry->lun = scsilun_to_int(&vfc_cmd->iu.lun);
  158. entry->tmf_flags = vfc_cmd->iu.tmf_flags;
  159. entry->u.start.xfer_len = vfc_cmd->iu.xfer_len;
  160. break;
  161. case IBMVFC_MAD_FORMAT:
  162. entry->op_code = mad->opcode;
  163. break;
  164. default:
  165. break;
  166. };
  167. }
  168. /**
  169. * ibmvfc_trc_end - Log an end trace entry
  170. * @evt: ibmvfc event struct
  171. *
  172. **/
  173. static void ibmvfc_trc_end(struct ibmvfc_event *evt)
  174. {
  175. struct ibmvfc_host *vhost = evt->vhost;
  176. struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
  177. struct ibmvfc_mad_common *mad = &evt->xfer_iu->mad_common;
  178. struct ibmvfc_trace_entry *entry = &vhost->trace[vhost->trace_index++];
  179. entry->evt = evt;
  180. entry->time = jiffies;
  181. entry->fmt = evt->crq.format;
  182. entry->type = IBMVFC_TRC_END;
  183. switch (entry->fmt) {
  184. case IBMVFC_CMD_FORMAT:
  185. entry->op_code = vfc_cmd->iu.cdb[0];
  186. entry->scsi_id = vfc_cmd->tgt_scsi_id;
  187. entry->lun = scsilun_to_int(&vfc_cmd->iu.lun);
  188. entry->tmf_flags = vfc_cmd->iu.tmf_flags;
  189. entry->u.end.status = vfc_cmd->status;
  190. entry->u.end.error = vfc_cmd->error;
  191. entry->u.end.fcp_rsp_flags = vfc_cmd->rsp.flags;
  192. entry->u.end.rsp_code = vfc_cmd->rsp.data.info.rsp_code;
  193. entry->u.end.scsi_status = vfc_cmd->rsp.scsi_status;
  194. break;
  195. case IBMVFC_MAD_FORMAT:
  196. entry->op_code = mad->opcode;
  197. entry->u.end.status = mad->status;
  198. break;
  199. default:
  200. break;
  201. };
  202. }
  203. #else
  204. #define ibmvfc_trc_start(evt) do { } while (0)
  205. #define ibmvfc_trc_end(evt) do { } while (0)
  206. #endif
  207. /**
  208. * ibmvfc_get_err_index - Find the index into cmd_status for the fcp response
  209. * @status: status / error class
  210. * @error: error
  211. *
  212. * Return value:
  213. * index into cmd_status / -EINVAL on failure
  214. **/
  215. static int ibmvfc_get_err_index(u16 status, u16 error)
  216. {
  217. int i;
  218. for (i = 0; i < ARRAY_SIZE(cmd_status); i++)
  219. if ((cmd_status[i].status & status) == cmd_status[i].status &&
  220. cmd_status[i].error == error)
  221. return i;
  222. return -EINVAL;
  223. }
  224. /**
  225. * ibmvfc_get_cmd_error - Find the error description for the fcp response
  226. * @status: status / error class
  227. * @error: error
  228. *
  229. * Return value:
  230. * error description string
  231. **/
  232. static const char *ibmvfc_get_cmd_error(u16 status, u16 error)
  233. {
  234. int rc = ibmvfc_get_err_index(status, error);
  235. if (rc >= 0)
  236. return cmd_status[rc].name;
  237. return unknown_error;
  238. }
  239. /**
  240. * ibmvfc_get_err_result - Find the scsi status to return for the fcp response
  241. * @vfc_cmd: ibmvfc command struct
  242. *
  243. * Return value:
  244. * SCSI result value to return for completed command
  245. **/
  246. static int ibmvfc_get_err_result(struct ibmvfc_cmd *vfc_cmd)
  247. {
  248. int err;
  249. struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
  250. int fc_rsp_len = rsp->fcp_rsp_len;
  251. if ((rsp->flags & FCP_RSP_LEN_VALID) &&
  252. ((fc_rsp_len && fc_rsp_len != 4 && fc_rsp_len != 8) ||
  253. rsp->data.info.rsp_code))
  254. return DID_ERROR << 16;
  255. err = ibmvfc_get_err_index(vfc_cmd->status, vfc_cmd->error);
  256. if (err >= 0)
  257. return rsp->scsi_status | (cmd_status[err].result << 16);
  258. return rsp->scsi_status | (DID_ERROR << 16);
  259. }
  260. /**
  261. * ibmvfc_retry_cmd - Determine if error status is retryable
  262. * @status: status / error class
  263. * @error: error
  264. *
  265. * Return value:
  266. * 1 if error should be retried / 0 if it should not
  267. **/
  268. static int ibmvfc_retry_cmd(u16 status, u16 error)
  269. {
  270. int rc = ibmvfc_get_err_index(status, error);
  271. if (rc >= 0)
  272. return cmd_status[rc].retry;
  273. return 1;
  274. }
  275. static const char *unknown_fc_explain = "unknown fc explain";
  276. static const struct {
  277. u16 fc_explain;
  278. char *name;
  279. } ls_explain [] = {
  280. { 0x00, "no additional explanation" },
  281. { 0x01, "service parameter error - options" },
  282. { 0x03, "service parameter error - initiator control" },
  283. { 0x05, "service parameter error - recipient control" },
  284. { 0x07, "service parameter error - received data field size" },
  285. { 0x09, "service parameter error - concurrent seq" },
  286. { 0x0B, "service parameter error - credit" },
  287. { 0x0D, "invalid N_Port/F_Port_Name" },
  288. { 0x0E, "invalid node/Fabric Name" },
  289. { 0x0F, "invalid common service parameters" },
  290. { 0x11, "invalid association header" },
  291. { 0x13, "association header required" },
  292. { 0x15, "invalid originator S_ID" },
  293. { 0x17, "invalid OX_ID-RX-ID combination" },
  294. { 0x19, "command (request) already in progress" },
  295. { 0x1E, "N_Port Login requested" },
  296. { 0x1F, "Invalid N_Port_ID" },
  297. };
  298. static const struct {
  299. u16 fc_explain;
  300. char *name;
  301. } gs_explain [] = {
  302. { 0x00, "no additional explanation" },
  303. { 0x01, "port identifier not registered" },
  304. { 0x02, "port name not registered" },
  305. { 0x03, "node name not registered" },
  306. { 0x04, "class of service not registered" },
  307. { 0x06, "initial process associator not registered" },
  308. { 0x07, "FC-4 TYPEs not registered" },
  309. { 0x08, "symbolic port name not registered" },
  310. { 0x09, "symbolic node name not registered" },
  311. { 0x0A, "port type not registered" },
  312. { 0xF0, "authorization exception" },
  313. { 0xF1, "authentication exception" },
  314. { 0xF2, "data base full" },
  315. { 0xF3, "data base empty" },
  316. { 0xF4, "processing request" },
  317. { 0xF5, "unable to verify connection" },
  318. { 0xF6, "devices not in a common zone" },
  319. };
  320. /**
  321. * ibmvfc_get_ls_explain - Return the FC Explain description text
  322. * @status: FC Explain status
  323. *
  324. * Returns:
  325. * error string
  326. **/
  327. static const char *ibmvfc_get_ls_explain(u16 status)
  328. {
  329. int i;
  330. for (i = 0; i < ARRAY_SIZE(ls_explain); i++)
  331. if (ls_explain[i].fc_explain == status)
  332. return ls_explain[i].name;
  333. return unknown_fc_explain;
  334. }
  335. /**
  336. * ibmvfc_get_gs_explain - Return the FC Explain description text
  337. * @status: FC Explain status
  338. *
  339. * Returns:
  340. * error string
  341. **/
  342. static const char *ibmvfc_get_gs_explain(u16 status)
  343. {
  344. int i;
  345. for (i = 0; i < ARRAY_SIZE(gs_explain); i++)
  346. if (gs_explain[i].fc_explain == status)
  347. return gs_explain[i].name;
  348. return unknown_fc_explain;
  349. }
  350. static const struct {
  351. enum ibmvfc_fc_type fc_type;
  352. char *name;
  353. } fc_type [] = {
  354. { IBMVFC_FABRIC_REJECT, "fabric reject" },
  355. { IBMVFC_PORT_REJECT, "port reject" },
  356. { IBMVFC_LS_REJECT, "ELS reject" },
  357. { IBMVFC_FABRIC_BUSY, "fabric busy" },
  358. { IBMVFC_PORT_BUSY, "port busy" },
  359. { IBMVFC_BASIC_REJECT, "basic reject" },
  360. };
  361. static const char *unknown_fc_type = "unknown fc type";
  362. /**
  363. * ibmvfc_get_fc_type - Return the FC Type description text
  364. * @status: FC Type error status
  365. *
  366. * Returns:
  367. * error string
  368. **/
  369. static const char *ibmvfc_get_fc_type(u16 status)
  370. {
  371. int i;
  372. for (i = 0; i < ARRAY_SIZE(fc_type); i++)
  373. if (fc_type[i].fc_type == status)
  374. return fc_type[i].name;
  375. return unknown_fc_type;
  376. }
  377. /**
  378. * ibmvfc_set_tgt_action - Set the next init action for the target
  379. * @tgt: ibmvfc target struct
  380. * @action: action to perform
  381. *
  382. **/
  383. static void ibmvfc_set_tgt_action(struct ibmvfc_target *tgt,
  384. enum ibmvfc_target_action action)
  385. {
  386. switch (tgt->action) {
  387. case IBMVFC_TGT_ACTION_DEL_RPORT:
  388. if (action == IBMVFC_TGT_ACTION_DELETED_RPORT)
  389. tgt->action = action;
  390. case IBMVFC_TGT_ACTION_DELETED_RPORT:
  391. break;
  392. default:
  393. if (action == IBMVFC_TGT_ACTION_DEL_RPORT)
  394. tgt->add_rport = 0;
  395. tgt->action = action;
  396. break;
  397. }
  398. }
  399. /**
  400. * ibmvfc_set_host_state - Set the state for the host
  401. * @vhost: ibmvfc host struct
  402. * @state: state to set host to
  403. *
  404. * Returns:
  405. * 0 if state changed / non-zero if not changed
  406. **/
  407. static int ibmvfc_set_host_state(struct ibmvfc_host *vhost,
  408. enum ibmvfc_host_state state)
  409. {
  410. int rc = 0;
  411. switch (vhost->state) {
  412. case IBMVFC_HOST_OFFLINE:
  413. rc = -EINVAL;
  414. break;
  415. default:
  416. vhost->state = state;
  417. break;
  418. };
  419. return rc;
  420. }
  421. /**
  422. * ibmvfc_set_host_action - Set the next init action for the host
  423. * @vhost: ibmvfc host struct
  424. * @action: action to perform
  425. *
  426. **/
  427. static void ibmvfc_set_host_action(struct ibmvfc_host *vhost,
  428. enum ibmvfc_host_action action)
  429. {
  430. switch (action) {
  431. case IBMVFC_HOST_ACTION_ALLOC_TGTS:
  432. if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT)
  433. vhost->action = action;
  434. break;
  435. case IBMVFC_HOST_ACTION_LOGO_WAIT:
  436. if (vhost->action == IBMVFC_HOST_ACTION_LOGO)
  437. vhost->action = action;
  438. break;
  439. case IBMVFC_HOST_ACTION_INIT_WAIT:
  440. if (vhost->action == IBMVFC_HOST_ACTION_INIT)
  441. vhost->action = action;
  442. break;
  443. case IBMVFC_HOST_ACTION_QUERY:
  444. switch (vhost->action) {
  445. case IBMVFC_HOST_ACTION_INIT_WAIT:
  446. case IBMVFC_HOST_ACTION_NONE:
  447. case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
  448. vhost->action = action;
  449. break;
  450. default:
  451. break;
  452. };
  453. break;
  454. case IBMVFC_HOST_ACTION_TGT_INIT:
  455. if (vhost->action == IBMVFC_HOST_ACTION_ALLOC_TGTS)
  456. vhost->action = action;
  457. break;
  458. case IBMVFC_HOST_ACTION_INIT:
  459. case IBMVFC_HOST_ACTION_TGT_DEL:
  460. switch (vhost->action) {
  461. case IBMVFC_HOST_ACTION_RESET:
  462. case IBMVFC_HOST_ACTION_REENABLE:
  463. break;
  464. default:
  465. vhost->action = action;
  466. break;
  467. };
  468. break;
  469. case IBMVFC_HOST_ACTION_LOGO:
  470. case IBMVFC_HOST_ACTION_QUERY_TGTS:
  471. case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
  472. case IBMVFC_HOST_ACTION_NONE:
  473. case IBMVFC_HOST_ACTION_RESET:
  474. case IBMVFC_HOST_ACTION_REENABLE:
  475. default:
  476. vhost->action = action;
  477. break;
  478. };
  479. }
  480. /**
  481. * ibmvfc_reinit_host - Re-start host initialization (no NPIV Login)
  482. * @vhost: ibmvfc host struct
  483. *
  484. * Return value:
  485. * nothing
  486. **/
  487. static void ibmvfc_reinit_host(struct ibmvfc_host *vhost)
  488. {
  489. if (vhost->action == IBMVFC_HOST_ACTION_NONE) {
  490. if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
  491. scsi_block_requests(vhost->host);
  492. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
  493. }
  494. } else
  495. vhost->reinit = 1;
  496. wake_up(&vhost->work_wait_q);
  497. }
  498. /**
  499. * ibmvfc_link_down - Handle a link down event from the adapter
  500. * @vhost: ibmvfc host struct
  501. * @state: ibmvfc host state to enter
  502. *
  503. **/
  504. static void ibmvfc_link_down(struct ibmvfc_host *vhost,
  505. enum ibmvfc_host_state state)
  506. {
  507. struct ibmvfc_target *tgt;
  508. ENTER;
  509. scsi_block_requests(vhost->host);
  510. list_for_each_entry(tgt, &vhost->targets, queue)
  511. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  512. ibmvfc_set_host_state(vhost, state);
  513. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
  514. vhost->events_to_log |= IBMVFC_AE_LINKDOWN;
  515. wake_up(&vhost->work_wait_q);
  516. LEAVE;
  517. }
  518. /**
  519. * ibmvfc_init_host - Start host initialization
  520. * @vhost: ibmvfc host struct
  521. *
  522. * Return value:
  523. * nothing
  524. **/
  525. static void ibmvfc_init_host(struct ibmvfc_host *vhost)
  526. {
  527. struct ibmvfc_target *tgt;
  528. if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
  529. if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
  530. dev_err(vhost->dev,
  531. "Host initialization retries exceeded. Taking adapter offline\n");
  532. ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
  533. return;
  534. }
  535. }
  536. if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
  537. memset(vhost->async_crq.msgs, 0, PAGE_SIZE);
  538. vhost->async_crq.cur = 0;
  539. list_for_each_entry(tgt, &vhost->targets, queue)
  540. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  541. scsi_block_requests(vhost->host);
  542. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
  543. vhost->job_step = ibmvfc_npiv_login;
  544. wake_up(&vhost->work_wait_q);
  545. }
  546. }
  547. /**
  548. * ibmvfc_send_crq - Send a CRQ
  549. * @vhost: ibmvfc host struct
  550. * @word1: the first 64 bits of the data
  551. * @word2: the second 64 bits of the data
  552. *
  553. * Return value:
  554. * 0 on success / other on failure
  555. **/
  556. static int ibmvfc_send_crq(struct ibmvfc_host *vhost, u64 word1, u64 word2)
  557. {
  558. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  559. return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
  560. }
  561. /**
  562. * ibmvfc_send_crq_init - Send a CRQ init message
  563. * @vhost: ibmvfc host struct
  564. *
  565. * Return value:
  566. * 0 on success / other on failure
  567. **/
  568. static int ibmvfc_send_crq_init(struct ibmvfc_host *vhost)
  569. {
  570. ibmvfc_dbg(vhost, "Sending CRQ init\n");
  571. return ibmvfc_send_crq(vhost, 0xC001000000000000LL, 0);
  572. }
  573. /**
  574. * ibmvfc_send_crq_init_complete - Send a CRQ init complete message
  575. * @vhost: ibmvfc host struct
  576. *
  577. * Return value:
  578. * 0 on success / other on failure
  579. **/
  580. static int ibmvfc_send_crq_init_complete(struct ibmvfc_host *vhost)
  581. {
  582. ibmvfc_dbg(vhost, "Sending CRQ init complete\n");
  583. return ibmvfc_send_crq(vhost, 0xC002000000000000LL, 0);
  584. }
  585. /**
  586. * ibmvfc_release_crq_queue - Deallocates data and unregisters CRQ
  587. * @vhost: ibmvfc host struct
  588. *
  589. * Frees irq, deallocates a page for messages, unmaps dma, and unregisters
  590. * the crq with the hypervisor.
  591. **/
  592. static void ibmvfc_release_crq_queue(struct ibmvfc_host *vhost)
  593. {
  594. long rc = 0;
  595. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  596. struct ibmvfc_crq_queue *crq = &vhost->crq;
  597. ibmvfc_dbg(vhost, "Releasing CRQ\n");
  598. free_irq(vdev->irq, vhost);
  599. tasklet_kill(&vhost->tasklet);
  600. do {
  601. if (rc)
  602. msleep(100);
  603. rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
  604. } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
  605. vhost->state = IBMVFC_NO_CRQ;
  606. vhost->logged_in = 0;
  607. dma_unmap_single(vhost->dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
  608. free_page((unsigned long)crq->msgs);
  609. }
  610. /**
  611. * ibmvfc_reenable_crq_queue - reenables the CRQ
  612. * @vhost: ibmvfc host struct
  613. *
  614. * Return value:
  615. * 0 on success / other on failure
  616. **/
  617. static int ibmvfc_reenable_crq_queue(struct ibmvfc_host *vhost)
  618. {
  619. int rc = 0;
  620. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  621. /* Re-enable the CRQ */
  622. do {
  623. if (rc)
  624. msleep(100);
  625. rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
  626. } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc));
  627. if (rc)
  628. dev_err(vhost->dev, "Error enabling adapter (rc=%d)\n", rc);
  629. return rc;
  630. }
  631. /**
  632. * ibmvfc_reset_crq - resets a crq after a failure
  633. * @vhost: ibmvfc host struct
  634. *
  635. * Return value:
  636. * 0 on success / other on failure
  637. **/
  638. static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)
  639. {
  640. int rc = 0;
  641. unsigned long flags;
  642. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  643. struct ibmvfc_crq_queue *crq = &vhost->crq;
  644. /* Close the CRQ */
  645. do {
  646. if (rc)
  647. msleep(100);
  648. rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
  649. } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
  650. spin_lock_irqsave(vhost->host->host_lock, flags);
  651. vhost->state = IBMVFC_NO_CRQ;
  652. vhost->logged_in = 0;
  653. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
  654. /* Clean out the queue */
  655. memset(crq->msgs, 0, PAGE_SIZE);
  656. crq->cur = 0;
  657. /* And re-open it again */
  658. rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
  659. crq->msg_token, PAGE_SIZE);
  660. if (rc == H_CLOSED)
  661. /* Adapter is good, but other end is not ready */
  662. dev_warn(vhost->dev, "Partner adapter not ready\n");
  663. else if (rc != 0)
  664. dev_warn(vhost->dev, "Couldn't register crq (rc=%d)\n", rc);
  665. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  666. return rc;
  667. }
  668. /**
  669. * ibmvfc_valid_event - Determines if event is valid.
  670. * @pool: event_pool that contains the event
  671. * @evt: ibmvfc event to be checked for validity
  672. *
  673. * Return value:
  674. * 1 if event is valid / 0 if event is not valid
  675. **/
  676. static int ibmvfc_valid_event(struct ibmvfc_event_pool *pool,
  677. struct ibmvfc_event *evt)
  678. {
  679. int index = evt - pool->events;
  680. if (index < 0 || index >= pool->size) /* outside of bounds */
  681. return 0;
  682. if (evt != pool->events + index) /* unaligned */
  683. return 0;
  684. return 1;
  685. }
  686. /**
  687. * ibmvfc_free_event - Free the specified event
  688. * @evt: ibmvfc_event to be freed
  689. *
  690. **/
  691. static void ibmvfc_free_event(struct ibmvfc_event *evt)
  692. {
  693. struct ibmvfc_host *vhost = evt->vhost;
  694. struct ibmvfc_event_pool *pool = &vhost->pool;
  695. BUG_ON(!ibmvfc_valid_event(pool, evt));
  696. BUG_ON(atomic_inc_return(&evt->free) != 1);
  697. list_add_tail(&evt->queue, &vhost->free);
  698. }
  699. /**
  700. * ibmvfc_scsi_eh_done - EH done function for queuecommand commands
  701. * @evt: ibmvfc event struct
  702. *
  703. * This function does not setup any error status, that must be done
  704. * before this function gets called.
  705. **/
  706. static void ibmvfc_scsi_eh_done(struct ibmvfc_event *evt)
  707. {
  708. struct scsi_cmnd *cmnd = evt->cmnd;
  709. if (cmnd) {
  710. scsi_dma_unmap(cmnd);
  711. cmnd->scsi_done(cmnd);
  712. }
  713. if (evt->eh_comp)
  714. complete(evt->eh_comp);
  715. ibmvfc_free_event(evt);
  716. }
  717. /**
  718. * ibmvfc_fail_request - Fail request with specified error code
  719. * @evt: ibmvfc event struct
  720. * @error_code: error code to fail request with
  721. *
  722. * Return value:
  723. * none
  724. **/
  725. static void ibmvfc_fail_request(struct ibmvfc_event *evt, int error_code)
  726. {
  727. if (evt->cmnd) {
  728. evt->cmnd->result = (error_code << 16);
  729. evt->done = ibmvfc_scsi_eh_done;
  730. } else
  731. evt->xfer_iu->mad_common.status = IBMVFC_MAD_DRIVER_FAILED;
  732. list_del(&evt->queue);
  733. del_timer(&evt->timer);
  734. ibmvfc_trc_end(evt);
  735. evt->done(evt);
  736. }
  737. /**
  738. * ibmvfc_purge_requests - Our virtual adapter just shut down. Purge any sent requests
  739. * @vhost: ibmvfc host struct
  740. * @error_code: error code to fail requests with
  741. *
  742. * Return value:
  743. * none
  744. **/
  745. static void ibmvfc_purge_requests(struct ibmvfc_host *vhost, int error_code)
  746. {
  747. struct ibmvfc_event *evt, *pos;
  748. ibmvfc_dbg(vhost, "Purging all requests\n");
  749. list_for_each_entry_safe(evt, pos, &vhost->sent, queue)
  750. ibmvfc_fail_request(evt, error_code);
  751. }
  752. /**
  753. * ibmvfc_hard_reset_host - Reset the connection to the server by breaking the CRQ
  754. * @vhost: struct ibmvfc host to reset
  755. **/
  756. static void ibmvfc_hard_reset_host(struct ibmvfc_host *vhost)
  757. {
  758. ibmvfc_purge_requests(vhost, DID_ERROR);
  759. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  760. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_RESET);
  761. }
  762. /**
  763. * __ibmvfc_reset_host - Reset the connection to the server (no locking)
  764. * @vhost: struct ibmvfc host to reset
  765. **/
  766. static void __ibmvfc_reset_host(struct ibmvfc_host *vhost)
  767. {
  768. if (vhost->logged_in && vhost->action != IBMVFC_HOST_ACTION_LOGO_WAIT &&
  769. !ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
  770. scsi_block_requests(vhost->host);
  771. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO);
  772. vhost->job_step = ibmvfc_npiv_logout;
  773. wake_up(&vhost->work_wait_q);
  774. } else
  775. ibmvfc_hard_reset_host(vhost);
  776. }
  777. /**
  778. * ibmvfc_reset_host - Reset the connection to the server
  779. * @vhost: ibmvfc host struct
  780. **/
  781. static void ibmvfc_reset_host(struct ibmvfc_host *vhost)
  782. {
  783. unsigned long flags;
  784. spin_lock_irqsave(vhost->host->host_lock, flags);
  785. __ibmvfc_reset_host(vhost);
  786. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  787. }
  788. /**
  789. * ibmvfc_retry_host_init - Retry host initialization if allowed
  790. * @vhost: ibmvfc host struct
  791. *
  792. * Returns: 1 if init will be retried / 0 if not
  793. *
  794. **/
  795. static int ibmvfc_retry_host_init(struct ibmvfc_host *vhost)
  796. {
  797. int retry = 0;
  798. if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
  799. vhost->delay_init = 1;
  800. if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
  801. dev_err(vhost->dev,
  802. "Host initialization retries exceeded. Taking adapter offline\n");
  803. ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
  804. } else if (vhost->init_retries == IBMVFC_MAX_HOST_INIT_RETRIES)
  805. __ibmvfc_reset_host(vhost);
  806. else {
  807. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
  808. retry = 1;
  809. }
  810. }
  811. wake_up(&vhost->work_wait_q);
  812. return retry;
  813. }
  814. /**
  815. * __ibmvfc_get_target - Find the specified scsi_target (no locking)
  816. * @starget: scsi target struct
  817. *
  818. * Return value:
  819. * ibmvfc_target struct / NULL if not found
  820. **/
  821. static struct ibmvfc_target *__ibmvfc_get_target(struct scsi_target *starget)
  822. {
  823. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  824. struct ibmvfc_host *vhost = shost_priv(shost);
  825. struct ibmvfc_target *tgt;
  826. list_for_each_entry(tgt, &vhost->targets, queue)
  827. if (tgt->target_id == starget->id) {
  828. kref_get(&tgt->kref);
  829. return tgt;
  830. }
  831. return NULL;
  832. }
  833. /**
  834. * ibmvfc_get_target - Find the specified scsi_target
  835. * @starget: scsi target struct
  836. *
  837. * Return value:
  838. * ibmvfc_target struct / NULL if not found
  839. **/
  840. static struct ibmvfc_target *ibmvfc_get_target(struct scsi_target *starget)
  841. {
  842. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  843. struct ibmvfc_target *tgt;
  844. unsigned long flags;
  845. spin_lock_irqsave(shost->host_lock, flags);
  846. tgt = __ibmvfc_get_target(starget);
  847. spin_unlock_irqrestore(shost->host_lock, flags);
  848. return tgt;
  849. }
  850. /**
  851. * ibmvfc_get_host_speed - Get host port speed
  852. * @shost: scsi host struct
  853. *
  854. * Return value:
  855. * none
  856. **/
  857. static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
  858. {
  859. struct ibmvfc_host *vhost = shost_priv(shost);
  860. unsigned long flags;
  861. spin_lock_irqsave(shost->host_lock, flags);
  862. if (vhost->state == IBMVFC_ACTIVE) {
  863. switch (vhost->login_buf->resp.link_speed / 100) {
  864. case 1:
  865. fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
  866. break;
  867. case 2:
  868. fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
  869. break;
  870. case 4:
  871. fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
  872. break;
  873. case 8:
  874. fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
  875. break;
  876. case 10:
  877. fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
  878. break;
  879. case 16:
  880. fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
  881. break;
  882. default:
  883. ibmvfc_log(vhost, 3, "Unknown port speed: %lld Gbit\n",
  884. vhost->login_buf->resp.link_speed / 100);
  885. fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
  886. break;
  887. }
  888. } else
  889. fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
  890. spin_unlock_irqrestore(shost->host_lock, flags);
  891. }
  892. /**
  893. * ibmvfc_get_host_port_state - Get host port state
  894. * @shost: scsi host struct
  895. *
  896. * Return value:
  897. * none
  898. **/
  899. static void ibmvfc_get_host_port_state(struct Scsi_Host *shost)
  900. {
  901. struct ibmvfc_host *vhost = shost_priv(shost);
  902. unsigned long flags;
  903. spin_lock_irqsave(shost->host_lock, flags);
  904. switch (vhost->state) {
  905. case IBMVFC_INITIALIZING:
  906. case IBMVFC_ACTIVE:
  907. fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
  908. break;
  909. case IBMVFC_LINK_DOWN:
  910. fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
  911. break;
  912. case IBMVFC_LINK_DEAD:
  913. case IBMVFC_HOST_OFFLINE:
  914. fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
  915. break;
  916. case IBMVFC_HALTED:
  917. fc_host_port_state(shost) = FC_PORTSTATE_BLOCKED;
  918. break;
  919. case IBMVFC_NO_CRQ:
  920. fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
  921. break;
  922. default:
  923. ibmvfc_log(vhost, 3, "Unknown port state: %d\n", vhost->state);
  924. fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
  925. break;
  926. }
  927. spin_unlock_irqrestore(shost->host_lock, flags);
  928. }
  929. /**
  930. * ibmvfc_set_rport_dev_loss_tmo - Set rport's device loss timeout
  931. * @rport: rport struct
  932. * @timeout: timeout value
  933. *
  934. * Return value:
  935. * none
  936. **/
  937. static void ibmvfc_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
  938. {
  939. if (timeout)
  940. rport->dev_loss_tmo = timeout;
  941. else
  942. rport->dev_loss_tmo = 1;
  943. }
  944. /**
  945. * ibmvfc_release_tgt - Free memory allocated for a target
  946. * @kref: kref struct
  947. *
  948. **/
  949. static void ibmvfc_release_tgt(struct kref *kref)
  950. {
  951. struct ibmvfc_target *tgt = container_of(kref, struct ibmvfc_target, kref);
  952. kfree(tgt);
  953. }
  954. /**
  955. * ibmvfc_get_starget_node_name - Get SCSI target's node name
  956. * @starget: scsi target struct
  957. *
  958. * Return value:
  959. * none
  960. **/
  961. static void ibmvfc_get_starget_node_name(struct scsi_target *starget)
  962. {
  963. struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
  964. fc_starget_port_name(starget) = tgt ? tgt->ids.node_name : 0;
  965. if (tgt)
  966. kref_put(&tgt->kref, ibmvfc_release_tgt);
  967. }
  968. /**
  969. * ibmvfc_get_starget_port_name - Get SCSI target's port name
  970. * @starget: scsi target struct
  971. *
  972. * Return value:
  973. * none
  974. **/
  975. static void ibmvfc_get_starget_port_name(struct scsi_target *starget)
  976. {
  977. struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
  978. fc_starget_port_name(starget) = tgt ? tgt->ids.port_name : 0;
  979. if (tgt)
  980. kref_put(&tgt->kref, ibmvfc_release_tgt);
  981. }
  982. /**
  983. * ibmvfc_get_starget_port_id - Get SCSI target's port ID
  984. * @starget: scsi target struct
  985. *
  986. * Return value:
  987. * none
  988. **/
  989. static void ibmvfc_get_starget_port_id(struct scsi_target *starget)
  990. {
  991. struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
  992. fc_starget_port_id(starget) = tgt ? tgt->scsi_id : -1;
  993. if (tgt)
  994. kref_put(&tgt->kref, ibmvfc_release_tgt);
  995. }
  996. /**
  997. * ibmvfc_wait_while_resetting - Wait while the host resets
  998. * @vhost: ibmvfc host struct
  999. *
  1000. * Return value:
  1001. * 0 on success / other on failure
  1002. **/
  1003. static int ibmvfc_wait_while_resetting(struct ibmvfc_host *vhost)
  1004. {
  1005. long timeout = wait_event_timeout(vhost->init_wait_q,
  1006. ((vhost->state == IBMVFC_ACTIVE ||
  1007. vhost->state == IBMVFC_HOST_OFFLINE ||
  1008. vhost->state == IBMVFC_LINK_DEAD) &&
  1009. vhost->action == IBMVFC_HOST_ACTION_NONE),
  1010. (init_timeout * HZ));
  1011. return timeout ? 0 : -EIO;
  1012. }
  1013. /**
  1014. * ibmvfc_issue_fc_host_lip - Re-initiate link initialization
  1015. * @shost: scsi host struct
  1016. *
  1017. * Return value:
  1018. * 0 on success / other on failure
  1019. **/
  1020. static int ibmvfc_issue_fc_host_lip(struct Scsi_Host *shost)
  1021. {
  1022. struct ibmvfc_host *vhost = shost_priv(shost);
  1023. dev_err(vhost->dev, "Initiating host LIP. Resetting connection\n");
  1024. ibmvfc_reset_host(vhost);
  1025. return ibmvfc_wait_while_resetting(vhost);
  1026. }
  1027. /**
  1028. * ibmvfc_gather_partition_info - Gather info about the LPAR
  1029. *
  1030. * Return value:
  1031. * none
  1032. **/
  1033. static void ibmvfc_gather_partition_info(struct ibmvfc_host *vhost)
  1034. {
  1035. struct device_node *rootdn;
  1036. const char *name;
  1037. const unsigned int *num;
  1038. rootdn = of_find_node_by_path("/");
  1039. if (!rootdn)
  1040. return;
  1041. name = of_get_property(rootdn, "ibm,partition-name", NULL);
  1042. if (name)
  1043. strncpy(vhost->partition_name, name, sizeof(vhost->partition_name));
  1044. num = of_get_property(rootdn, "ibm,partition-no", NULL);
  1045. if (num)
  1046. vhost->partition_number = *num;
  1047. of_node_put(rootdn);
  1048. }
  1049. /**
  1050. * ibmvfc_set_login_info - Setup info for NPIV login
  1051. * @vhost: ibmvfc host struct
  1052. *
  1053. * Return value:
  1054. * none
  1055. **/
  1056. static void ibmvfc_set_login_info(struct ibmvfc_host *vhost)
  1057. {
  1058. struct ibmvfc_npiv_login *login_info = &vhost->login_info;
  1059. struct device_node *of_node = vhost->dev->of_node;
  1060. const char *location;
  1061. memset(login_info, 0, sizeof(*login_info));
  1062. login_info->ostype = IBMVFC_OS_LINUX;
  1063. login_info->max_dma_len = IBMVFC_MAX_SECTORS << 9;
  1064. login_info->max_payload = sizeof(struct ibmvfc_fcp_cmd_iu);
  1065. login_info->max_response = sizeof(struct ibmvfc_fcp_rsp);
  1066. login_info->partition_num = vhost->partition_number;
  1067. login_info->vfc_frame_version = 1;
  1068. login_info->fcp_version = 3;
  1069. login_info->flags = IBMVFC_FLUSH_ON_HALT;
  1070. if (vhost->client_migrated)
  1071. login_info->flags |= IBMVFC_CLIENT_MIGRATED;
  1072. login_info->max_cmds = max_requests + IBMVFC_NUM_INTERNAL_REQ;
  1073. login_info->capabilities = IBMVFC_CAN_MIGRATE;
  1074. login_info->async.va = vhost->async_crq.msg_token;
  1075. login_info->async.len = vhost->async_crq.size * sizeof(*vhost->async_crq.msgs);
  1076. strncpy(login_info->partition_name, vhost->partition_name, IBMVFC_MAX_NAME);
  1077. strncpy(login_info->device_name,
  1078. dev_name(&vhost->host->shost_gendev), IBMVFC_MAX_NAME);
  1079. location = of_get_property(of_node, "ibm,loc-code", NULL);
  1080. location = location ? location : dev_name(vhost->dev);
  1081. strncpy(login_info->drc_name, location, IBMVFC_MAX_NAME);
  1082. }
  1083. /**
  1084. * ibmvfc_init_event_pool - Allocates and initializes the event pool for a host
  1085. * @vhost: ibmvfc host who owns the event pool
  1086. *
  1087. * Returns zero on success.
  1088. **/
  1089. static int ibmvfc_init_event_pool(struct ibmvfc_host *vhost)
  1090. {
  1091. int i;
  1092. struct ibmvfc_event_pool *pool = &vhost->pool;
  1093. ENTER;
  1094. pool->size = max_requests + IBMVFC_NUM_INTERNAL_REQ;
  1095. pool->events = kcalloc(pool->size, sizeof(*pool->events), GFP_KERNEL);
  1096. if (!pool->events)
  1097. return -ENOMEM;
  1098. pool->iu_storage = dma_alloc_coherent(vhost->dev,
  1099. pool->size * sizeof(*pool->iu_storage),
  1100. &pool->iu_token, 0);
  1101. if (!pool->iu_storage) {
  1102. kfree(pool->events);
  1103. return -ENOMEM;
  1104. }
  1105. for (i = 0; i < pool->size; ++i) {
  1106. struct ibmvfc_event *evt = &pool->events[i];
  1107. atomic_set(&evt->free, 1);
  1108. evt->crq.valid = 0x80;
  1109. evt->crq.ioba = pool->iu_token + (sizeof(*evt->xfer_iu) * i);
  1110. evt->xfer_iu = pool->iu_storage + i;
  1111. evt->vhost = vhost;
  1112. evt->ext_list = NULL;
  1113. list_add_tail(&evt->queue, &vhost->free);
  1114. }
  1115. LEAVE;
  1116. return 0;
  1117. }
  1118. /**
  1119. * ibmvfc_free_event_pool - Frees memory of the event pool of a host
  1120. * @vhost: ibmvfc host who owns the event pool
  1121. *
  1122. **/
  1123. static void ibmvfc_free_event_pool(struct ibmvfc_host *vhost)
  1124. {
  1125. int i;
  1126. struct ibmvfc_event_pool *pool = &vhost->pool;
  1127. ENTER;
  1128. for (i = 0; i < pool->size; ++i) {
  1129. list_del(&pool->events[i].queue);
  1130. BUG_ON(atomic_read(&pool->events[i].free) != 1);
  1131. if (pool->events[i].ext_list)
  1132. dma_pool_free(vhost->sg_pool,
  1133. pool->events[i].ext_list,
  1134. pool->events[i].ext_list_token);
  1135. }
  1136. kfree(pool->events);
  1137. dma_free_coherent(vhost->dev,
  1138. pool->size * sizeof(*pool->iu_storage),
  1139. pool->iu_storage, pool->iu_token);
  1140. LEAVE;
  1141. }
  1142. /**
  1143. * ibmvfc_get_event - Gets the next free event in pool
  1144. * @vhost: ibmvfc host struct
  1145. *
  1146. * Returns a free event from the pool.
  1147. **/
  1148. static struct ibmvfc_event *ibmvfc_get_event(struct ibmvfc_host *vhost)
  1149. {
  1150. struct ibmvfc_event *evt;
  1151. BUG_ON(list_empty(&vhost->free));
  1152. evt = list_entry(vhost->free.next, struct ibmvfc_event, queue);
  1153. atomic_set(&evt->free, 0);
  1154. list_del(&evt->queue);
  1155. return evt;
  1156. }
  1157. /**
  1158. * ibmvfc_init_event - Initialize fields in an event struct that are always
  1159. * required.
  1160. * @evt: The event
  1161. * @done: Routine to call when the event is responded to
  1162. * @format: SRP or MAD format
  1163. **/
  1164. static void ibmvfc_init_event(struct ibmvfc_event *evt,
  1165. void (*done) (struct ibmvfc_event *), u8 format)
  1166. {
  1167. evt->cmnd = NULL;
  1168. evt->sync_iu = NULL;
  1169. evt->crq.format = format;
  1170. evt->done = done;
  1171. evt->eh_comp = NULL;
  1172. }
  1173. /**
  1174. * ibmvfc_map_sg_list - Initialize scatterlist
  1175. * @scmd: scsi command struct
  1176. * @nseg: number of scatterlist segments
  1177. * @md: memory descriptor list to initialize
  1178. **/
  1179. static void ibmvfc_map_sg_list(struct scsi_cmnd *scmd, int nseg,
  1180. struct srp_direct_buf *md)
  1181. {
  1182. int i;
  1183. struct scatterlist *sg;
  1184. scsi_for_each_sg(scmd, sg, nseg, i) {
  1185. md[i].va = sg_dma_address(sg);
  1186. md[i].len = sg_dma_len(sg);
  1187. md[i].key = 0;
  1188. }
  1189. }
  1190. /**
  1191. * ibmvfc_map_sg_data - Maps dma for a scatterlist and initializes decriptor fields
  1192. * @scmd: Scsi_Cmnd with the scatterlist
  1193. * @evt: ibmvfc event struct
  1194. * @vfc_cmd: vfc_cmd that contains the memory descriptor
  1195. * @dev: device for which to map dma memory
  1196. *
  1197. * Returns:
  1198. * 0 on success / non-zero on failure
  1199. **/
  1200. static int ibmvfc_map_sg_data(struct scsi_cmnd *scmd,
  1201. struct ibmvfc_event *evt,
  1202. struct ibmvfc_cmd *vfc_cmd, struct device *dev)
  1203. {
  1204. int sg_mapped;
  1205. struct srp_direct_buf *data = &vfc_cmd->ioba;
  1206. struct ibmvfc_host *vhost = dev_get_drvdata(dev);
  1207. sg_mapped = scsi_dma_map(scmd);
  1208. if (!sg_mapped) {
  1209. vfc_cmd->flags |= IBMVFC_NO_MEM_DESC;
  1210. return 0;
  1211. } else if (unlikely(sg_mapped < 0)) {
  1212. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  1213. scmd_printk(KERN_ERR, scmd, "Failed to map DMA buffer for command\n");
  1214. return sg_mapped;
  1215. }
  1216. if (scmd->sc_data_direction == DMA_TO_DEVICE) {
  1217. vfc_cmd->flags |= IBMVFC_WRITE;
  1218. vfc_cmd->iu.add_cdb_len |= IBMVFC_WRDATA;
  1219. } else {
  1220. vfc_cmd->flags |= IBMVFC_READ;
  1221. vfc_cmd->iu.add_cdb_len |= IBMVFC_RDDATA;
  1222. }
  1223. if (sg_mapped == 1) {
  1224. ibmvfc_map_sg_list(scmd, sg_mapped, data);
  1225. return 0;
  1226. }
  1227. vfc_cmd->flags |= IBMVFC_SCATTERLIST;
  1228. if (!evt->ext_list) {
  1229. evt->ext_list = dma_pool_alloc(vhost->sg_pool, GFP_ATOMIC,
  1230. &evt->ext_list_token);
  1231. if (!evt->ext_list) {
  1232. scsi_dma_unmap(scmd);
  1233. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  1234. scmd_printk(KERN_ERR, scmd, "Can't allocate memory for scatterlist\n");
  1235. return -ENOMEM;
  1236. }
  1237. }
  1238. ibmvfc_map_sg_list(scmd, sg_mapped, evt->ext_list);
  1239. data->va = evt->ext_list_token;
  1240. data->len = sg_mapped * sizeof(struct srp_direct_buf);
  1241. data->key = 0;
  1242. return 0;
  1243. }
  1244. /**
  1245. * ibmvfc_timeout - Internal command timeout handler
  1246. * @evt: struct ibmvfc_event that timed out
  1247. *
  1248. * Called when an internally generated command times out
  1249. **/
  1250. static void ibmvfc_timeout(struct ibmvfc_event *evt)
  1251. {
  1252. struct ibmvfc_host *vhost = evt->vhost;
  1253. dev_err(vhost->dev, "Command timed out (%p). Resetting connection\n", evt);
  1254. ibmvfc_reset_host(vhost);
  1255. }
  1256. /**
  1257. * ibmvfc_send_event - Transforms event to u64 array and calls send_crq()
  1258. * @evt: event to be sent
  1259. * @vhost: ibmvfc host struct
  1260. * @timeout: timeout in seconds - 0 means do not time command
  1261. *
  1262. * Returns the value returned from ibmvfc_send_crq(). (Zero for success)
  1263. **/
  1264. static int ibmvfc_send_event(struct ibmvfc_event *evt,
  1265. struct ibmvfc_host *vhost, unsigned long timeout)
  1266. {
  1267. u64 *crq_as_u64 = (u64 *) &evt->crq;
  1268. int rc;
  1269. /* Copy the IU into the transfer area */
  1270. *evt->xfer_iu = evt->iu;
  1271. if (evt->crq.format == IBMVFC_CMD_FORMAT)
  1272. evt->xfer_iu->cmd.tag = (u64)evt;
  1273. else if (evt->crq.format == IBMVFC_MAD_FORMAT)
  1274. evt->xfer_iu->mad_common.tag = (u64)evt;
  1275. else
  1276. BUG();
  1277. list_add_tail(&evt->queue, &vhost->sent);
  1278. init_timer(&evt->timer);
  1279. if (timeout) {
  1280. evt->timer.data = (unsigned long) evt;
  1281. evt->timer.expires = jiffies + (timeout * HZ);
  1282. evt->timer.function = (void (*)(unsigned long))ibmvfc_timeout;
  1283. add_timer(&evt->timer);
  1284. }
  1285. mb();
  1286. if ((rc = ibmvfc_send_crq(vhost, crq_as_u64[0], crq_as_u64[1]))) {
  1287. list_del(&evt->queue);
  1288. del_timer(&evt->timer);
  1289. /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY.
  1290. * Firmware will send a CRQ with a transport event (0xFF) to
  1291. * tell this client what has happened to the transport. This
  1292. * will be handled in ibmvfc_handle_crq()
  1293. */
  1294. if (rc == H_CLOSED) {
  1295. if (printk_ratelimit())
  1296. dev_warn(vhost->dev, "Send warning. Receive queue closed, will retry.\n");
  1297. if (evt->cmnd)
  1298. scsi_dma_unmap(evt->cmnd);
  1299. ibmvfc_free_event(evt);
  1300. return SCSI_MLQUEUE_HOST_BUSY;
  1301. }
  1302. dev_err(vhost->dev, "Send error (rc=%d)\n", rc);
  1303. if (evt->cmnd) {
  1304. evt->cmnd->result = DID_ERROR << 16;
  1305. evt->done = ibmvfc_scsi_eh_done;
  1306. } else
  1307. evt->xfer_iu->mad_common.status = IBMVFC_MAD_CRQ_ERROR;
  1308. evt->done(evt);
  1309. } else
  1310. ibmvfc_trc_start(evt);
  1311. return 0;
  1312. }
  1313. /**
  1314. * ibmvfc_log_error - Log an error for the failed command if appropriate
  1315. * @evt: ibmvfc event to log
  1316. *
  1317. **/
  1318. static void ibmvfc_log_error(struct ibmvfc_event *evt)
  1319. {
  1320. struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
  1321. struct ibmvfc_host *vhost = evt->vhost;
  1322. struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
  1323. struct scsi_cmnd *cmnd = evt->cmnd;
  1324. const char *err = unknown_error;
  1325. int index = ibmvfc_get_err_index(vfc_cmd->status, vfc_cmd->error);
  1326. int logerr = 0;
  1327. int rsp_code = 0;
  1328. if (index >= 0) {
  1329. logerr = cmd_status[index].log;
  1330. err = cmd_status[index].name;
  1331. }
  1332. if (!logerr && (vhost->log_level <= (IBMVFC_DEFAULT_LOG_LEVEL + 1)))
  1333. return;
  1334. if (rsp->flags & FCP_RSP_LEN_VALID)
  1335. rsp_code = rsp->data.info.rsp_code;
  1336. scmd_printk(KERN_ERR, cmnd, "Command (%02X) failed: %s (%x:%x) "
  1337. "flags: %x fcp_rsp: %x, resid=%d, scsi_status: %x\n",
  1338. cmnd->cmnd[0], err, vfc_cmd->status, vfc_cmd->error,
  1339. rsp->flags, rsp_code, scsi_get_resid(cmnd), rsp->scsi_status);
  1340. }
  1341. /**
  1342. * ibmvfc_relogin - Log back into the specified device
  1343. * @sdev: scsi device struct
  1344. *
  1345. **/
  1346. static void ibmvfc_relogin(struct scsi_device *sdev)
  1347. {
  1348. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  1349. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  1350. struct ibmvfc_target *tgt;
  1351. list_for_each_entry(tgt, &vhost->targets, queue) {
  1352. if (rport == tgt->rport) {
  1353. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  1354. break;
  1355. }
  1356. }
  1357. ibmvfc_reinit_host(vhost);
  1358. }
  1359. /**
  1360. * ibmvfc_scsi_done - Handle responses from commands
  1361. * @evt: ibmvfc event to be handled
  1362. *
  1363. * Used as a callback when sending scsi cmds.
  1364. **/
  1365. static void ibmvfc_scsi_done(struct ibmvfc_event *evt)
  1366. {
  1367. struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
  1368. struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
  1369. struct scsi_cmnd *cmnd = evt->cmnd;
  1370. u32 rsp_len = 0;
  1371. u32 sense_len = rsp->fcp_sense_len;
  1372. if (cmnd) {
  1373. if (vfc_cmd->response_flags & IBMVFC_ADAPTER_RESID_VALID)
  1374. scsi_set_resid(cmnd, vfc_cmd->adapter_resid);
  1375. else if (rsp->flags & FCP_RESID_UNDER)
  1376. scsi_set_resid(cmnd, rsp->fcp_resid);
  1377. else
  1378. scsi_set_resid(cmnd, 0);
  1379. if (vfc_cmd->status) {
  1380. cmnd->result = ibmvfc_get_err_result(vfc_cmd);
  1381. if (rsp->flags & FCP_RSP_LEN_VALID)
  1382. rsp_len = rsp->fcp_rsp_len;
  1383. if ((sense_len + rsp_len) > SCSI_SENSE_BUFFERSIZE)
  1384. sense_len = SCSI_SENSE_BUFFERSIZE - rsp_len;
  1385. if ((rsp->flags & FCP_SNS_LEN_VALID) && rsp->fcp_sense_len && rsp_len <= 8)
  1386. memcpy(cmnd->sense_buffer, rsp->data.sense + rsp_len, sense_len);
  1387. if ((vfc_cmd->status & IBMVFC_VIOS_FAILURE) && (vfc_cmd->error == IBMVFC_PLOGI_REQUIRED))
  1388. ibmvfc_relogin(cmnd->device);
  1389. if (!cmnd->result && (!scsi_get_resid(cmnd) || (rsp->flags & FCP_RESID_OVER)))
  1390. cmnd->result = (DID_ERROR << 16);
  1391. ibmvfc_log_error(evt);
  1392. }
  1393. if (!cmnd->result &&
  1394. (scsi_bufflen(cmnd) - scsi_get_resid(cmnd) < cmnd->underflow))
  1395. cmnd->result = (DID_ERROR << 16);
  1396. scsi_dma_unmap(cmnd);
  1397. cmnd->scsi_done(cmnd);
  1398. }
  1399. if (evt->eh_comp)
  1400. complete(evt->eh_comp);
  1401. ibmvfc_free_event(evt);
  1402. }
  1403. /**
  1404. * ibmvfc_host_chkready - Check if the host can accept commands
  1405. * @vhost: struct ibmvfc host
  1406. *
  1407. * Returns:
  1408. * 1 if host can accept command / 0 if not
  1409. **/
  1410. static inline int ibmvfc_host_chkready(struct ibmvfc_host *vhost)
  1411. {
  1412. int result = 0;
  1413. switch (vhost->state) {
  1414. case IBMVFC_LINK_DEAD:
  1415. case IBMVFC_HOST_OFFLINE:
  1416. result = DID_NO_CONNECT << 16;
  1417. break;
  1418. case IBMVFC_NO_CRQ:
  1419. case IBMVFC_INITIALIZING:
  1420. case IBMVFC_HALTED:
  1421. case IBMVFC_LINK_DOWN:
  1422. result = DID_REQUEUE << 16;
  1423. break;
  1424. case IBMVFC_ACTIVE:
  1425. result = 0;
  1426. break;
  1427. };
  1428. return result;
  1429. }
  1430. /**
  1431. * ibmvfc_queuecommand - The queuecommand function of the scsi template
  1432. * @cmnd: struct scsi_cmnd to be executed
  1433. * @done: Callback function to be called when cmnd is completed
  1434. *
  1435. * Returns:
  1436. * 0 on success / other on failure
  1437. **/
  1438. static int ibmvfc_queuecommand_lck(struct scsi_cmnd *cmnd,
  1439. void (*done) (struct scsi_cmnd *))
  1440. {
  1441. struct ibmvfc_host *vhost = shost_priv(cmnd->device->host);
  1442. struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
  1443. struct ibmvfc_cmd *vfc_cmd;
  1444. struct ibmvfc_event *evt;
  1445. u8 tag[2];
  1446. int rc;
  1447. if (unlikely((rc = fc_remote_port_chkready(rport))) ||
  1448. unlikely((rc = ibmvfc_host_chkready(vhost)))) {
  1449. cmnd->result = rc;
  1450. done(cmnd);
  1451. return 0;
  1452. }
  1453. cmnd->result = (DID_OK << 16);
  1454. evt = ibmvfc_get_event(vhost);
  1455. ibmvfc_init_event(evt, ibmvfc_scsi_done, IBMVFC_CMD_FORMAT);
  1456. evt->cmnd = cmnd;
  1457. cmnd->scsi_done = done;
  1458. vfc_cmd = &evt->iu.cmd;
  1459. memset(vfc_cmd, 0, sizeof(*vfc_cmd));
  1460. vfc_cmd->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
  1461. vfc_cmd->resp.len = sizeof(vfc_cmd->rsp);
  1462. vfc_cmd->frame_type = IBMVFC_SCSI_FCP_TYPE;
  1463. vfc_cmd->payload_len = sizeof(vfc_cmd->iu);
  1464. vfc_cmd->resp_len = sizeof(vfc_cmd->rsp);
  1465. vfc_cmd->cancel_key = (unsigned long)cmnd->device->hostdata;
  1466. vfc_cmd->tgt_scsi_id = rport->port_id;
  1467. vfc_cmd->iu.xfer_len = scsi_bufflen(cmnd);
  1468. int_to_scsilun(cmnd->device->lun, &vfc_cmd->iu.lun);
  1469. memcpy(vfc_cmd->iu.cdb, cmnd->cmnd, cmnd->cmd_len);
  1470. if (scsi_populate_tag_msg(cmnd, tag)) {
  1471. vfc_cmd->task_tag = tag[1];
  1472. switch (tag[0]) {
  1473. case MSG_SIMPLE_TAG:
  1474. vfc_cmd->iu.pri_task_attr = IBMVFC_SIMPLE_TASK;
  1475. break;
  1476. case MSG_HEAD_TAG:
  1477. vfc_cmd->iu.pri_task_attr = IBMVFC_HEAD_OF_QUEUE;
  1478. break;
  1479. case MSG_ORDERED_TAG:
  1480. vfc_cmd->iu.pri_task_attr = IBMVFC_ORDERED_TASK;
  1481. break;
  1482. };
  1483. }
  1484. if (likely(!(rc = ibmvfc_map_sg_data(cmnd, evt, vfc_cmd, vhost->dev))))
  1485. return ibmvfc_send_event(evt, vhost, 0);
  1486. ibmvfc_free_event(evt);
  1487. if (rc == -ENOMEM)
  1488. return SCSI_MLQUEUE_HOST_BUSY;
  1489. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  1490. scmd_printk(KERN_ERR, cmnd,
  1491. "Failed to map DMA buffer for command. rc=%d\n", rc);
  1492. cmnd->result = DID_ERROR << 16;
  1493. done(cmnd);
  1494. return 0;
  1495. }
  1496. static DEF_SCSI_QCMD(ibmvfc_queuecommand)
  1497. /**
  1498. * ibmvfc_sync_completion - Signal that a synchronous command has completed
  1499. * @evt: ibmvfc event struct
  1500. *
  1501. **/
  1502. static void ibmvfc_sync_completion(struct ibmvfc_event *evt)
  1503. {
  1504. /* copy the response back */
  1505. if (evt->sync_iu)
  1506. *evt->sync_iu = *evt->xfer_iu;
  1507. complete(&evt->comp);
  1508. }
  1509. /**
  1510. * ibmvfc_bsg_timeout_done - Completion handler for cancelling BSG commands
  1511. * @evt: struct ibmvfc_event
  1512. *
  1513. **/
  1514. static void ibmvfc_bsg_timeout_done(struct ibmvfc_event *evt)
  1515. {
  1516. struct ibmvfc_host *vhost = evt->vhost;
  1517. ibmvfc_free_event(evt);
  1518. vhost->aborting_passthru = 0;
  1519. dev_info(vhost->dev, "Passthru command cancelled\n");
  1520. }
  1521. /**
  1522. * ibmvfc_bsg_timeout - Handle a BSG timeout
  1523. * @job: struct fc_bsg_job that timed out
  1524. *
  1525. * Returns:
  1526. * 0 on success / other on failure
  1527. **/
  1528. static int ibmvfc_bsg_timeout(struct fc_bsg_job *job)
  1529. {
  1530. struct ibmvfc_host *vhost = shost_priv(job->shost);
  1531. unsigned long port_id = (unsigned long)job->dd_data;
  1532. struct ibmvfc_event *evt;
  1533. struct ibmvfc_tmf *tmf;
  1534. unsigned long flags;
  1535. int rc;
  1536. ENTER;
  1537. spin_lock_irqsave(vhost->host->host_lock, flags);
  1538. if (vhost->aborting_passthru || vhost->state != IBMVFC_ACTIVE) {
  1539. __ibmvfc_reset_host(vhost);
  1540. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1541. return 0;
  1542. }
  1543. vhost->aborting_passthru = 1;
  1544. evt = ibmvfc_get_event(vhost);
  1545. ibmvfc_init_event(evt, ibmvfc_bsg_timeout_done, IBMVFC_MAD_FORMAT);
  1546. tmf = &evt->iu.tmf;
  1547. memset(tmf, 0, sizeof(*tmf));
  1548. tmf->common.version = 1;
  1549. tmf->common.opcode = IBMVFC_TMF_MAD;
  1550. tmf->common.length = sizeof(*tmf);
  1551. tmf->scsi_id = port_id;
  1552. tmf->cancel_key = IBMVFC_PASSTHRU_CANCEL_KEY;
  1553. tmf->my_cancel_key = IBMVFC_INTERNAL_CANCEL_KEY;
  1554. rc = ibmvfc_send_event(evt, vhost, default_timeout);
  1555. if (rc != 0) {
  1556. vhost->aborting_passthru = 0;
  1557. dev_err(vhost->dev, "Failed to send cancel event. rc=%d\n", rc);
  1558. rc = -EIO;
  1559. } else
  1560. dev_info(vhost->dev, "Cancelling passthru command to port id 0x%lx\n",
  1561. port_id);
  1562. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1563. LEAVE;
  1564. return rc;
  1565. }
  1566. /**
  1567. * ibmvfc_bsg_plogi - PLOGI into a target to handle a BSG command
  1568. * @vhost: struct ibmvfc_host to send command
  1569. * @port_id: port ID to send command
  1570. *
  1571. * Returns:
  1572. * 0 on success / other on failure
  1573. **/
  1574. static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
  1575. {
  1576. struct ibmvfc_port_login *plogi;
  1577. struct ibmvfc_target *tgt;
  1578. struct ibmvfc_event *evt;
  1579. union ibmvfc_iu rsp_iu;
  1580. unsigned long flags;
  1581. int rc = 0, issue_login = 1;
  1582. ENTER;
  1583. spin_lock_irqsave(vhost->host->host_lock, flags);
  1584. list_for_each_entry(tgt, &vhost->targets, queue) {
  1585. if (tgt->scsi_id == port_id) {
  1586. issue_login = 0;
  1587. break;
  1588. }
  1589. }
  1590. if (!issue_login)
  1591. goto unlock_out;
  1592. if (unlikely((rc = ibmvfc_host_chkready(vhost))))
  1593. goto unlock_out;
  1594. evt = ibmvfc_get_event(vhost);
  1595. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
  1596. plogi = &evt->iu.plogi;
  1597. memset(plogi, 0, sizeof(*plogi));
  1598. plogi->common.version = 1;
  1599. plogi->common.opcode = IBMVFC_PORT_LOGIN;
  1600. plogi->common.length = sizeof(*plogi);
  1601. plogi->scsi_id = port_id;
  1602. evt->sync_iu = &rsp_iu;
  1603. init_completion(&evt->comp);
  1604. rc = ibmvfc_send_event(evt, vhost, default_timeout);
  1605. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1606. if (rc)
  1607. return -EIO;
  1608. wait_for_completion(&evt->comp);
  1609. if (rsp_iu.plogi.common.status)
  1610. rc = -EIO;
  1611. spin_lock_irqsave(vhost->host->host_lock, flags);
  1612. ibmvfc_free_event(evt);
  1613. unlock_out:
  1614. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1615. LEAVE;
  1616. return rc;
  1617. }
  1618. /**
  1619. * ibmvfc_bsg_request - Handle a BSG request
  1620. * @job: struct fc_bsg_job to be executed
  1621. *
  1622. * Returns:
  1623. * 0 on success / other on failure
  1624. **/
  1625. static int ibmvfc_bsg_request(struct fc_bsg_job *job)
  1626. {
  1627. struct ibmvfc_host *vhost = shost_priv(job->shost);
  1628. struct fc_rport *rport = job->rport;
  1629. struct ibmvfc_passthru_mad *mad;
  1630. struct ibmvfc_event *evt;
  1631. union ibmvfc_iu rsp_iu;
  1632. unsigned long flags, port_id = -1;
  1633. unsigned int code = job->request->msgcode;
  1634. int rc = 0, req_seg, rsp_seg, issue_login = 0;
  1635. u32 fc_flags, rsp_len;
  1636. ENTER;
  1637. job->reply->reply_payload_rcv_len = 0;
  1638. if (rport)
  1639. port_id = rport->port_id;
  1640. switch (code) {
  1641. case FC_BSG_HST_ELS_NOLOGIN:
  1642. port_id = (job->request->rqst_data.h_els.port_id[0] << 16) |
  1643. (job->request->rqst_data.h_els.port_id[1] << 8) |
  1644. job->request->rqst_data.h_els.port_id[2];
  1645. case FC_BSG_RPT_ELS:
  1646. fc_flags = IBMVFC_FC_ELS;
  1647. break;
  1648. case FC_BSG_HST_CT:
  1649. issue_login = 1;
  1650. port_id = (job->request->rqst_data.h_ct.port_id[0] << 16) |
  1651. (job->request->rqst_data.h_ct.port_id[1] << 8) |
  1652. job->request->rqst_data.h_ct.port_id[2];
  1653. case FC_BSG_RPT_CT:
  1654. fc_flags = IBMVFC_FC_CT_IU;
  1655. break;
  1656. default:
  1657. return -ENOTSUPP;
  1658. };
  1659. if (port_id == -1)
  1660. return -EINVAL;
  1661. if (!mutex_trylock(&vhost->passthru_mutex))
  1662. return -EBUSY;
  1663. job->dd_data = (void *)port_id;
  1664. req_seg = dma_map_sg(vhost->dev, job->request_payload.sg_list,
  1665. job->request_payload.sg_cnt, DMA_TO_DEVICE);
  1666. if (!req_seg) {
  1667. mutex_unlock(&vhost->passthru_mutex);
  1668. return -ENOMEM;
  1669. }
  1670. rsp_seg = dma_map_sg(vhost->dev, job->reply_payload.sg_list,
  1671. job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
  1672. if (!rsp_seg) {
  1673. dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
  1674. job->request_payload.sg_cnt, DMA_TO_DEVICE);
  1675. mutex_unlock(&vhost->passthru_mutex);
  1676. return -ENOMEM;
  1677. }
  1678. if (req_seg > 1 || rsp_seg > 1) {
  1679. rc = -EINVAL;
  1680. goto out;
  1681. }
  1682. if (issue_login)
  1683. rc = ibmvfc_bsg_plogi(vhost, port_id);
  1684. spin_lock_irqsave(vhost->host->host_lock, flags);
  1685. if (unlikely(rc || (rport && (rc = fc_remote_port_chkready(rport)))) ||
  1686. unlikely((rc = ibmvfc_host_chkready(vhost)))) {
  1687. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1688. goto out;
  1689. }
  1690. evt = ibmvfc_get_event(vhost);
  1691. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
  1692. mad = &evt->iu.passthru;
  1693. memset(mad, 0, sizeof(*mad));
  1694. mad->common.version = 1;
  1695. mad->common.opcode = IBMVFC_PASSTHRU;
  1696. mad->common.length = sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu);
  1697. mad->cmd_ioba.va = (u64)evt->crq.ioba +
  1698. offsetof(struct ibmvfc_passthru_mad, iu);
  1699. mad->cmd_ioba.len = sizeof(mad->iu);
  1700. mad->iu.cmd_len = job->request_payload.payload_len;
  1701. mad->iu.rsp_len = job->reply_payload.payload_len;
  1702. mad->iu.flags = fc_flags;
  1703. mad->iu.cancel_key = IBMVFC_PASSTHRU_CANCEL_KEY;
  1704. mad->iu.cmd.va = sg_dma_address(job->request_payload.sg_list);
  1705. mad->iu.cmd.len = sg_dma_len(job->request_payload.sg_list);
  1706. mad->iu.rsp.va = sg_dma_address(job->reply_payload.sg_list);
  1707. mad->iu.rsp.len = sg_dma_len(job->reply_payload.sg_list);
  1708. mad->iu.scsi_id = port_id;
  1709. mad->iu.tag = (u64)evt;
  1710. rsp_len = mad->iu.rsp.len;
  1711. evt->sync_iu = &rsp_iu;
  1712. init_completion(&evt->comp);
  1713. rc = ibmvfc_send_event(evt, vhost, 0);
  1714. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1715. if (rc) {
  1716. rc = -EIO;
  1717. goto out;
  1718. }
  1719. wait_for_completion(&evt->comp);
  1720. if (rsp_iu.passthru.common.status)
  1721. rc = -EIO;
  1722. else
  1723. job->reply->reply_payload_rcv_len = rsp_len;
  1724. spin_lock_irqsave(vhost->host->host_lock, flags);
  1725. ibmvfc_free_event(evt);
  1726. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1727. job->reply->result = rc;
  1728. job->job_done(job);
  1729. rc = 0;
  1730. out:
  1731. dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
  1732. job->request_payload.sg_cnt, DMA_TO_DEVICE);
  1733. dma_unmap_sg(vhost->dev, job->reply_payload.sg_list,
  1734. job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
  1735. mutex_unlock(&vhost->passthru_mutex);
  1736. LEAVE;
  1737. return rc;
  1738. }
  1739. /**
  1740. * ibmvfc_reset_device - Reset the device with the specified reset type
  1741. * @sdev: scsi device to reset
  1742. * @type: reset type
  1743. * @desc: reset type description for log messages
  1744. *
  1745. * Returns:
  1746. * 0 on success / other on failure
  1747. **/
  1748. static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
  1749. {
  1750. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  1751. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  1752. struct ibmvfc_cmd *tmf;
  1753. struct ibmvfc_event *evt = NULL;
  1754. union ibmvfc_iu rsp_iu;
  1755. struct ibmvfc_fcp_rsp *fc_rsp = &rsp_iu.cmd.rsp;
  1756. int rsp_rc = -EBUSY;
  1757. unsigned long flags;
  1758. int rsp_code = 0;
  1759. spin_lock_irqsave(vhost->host->host_lock, flags);
  1760. if (vhost->state == IBMVFC_ACTIVE) {
  1761. evt = ibmvfc_get_event(vhost);
  1762. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
  1763. tmf = &evt->iu.cmd;
  1764. memset(tmf, 0, sizeof(*tmf));
  1765. tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
  1766. tmf->resp.len = sizeof(tmf->rsp);
  1767. tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
  1768. tmf->payload_len = sizeof(tmf->iu);
  1769. tmf->resp_len = sizeof(tmf->rsp);
  1770. tmf->cancel_key = (unsigned long)sdev->hostdata;
  1771. tmf->tgt_scsi_id = rport->port_id;
  1772. int_to_scsilun(sdev->lun, &tmf->iu.lun);
  1773. tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
  1774. tmf->iu.tmf_flags = type;
  1775. evt->sync_iu = &rsp_iu;
  1776. init_completion(&evt->comp);
  1777. rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
  1778. }
  1779. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1780. if (rsp_rc != 0) {
  1781. sdev_printk(KERN_ERR, sdev, "Failed to send %s reset event. rc=%d\n",
  1782. desc, rsp_rc);
  1783. return -EIO;
  1784. }
  1785. sdev_printk(KERN_INFO, sdev, "Resetting %s\n", desc);
  1786. wait_for_completion(&evt->comp);
  1787. if (rsp_iu.cmd.status)
  1788. rsp_code = ibmvfc_get_err_result(&rsp_iu.cmd);
  1789. if (rsp_code) {
  1790. if (fc_rsp->flags & FCP_RSP_LEN_VALID)
  1791. rsp_code = fc_rsp->data.info.rsp_code;
  1792. sdev_printk(KERN_ERR, sdev, "%s reset failed: %s (%x:%x) "
  1793. "flags: %x fcp_rsp: %x, scsi_status: %x\n",
  1794. desc, ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
  1795. rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
  1796. fc_rsp->scsi_status);
  1797. rsp_rc = -EIO;
  1798. } else
  1799. sdev_printk(KERN_INFO, sdev, "%s reset successful\n", desc);
  1800. spin_lock_irqsave(vhost->host->host_lock, flags);
  1801. ibmvfc_free_event(evt);
  1802. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1803. return rsp_rc;
  1804. }
  1805. /**
  1806. * ibmvfc_match_rport - Match function for specified remote port
  1807. * @evt: ibmvfc event struct
  1808. * @device: device to match (rport)
  1809. *
  1810. * Returns:
  1811. * 1 if event matches rport / 0 if event does not match rport
  1812. **/
  1813. static int ibmvfc_match_rport(struct ibmvfc_event *evt, void *rport)
  1814. {
  1815. struct fc_rport *cmd_rport;
  1816. if (evt->cmnd) {
  1817. cmd_rport = starget_to_rport(scsi_target(evt->cmnd->device));
  1818. if (cmd_rport == rport)
  1819. return 1;
  1820. }
  1821. return 0;
  1822. }
  1823. /**
  1824. * ibmvfc_match_target - Match function for specified target
  1825. * @evt: ibmvfc event struct
  1826. * @device: device to match (starget)
  1827. *
  1828. * Returns:
  1829. * 1 if event matches starget / 0 if event does not match starget
  1830. **/
  1831. static int ibmvfc_match_target(struct ibmvfc_event *evt, void *device)
  1832. {
  1833. if (evt->cmnd && scsi_target(evt->cmnd->device) == device)
  1834. return 1;
  1835. return 0;
  1836. }
  1837. /**
  1838. * ibmvfc_match_lun - Match function for specified LUN
  1839. * @evt: ibmvfc event struct
  1840. * @device: device to match (sdev)
  1841. *
  1842. * Returns:
  1843. * 1 if event matches sdev / 0 if event does not match sdev
  1844. **/
  1845. static int ibmvfc_match_lun(struct ibmvfc_event *evt, void *device)
  1846. {
  1847. if (evt->cmnd && evt->cmnd->device == device)
  1848. return 1;
  1849. return 0;
  1850. }
  1851. /**
  1852. * ibmvfc_wait_for_ops - Wait for ops to complete
  1853. * @vhost: ibmvfc host struct
  1854. * @device: device to match (starget or sdev)
  1855. * @match: match function
  1856. *
  1857. * Returns:
  1858. * SUCCESS / FAILED
  1859. **/
  1860. static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
  1861. int (*match) (struct ibmvfc_event *, void *))
  1862. {
  1863. struct ibmvfc_event *evt;
  1864. DECLARE_COMPLETION_ONSTACK(comp);
  1865. int wait;
  1866. unsigned long flags;
  1867. signed long timeout = IBMVFC_ABORT_WAIT_TIMEOUT * HZ;
  1868. ENTER;
  1869. do {
  1870. wait = 0;
  1871. spin_lock_irqsave(vhost->host->host_lock, flags);
  1872. list_for_each_entry(evt, &vhost->sent, queue) {
  1873. if (match(evt, device)) {
  1874. evt->eh_comp = &comp;
  1875. wait++;
  1876. }
  1877. }
  1878. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1879. if (wait) {
  1880. timeout = wait_for_completion_timeout(&comp, timeout);
  1881. if (!timeout) {
  1882. wait = 0;
  1883. spin_lock_irqsave(vhost->host->host_lock, flags);
  1884. list_for_each_entry(evt, &vhost->sent, queue) {
  1885. if (match(evt, device)) {
  1886. evt->eh_comp = NULL;
  1887. wait++;
  1888. }
  1889. }
  1890. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1891. if (wait)
  1892. dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
  1893. LEAVE;
  1894. return wait ? FAILED : SUCCESS;
  1895. }
  1896. }
  1897. } while (wait);
  1898. LEAVE;
  1899. return SUCCESS;
  1900. }
  1901. /**
  1902. * ibmvfc_cancel_all - Cancel all outstanding commands to the device
  1903. * @sdev: scsi device to cancel commands
  1904. * @type: type of error recovery being performed
  1905. *
  1906. * This sends a cancel to the VIOS for the specified device. This does
  1907. * NOT send any abort to the actual device. That must be done separately.
  1908. *
  1909. * Returns:
  1910. * 0 on success / other on failure
  1911. **/
  1912. static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
  1913. {
  1914. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  1915. struct scsi_target *starget = scsi_target(sdev);
  1916. struct fc_rport *rport = starget_to_rport(starget);
  1917. struct ibmvfc_tmf *tmf;
  1918. struct ibmvfc_event *evt, *found_evt;
  1919. union ibmvfc_iu rsp;
  1920. int rsp_rc = -EBUSY;
  1921. unsigned long flags;
  1922. u16 status;
  1923. ENTER;
  1924. spin_lock_irqsave(vhost->host->host_lock, flags);
  1925. found_evt = NULL;
  1926. list_for_each_entry(evt, &vhost->sent, queue) {
  1927. if (evt->cmnd && evt->cmnd->device == sdev) {
  1928. found_evt = evt;
  1929. break;
  1930. }
  1931. }
  1932. if (!found_evt) {
  1933. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  1934. sdev_printk(KERN_INFO, sdev, "No events found to cancel\n");
  1935. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1936. return 0;
  1937. }
  1938. if (vhost->logged_in) {
  1939. evt = ibmvfc_get_event(vhost);
  1940. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
  1941. tmf = &evt->iu.tmf;
  1942. memset(tmf, 0, sizeof(*tmf));
  1943. tmf->common.version = 1;
  1944. tmf->common.opcode = IBMVFC_TMF_MAD;
  1945. tmf->common.length = sizeof(*tmf);
  1946. tmf->scsi_id = rport->port_id;
  1947. int_to_scsilun(sdev->lun, &tmf->lun);
  1948. if (!(vhost->login_buf->resp.capabilities & IBMVFC_CAN_SUPPRESS_ABTS))
  1949. type &= ~IBMVFC_TMF_SUPPRESS_ABTS;
  1950. if (vhost->state == IBMVFC_ACTIVE)
  1951. tmf->flags = (type | IBMVFC_TMF_LUA_VALID);
  1952. else
  1953. tmf->flags = ((type & IBMVFC_TMF_SUPPRESS_ABTS) | IBMVFC_TMF_LUA_VALID);
  1954. tmf->cancel_key = (unsigned long)sdev->hostdata;
  1955. tmf->my_cancel_key = (unsigned long)starget->hostdata;
  1956. evt->sync_iu = &rsp;
  1957. init_completion(&evt->comp);
  1958. rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
  1959. }
  1960. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1961. if (rsp_rc != 0) {
  1962. sdev_printk(KERN_ERR, sdev, "Failed to send cancel event. rc=%d\n", rsp_rc);
  1963. /* If failure is received, the host adapter is most likely going
  1964. through reset, return success so the caller will wait for the command
  1965. being cancelled to get returned */
  1966. return 0;
  1967. }
  1968. sdev_printk(KERN_INFO, sdev, "Cancelling outstanding commands.\n");
  1969. wait_for_completion(&evt->comp);
  1970. status = rsp.mad_common.status;
  1971. spin_lock_irqsave(vhost->host->host_lock, flags);
  1972. ibmvfc_free_event(evt);
  1973. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1974. if (status != IBMVFC_MAD_SUCCESS) {
  1975. sdev_printk(KERN_WARNING, sdev, "Cancel failed with rc=%x\n", status);
  1976. switch (status) {
  1977. case IBMVFC_MAD_DRIVER_FAILED:
  1978. case IBMVFC_MAD_CRQ_ERROR:
  1979. /* Host adapter most likely going through reset, return success to
  1980. the caller will wait for the command being cancelled to get returned */
  1981. return 0;
  1982. default:
  1983. return -EIO;
  1984. };
  1985. }
  1986. sdev_printk(KERN_INFO, sdev, "Successfully cancelled outstanding commands\n");
  1987. return 0;
  1988. }
  1989. /**
  1990. * ibmvfc_match_key - Match function for specified cancel key
  1991. * @evt: ibmvfc event struct
  1992. * @key: cancel key to match
  1993. *
  1994. * Returns:
  1995. * 1 if event matches key / 0 if event does not match key
  1996. **/
  1997. static int ibmvfc_match_key(struct ibmvfc_event *evt, void *key)
  1998. {
  1999. unsigned long cancel_key = (unsigned long)key;
  2000. if (evt->crq.format == IBMVFC_CMD_FORMAT &&
  2001. evt->iu.cmd.cancel_key == cancel_key)
  2002. return 1;
  2003. return 0;
  2004. }
  2005. /**
  2006. * ibmvfc_match_evt - Match function for specified event
  2007. * @evt: ibmvfc event struct
  2008. * @match: event to match
  2009. *
  2010. * Returns:
  2011. * 1 if event matches key / 0 if event does not match key
  2012. **/
  2013. static int ibmvfc_match_evt(struct ibmvfc_event *evt, void *match)
  2014. {
  2015. if (evt == match)
  2016. return 1;
  2017. return 0;
  2018. }
  2019. /**
  2020. * ibmvfc_abort_task_set - Abort outstanding commands to the device
  2021. * @sdev: scsi device to abort commands
  2022. *
  2023. * This sends an Abort Task Set to the VIOS for the specified device. This does
  2024. * NOT send any cancel to the VIOS. That must be done separately.
  2025. *
  2026. * Returns:
  2027. * 0 on success / other on failure
  2028. **/
  2029. static int ibmvfc_abort_task_set(struct scsi_device *sdev)
  2030. {
  2031. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  2032. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  2033. struct ibmvfc_cmd *tmf;
  2034. struct ibmvfc_event *evt, *found_evt;
  2035. union ibmvfc_iu rsp_iu;
  2036. struct ibmvfc_fcp_rsp *fc_rsp = &rsp_iu.cmd.rsp;
  2037. int rc, rsp_rc = -EBUSY;
  2038. unsigned long flags, timeout = IBMVFC_ABORT_TIMEOUT;
  2039. int rsp_code = 0;
  2040. spin_lock_irqsave(vhost->host->host_lock, flags);
  2041. found_evt = NULL;
  2042. list_for_each_entry(evt, &vhost->sent, queue) {
  2043. if (evt->cmnd && evt->cmnd->device == sdev) {
  2044. found_evt = evt;
  2045. break;
  2046. }
  2047. }
  2048. if (!found_evt) {
  2049. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  2050. sdev_printk(KERN_INFO, sdev, "No events found to abort\n");
  2051. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2052. return 0;
  2053. }
  2054. if (vhost->state == IBMVFC_ACTIVE) {
  2055. evt = ibmvfc_get_event(vhost);
  2056. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
  2057. tmf = &evt->iu.cmd;
  2058. memset(tmf, 0, sizeof(*tmf));
  2059. tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
  2060. tmf->resp.len = sizeof(tmf->rsp);
  2061. tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
  2062. tmf->payload_len = sizeof(tmf->iu);
  2063. tmf->resp_len = sizeof(tmf->rsp);
  2064. tmf->cancel_key = (unsigned long)sdev->hostdata;
  2065. tmf->tgt_scsi_id = rport->port_id;
  2066. int_to_scsilun(sdev->lun, &tmf->iu.lun);
  2067. tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
  2068. tmf->iu.tmf_flags = IBMVFC_ABORT_TASK_SET;
  2069. evt->sync_iu = &rsp_iu;
  2070. init_completion(&evt->comp);
  2071. rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
  2072. }
  2073. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2074. if (rsp_rc != 0) {
  2075. sdev_printk(KERN_ERR, sdev, "Failed to send abort. rc=%d\n", rsp_rc);
  2076. return -EIO;
  2077. }
  2078. sdev_printk(KERN_INFO, sdev, "Aborting outstanding commands\n");
  2079. timeout = wait_for_completion_timeout(&evt->comp, timeout);
  2080. if (!timeout) {
  2081. rc = ibmvfc_cancel_all(sdev, 0);
  2082. if (!rc) {
  2083. rc = ibmvfc_wait_for_ops(vhost, sdev->hostdata, ibmvfc_match_key);
  2084. if (rc == SUCCESS)
  2085. rc = 0;
  2086. }
  2087. if (rc) {
  2088. sdev_printk(KERN_INFO, sdev, "Cancel failed, resetting host\n");
  2089. ibmvfc_reset_host(vhost);
  2090. rsp_rc = -EIO;
  2091. rc = ibmvfc_wait_for_ops(vhost, sdev->hostdata, ibmvfc_match_key);
  2092. if (rc == SUCCESS)
  2093. rsp_rc = 0;
  2094. rc = ibmvfc_wait_for_ops(vhost, evt, ibmvfc_match_evt);
  2095. if (rc != SUCCESS) {
  2096. spin_lock_irqsave(vhost->host->host_lock, flags);
  2097. ibmvfc_hard_reset_host(vhost);
  2098. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2099. rsp_rc = 0;
  2100. }
  2101. goto out;
  2102. }
  2103. }
  2104. if (rsp_iu.cmd.status)
  2105. rsp_code = ibmvfc_get_err_result(&rsp_iu.cmd);
  2106. if (rsp_code) {
  2107. if (fc_rsp->flags & FCP_RSP_LEN_VALID)
  2108. rsp_code = fc_rsp->data.info.rsp_code;
  2109. sdev_printk(KERN_ERR, sdev, "Abort failed: %s (%x:%x) "
  2110. "flags: %x fcp_rsp: %x, scsi_status: %x\n",
  2111. ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
  2112. rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
  2113. fc_rsp->scsi_status);
  2114. rsp_rc = -EIO;
  2115. } else
  2116. sdev_printk(KERN_INFO, sdev, "Abort successful\n");
  2117. out:
  2118. spin_lock_irqsave(vhost->host->host_lock, flags);
  2119. ibmvfc_free_event(evt);
  2120. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2121. return rsp_rc;
  2122. }
  2123. /**
  2124. * ibmvfc_eh_abort_handler - Abort a command
  2125. * @cmd: scsi command to abort
  2126. *
  2127. * Returns:
  2128. * SUCCESS / FAST_IO_FAIL / FAILED
  2129. **/
  2130. static int ibmvfc_eh_abort_handler(struct scsi_cmnd *cmd)
  2131. {
  2132. struct scsi_device *sdev = cmd->device;
  2133. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  2134. int cancel_rc, block_rc;
  2135. int rc = FAILED;
  2136. ENTER;
  2137. block_rc = fc_block_scsi_eh(cmd);
  2138. ibmvfc_wait_while_resetting(vhost);
  2139. if (block_rc != FAST_IO_FAIL) {
  2140. cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
  2141. ibmvfc_abort_task_set(sdev);
  2142. } else
  2143. cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
  2144. if (!cancel_rc)
  2145. rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
  2146. if (block_rc == FAST_IO_FAIL && rc != FAILED)
  2147. rc = FAST_IO_FAIL;
  2148. LEAVE;
  2149. return rc;
  2150. }
  2151. /**
  2152. * ibmvfc_eh_device_reset_handler - Reset a single LUN
  2153. * @cmd: scsi command struct
  2154. *
  2155. * Returns:
  2156. * SUCCESS / FAST_IO_FAIL / FAILED
  2157. **/
  2158. static int ibmvfc_eh_device_reset_handler(struct scsi_cmnd *cmd)
  2159. {
  2160. struct scsi_device *sdev = cmd->device;
  2161. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  2162. int cancel_rc, block_rc, reset_rc = 0;
  2163. int rc = FAILED;
  2164. ENTER;
  2165. block_rc = fc_block_scsi_eh(cmd);
  2166. ibmvfc_wait_while_resetting(vhost);
  2167. if (block_rc != FAST_IO_FAIL) {
  2168. cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_LUN_RESET);
  2169. reset_rc = ibmvfc_reset_device(sdev, IBMVFC_LUN_RESET, "LUN");
  2170. } else
  2171. cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
  2172. if (!cancel_rc && !reset_rc)
  2173. rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
  2174. if (block_rc == FAST_IO_FAIL && rc != FAILED)
  2175. rc = FAST_IO_FAIL;
  2176. LEAVE;
  2177. return rc;
  2178. }
  2179. /**
  2180. * ibmvfc_dev_cancel_all_noreset - Device iterated cancel all function
  2181. * @sdev: scsi device struct
  2182. * @data: return code
  2183. *
  2184. **/
  2185. static void ibmvfc_dev_cancel_all_noreset(struct scsi_device *sdev, void *data)
  2186. {
  2187. unsigned long *rc = data;
  2188. *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
  2189. }
  2190. /**
  2191. * ibmvfc_dev_cancel_all_reset - Device iterated cancel all function
  2192. * @sdev: scsi device struct
  2193. * @data: return code
  2194. *
  2195. **/
  2196. static void ibmvfc_dev_cancel_all_reset(struct scsi_device *sdev, void *data)
  2197. {
  2198. unsigned long *rc = data;
  2199. *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_TGT_RESET);
  2200. }
  2201. /**
  2202. * ibmvfc_eh_target_reset_handler - Reset the target
  2203. * @cmd: scsi command struct
  2204. *
  2205. * Returns:
  2206. * SUCCESS / FAST_IO_FAIL / FAILED
  2207. **/
  2208. static int ibmvfc_eh_target_reset_handler(struct scsi_cmnd *cmd)
  2209. {
  2210. struct scsi_device *sdev = cmd->device;
  2211. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  2212. struct scsi_target *starget = scsi_target(sdev);
  2213. int block_rc;
  2214. int reset_rc = 0;
  2215. int rc = FAILED;
  2216. unsigned long cancel_rc = 0;
  2217. ENTER;
  2218. block_rc = fc_block_scsi_eh(cmd);
  2219. ibmvfc_wait_while_resetting(vhost);
  2220. if (block_rc != FAST_IO_FAIL) {
  2221. starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_reset);
  2222. reset_rc = ibmvfc_reset_device(sdev, IBMVFC_TARGET_RESET, "target");
  2223. } else
  2224. starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_noreset);
  2225. if (!cancel_rc && !reset_rc)
  2226. rc = ibmvfc_wait_for_ops(vhost, starget, ibmvfc_match_target);
  2227. if (block_rc == FAST_IO_FAIL && rc != FAILED)
  2228. rc = FAST_IO_FAIL;
  2229. LEAVE;
  2230. return rc;
  2231. }
  2232. /**
  2233. * ibmvfc_eh_host_reset_handler - Reset the connection to the server
  2234. * @cmd: struct scsi_cmnd having problems
  2235. *
  2236. **/
  2237. static int ibmvfc_eh_host_reset_handler(struct scsi_cmnd *cmd)
  2238. {
  2239. int rc, block_rc;
  2240. struct ibmvfc_host *vhost = shost_priv(cmd->device->host);
  2241. block_rc = fc_block_scsi_eh(cmd);
  2242. dev_err(vhost->dev, "Resetting connection due to error recovery\n");
  2243. rc = ibmvfc_issue_fc_host_lip(vhost->host);
  2244. if (block_rc == FAST_IO_FAIL)
  2245. return FAST_IO_FAIL;
  2246. return rc ? FAILED : SUCCESS;
  2247. }
  2248. /**
  2249. * ibmvfc_terminate_rport_io - Terminate all pending I/O to the rport.
  2250. * @rport: rport struct
  2251. *
  2252. * Return value:
  2253. * none
  2254. **/
  2255. static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
  2256. {
  2257. struct Scsi_Host *shost = rport_to_shost(rport);
  2258. struct ibmvfc_host *vhost = shost_priv(shost);
  2259. struct fc_rport *dev_rport;
  2260. struct scsi_device *sdev;
  2261. unsigned long rc;
  2262. ENTER;
  2263. shost_for_each_device(sdev, shost) {
  2264. dev_rport = starget_to_rport(scsi_target(sdev));
  2265. if (dev_rport != rport)
  2266. continue;
  2267. ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
  2268. }
  2269. rc = ibmvfc_wait_for_ops(vhost, rport, ibmvfc_match_rport);
  2270. if (rc == FAILED)
  2271. ibmvfc_issue_fc_host_lip(shost);
  2272. LEAVE;
  2273. }
  2274. static const struct ibmvfc_async_desc ae_desc [] = {
  2275. { "PLOGI", IBMVFC_AE_ELS_PLOGI, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2276. { "LOGO", IBMVFC_AE_ELS_LOGO, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2277. { "PRLO", IBMVFC_AE_ELS_PRLO, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2278. { "N-Port SCN", IBMVFC_AE_SCN_NPORT, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2279. { "Group SCN", IBMVFC_AE_SCN_GROUP, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2280. { "Domain SCN", IBMVFC_AE_SCN_DOMAIN, IBMVFC_DEFAULT_LOG_LEVEL },
  2281. { "Fabric SCN", IBMVFC_AE_SCN_FABRIC, IBMVFC_DEFAULT_LOG_LEVEL },
  2282. { "Link Up", IBMVFC_AE_LINK_UP, IBMVFC_DEFAULT_LOG_LEVEL },
  2283. { "Link Down", IBMVFC_AE_LINK_DOWN, IBMVFC_DEFAULT_LOG_LEVEL },
  2284. { "Link Dead", IBMVFC_AE_LINK_DEAD, IBMVFC_DEFAULT_LOG_LEVEL },
  2285. { "Halt", IBMVFC_AE_HALT, IBMVFC_DEFAULT_LOG_LEVEL },
  2286. { "Resume", IBMVFC_AE_RESUME, IBMVFC_DEFAULT_LOG_LEVEL },
  2287. { "Adapter Failed", IBMVFC_AE_ADAPTER_FAILED, IBMVFC_DEFAULT_LOG_LEVEL },
  2288. };
  2289. static const struct ibmvfc_async_desc unknown_ae = {
  2290. "Unknown async", 0, IBMVFC_DEFAULT_LOG_LEVEL
  2291. };
  2292. /**
  2293. * ibmvfc_get_ae_desc - Get text description for async event
  2294. * @ae: async event
  2295. *
  2296. **/
  2297. static const struct ibmvfc_async_desc *ibmvfc_get_ae_desc(u64 ae)
  2298. {
  2299. int i;
  2300. for (i = 0; i < ARRAY_SIZE(ae_desc); i++)
  2301. if (ae_desc[i].ae == ae)
  2302. return &ae_desc[i];
  2303. return &unknown_ae;
  2304. }
  2305. static const struct {
  2306. enum ibmvfc_ae_link_state state;
  2307. const char *desc;
  2308. } link_desc [] = {
  2309. { IBMVFC_AE_LS_LINK_UP, " link up" },
  2310. { IBMVFC_AE_LS_LINK_BOUNCED, " link bounced" },
  2311. { IBMVFC_AE_LS_LINK_DOWN, " link down" },
  2312. { IBMVFC_AE_LS_LINK_DEAD, " link dead" },
  2313. };
  2314. /**
  2315. * ibmvfc_get_link_state - Get text description for link state
  2316. * @state: link state
  2317. *
  2318. **/
  2319. static const char *ibmvfc_get_link_state(enum ibmvfc_ae_link_state state)
  2320. {
  2321. int i;
  2322. for (i = 0; i < ARRAY_SIZE(link_desc); i++)
  2323. if (link_desc[i].state == state)
  2324. return link_desc[i].desc;
  2325. return "";
  2326. }
  2327. /**
  2328. * ibmvfc_handle_async - Handle an async event from the adapter
  2329. * @crq: crq to process
  2330. * @vhost: ibmvfc host struct
  2331. *
  2332. **/
  2333. static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
  2334. struct ibmvfc_host *vhost)
  2335. {
  2336. const struct ibmvfc_async_desc *desc = ibmvfc_get_ae_desc(crq->event);
  2337. struct ibmvfc_target *tgt;
  2338. ibmvfc_log(vhost, desc->log_level, "%s event received. scsi_id: %llx, wwpn: %llx,"
  2339. " node_name: %llx%s\n", desc->desc, crq->scsi_id, crq->wwpn, crq->node_name,
  2340. ibmvfc_get_link_state(crq->link_state));
  2341. switch (crq->event) {
  2342. case IBMVFC_AE_RESUME:
  2343. switch (crq->link_state) {
  2344. case IBMVFC_AE_LS_LINK_DOWN:
  2345. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  2346. break;
  2347. case IBMVFC_AE_LS_LINK_DEAD:
  2348. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  2349. break;
  2350. case IBMVFC_AE_LS_LINK_UP:
  2351. case IBMVFC_AE_LS_LINK_BOUNCED:
  2352. default:
  2353. vhost->events_to_log |= IBMVFC_AE_LINKUP;
  2354. vhost->delay_init = 1;
  2355. __ibmvfc_reset_host(vhost);
  2356. break;
  2357. };
  2358. break;
  2359. case IBMVFC_AE_LINK_UP:
  2360. vhost->events_to_log |= IBMVFC_AE_LINKUP;
  2361. vhost->delay_init = 1;
  2362. __ibmvfc_reset_host(vhost);
  2363. break;
  2364. case IBMVFC_AE_SCN_FABRIC:
  2365. case IBMVFC_AE_SCN_DOMAIN:
  2366. vhost->events_to_log |= IBMVFC_AE_RSCN;
  2367. if (vhost->state < IBMVFC_HALTED) {
  2368. vhost->delay_init = 1;
  2369. __ibmvfc_reset_host(vhost);
  2370. }
  2371. break;
  2372. case IBMVFC_AE_SCN_NPORT:
  2373. case IBMVFC_AE_SCN_GROUP:
  2374. vhost->events_to_log |= IBMVFC_AE_RSCN;
  2375. ibmvfc_reinit_host(vhost);
  2376. break;
  2377. case IBMVFC_AE_ELS_LOGO:
  2378. case IBMVFC_AE_ELS_PRLO:
  2379. case IBMVFC_AE_ELS_PLOGI:
  2380. list_for_each_entry(tgt, &vhost->targets, queue) {
  2381. if (!crq->scsi_id && !crq->wwpn && !crq->node_name)
  2382. break;
  2383. if (crq->scsi_id && tgt->scsi_id != crq->scsi_id)
  2384. continue;
  2385. if (crq->wwpn && tgt->ids.port_name != crq->wwpn)
  2386. continue;
  2387. if (crq->node_name && tgt->ids.node_name != crq->node_name)
  2388. continue;
  2389. if (tgt->need_login && crq->event == IBMVFC_AE_ELS_LOGO)
  2390. tgt->logo_rcvd = 1;
  2391. if (!tgt->need_login || crq->event == IBMVFC_AE_ELS_PLOGI) {
  2392. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2393. ibmvfc_reinit_host(vhost);
  2394. }
  2395. }
  2396. break;
  2397. case IBMVFC_AE_LINK_DOWN:
  2398. case IBMVFC_AE_ADAPTER_FAILED:
  2399. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  2400. break;
  2401. case IBMVFC_AE_LINK_DEAD:
  2402. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  2403. break;
  2404. case IBMVFC_AE_HALT:
  2405. ibmvfc_link_down(vhost, IBMVFC_HALTED);
  2406. break;
  2407. default:
  2408. dev_err(vhost->dev, "Unknown async event received: %lld\n", crq->event);
  2409. break;
  2410. };
  2411. }
  2412. /**
  2413. * ibmvfc_handle_crq - Handles and frees received events in the CRQ
  2414. * @crq: Command/Response queue
  2415. * @vhost: ibmvfc host struct
  2416. *
  2417. **/
  2418. static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
  2419. {
  2420. long rc;
  2421. struct ibmvfc_event *evt = (struct ibmvfc_event *)crq->ioba;
  2422. switch (crq->valid) {
  2423. case IBMVFC_CRQ_INIT_RSP:
  2424. switch (crq->format) {
  2425. case IBMVFC_CRQ_INIT:
  2426. dev_info(vhost->dev, "Partner initialized\n");
  2427. /* Send back a response */
  2428. rc = ibmvfc_send_crq_init_complete(vhost);
  2429. if (rc == 0)
  2430. ibmvfc_init_host(vhost);
  2431. else
  2432. dev_err(vhost->dev, "Unable to send init rsp. rc=%ld\n", rc);
  2433. break;
  2434. case IBMVFC_CRQ_INIT_COMPLETE:
  2435. dev_info(vhost->dev, "Partner initialization complete\n");
  2436. ibmvfc_init_host(vhost);
  2437. break;
  2438. default:
  2439. dev_err(vhost->dev, "Unknown crq message type: %d\n", crq->format);
  2440. }
  2441. return;
  2442. case IBMVFC_CRQ_XPORT_EVENT:
  2443. vhost->state = IBMVFC_NO_CRQ;
  2444. vhost->logged_in = 0;
  2445. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
  2446. if (crq->format == IBMVFC_PARTITION_MIGRATED) {
  2447. /* We need to re-setup the interpartition connection */
  2448. dev_info(vhost->dev, "Re-enabling adapter\n");
  2449. vhost->client_migrated = 1;
  2450. ibmvfc_purge_requests(vhost, DID_REQUEUE);
  2451. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  2452. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_REENABLE);
  2453. } else {
  2454. dev_err(vhost->dev, "Virtual adapter failed (rc=%d)\n", crq->format);
  2455. ibmvfc_purge_requests(vhost, DID_ERROR);
  2456. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  2457. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_RESET);
  2458. }
  2459. return;
  2460. case IBMVFC_CRQ_CMD_RSP:
  2461. break;
  2462. default:
  2463. dev_err(vhost->dev, "Got an invalid message type 0x%02x\n", crq->valid);
  2464. return;
  2465. }
  2466. if (crq->format == IBMVFC_ASYNC_EVENT)
  2467. return;
  2468. /* The only kind of payload CRQs we should get are responses to
  2469. * things we send. Make sure this response is to something we
  2470. * actually sent
  2471. */
  2472. if (unlikely(!ibmvfc_valid_event(&vhost->pool, evt))) {
  2473. dev_err(vhost->dev, "Returned correlation_token 0x%08llx is invalid!\n",
  2474. crq->ioba);
  2475. return;
  2476. }
  2477. if (unlikely(atomic_read(&evt->free))) {
  2478. dev_err(vhost->dev, "Received duplicate correlation_token 0x%08llx!\n",
  2479. crq->ioba);
  2480. return;
  2481. }
  2482. del_timer(&evt->timer);
  2483. list_del(&evt->queue);
  2484. ibmvfc_trc_end(evt);
  2485. evt->done(evt);
  2486. }
  2487. /**
  2488. * ibmvfc_scan_finished - Check if the device scan is done.
  2489. * @shost: scsi host struct
  2490. * @time: current elapsed time
  2491. *
  2492. * Returns:
  2493. * 0 if scan is not done / 1 if scan is done
  2494. **/
  2495. static int ibmvfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
  2496. {
  2497. unsigned long flags;
  2498. struct ibmvfc_host *vhost = shost_priv(shost);
  2499. int done = 0;
  2500. spin_lock_irqsave(shost->host_lock, flags);
  2501. if (time >= (init_timeout * HZ)) {
  2502. dev_info(vhost->dev, "Scan taking longer than %d seconds, "
  2503. "continuing initialization\n", init_timeout);
  2504. done = 1;
  2505. }
  2506. if (vhost->scan_complete)
  2507. done = 1;
  2508. spin_unlock_irqrestore(shost->host_lock, flags);
  2509. return done;
  2510. }
  2511. /**
  2512. * ibmvfc_slave_alloc - Setup the device's task set value
  2513. * @sdev: struct scsi_device device to configure
  2514. *
  2515. * Set the device's task set value so that error handling works as
  2516. * expected.
  2517. *
  2518. * Returns:
  2519. * 0 on success / -ENXIO if device does not exist
  2520. **/
  2521. static int ibmvfc_slave_alloc(struct scsi_device *sdev)
  2522. {
  2523. struct Scsi_Host *shost = sdev->host;
  2524. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  2525. struct ibmvfc_host *vhost = shost_priv(shost);
  2526. unsigned long flags = 0;
  2527. if (!rport || fc_remote_port_chkready(rport))
  2528. return -ENXIO;
  2529. spin_lock_irqsave(shost->host_lock, flags);
  2530. sdev->hostdata = (void *)(unsigned long)vhost->task_set++;
  2531. spin_unlock_irqrestore(shost->host_lock, flags);
  2532. return 0;
  2533. }
  2534. /**
  2535. * ibmvfc_target_alloc - Setup the target's task set value
  2536. * @starget: struct scsi_target
  2537. *
  2538. * Set the target's task set value so that error handling works as
  2539. * expected.
  2540. *
  2541. * Returns:
  2542. * 0 on success / -ENXIO if device does not exist
  2543. **/
  2544. static int ibmvfc_target_alloc(struct scsi_target *starget)
  2545. {
  2546. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  2547. struct ibmvfc_host *vhost = shost_priv(shost);
  2548. unsigned long flags = 0;
  2549. spin_lock_irqsave(shost->host_lock, flags);
  2550. starget->hostdata = (void *)(unsigned long)vhost->task_set++;
  2551. spin_unlock_irqrestore(shost->host_lock, flags);
  2552. return 0;
  2553. }
  2554. /**
  2555. * ibmvfc_slave_configure - Configure the device
  2556. * @sdev: struct scsi_device device to configure
  2557. *
  2558. * Enable allow_restart for a device if it is a disk. Adjust the
  2559. * queue_depth here also.
  2560. *
  2561. * Returns:
  2562. * 0
  2563. **/
  2564. static int ibmvfc_slave_configure(struct scsi_device *sdev)
  2565. {
  2566. struct Scsi_Host *shost = sdev->host;
  2567. unsigned long flags = 0;
  2568. spin_lock_irqsave(shost->host_lock, flags);
  2569. if (sdev->type == TYPE_DISK)
  2570. sdev->allow_restart = 1;
  2571. if (sdev->tagged_supported) {
  2572. scsi_set_tag_type(sdev, MSG_SIMPLE_TAG);
  2573. scsi_activate_tcq(sdev, sdev->queue_depth);
  2574. } else
  2575. scsi_deactivate_tcq(sdev, sdev->queue_depth);
  2576. spin_unlock_irqrestore(shost->host_lock, flags);
  2577. return 0;
  2578. }
  2579. /**
  2580. * ibmvfc_change_queue_depth - Change the device's queue depth
  2581. * @sdev: scsi device struct
  2582. * @qdepth: depth to set
  2583. * @reason: calling context
  2584. *
  2585. * Return value:
  2586. * actual depth set
  2587. **/
  2588. static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth,
  2589. int reason)
  2590. {
  2591. if (reason != SCSI_QDEPTH_DEFAULT)
  2592. return -EOPNOTSUPP;
  2593. if (qdepth > IBMVFC_MAX_CMDS_PER_LUN)
  2594. qdepth = IBMVFC_MAX_CMDS_PER_LUN;
  2595. scsi_adjust_queue_depth(sdev, 0, qdepth);
  2596. return sdev->queue_depth;
  2597. }
  2598. /**
  2599. * ibmvfc_change_queue_type - Change the device's queue type
  2600. * @sdev: scsi device struct
  2601. * @tag_type: type of tags to use
  2602. *
  2603. * Return value:
  2604. * actual queue type set
  2605. **/
  2606. static int ibmvfc_change_queue_type(struct scsi_device *sdev, int tag_type)
  2607. {
  2608. if (sdev->tagged_supported) {
  2609. scsi_set_tag_type(sdev, tag_type);
  2610. if (tag_type)
  2611. scsi_activate_tcq(sdev, sdev->queue_depth);
  2612. else
  2613. scsi_deactivate_tcq(sdev, sdev->queue_depth);
  2614. } else
  2615. tag_type = 0;
  2616. return tag_type;
  2617. }
  2618. static ssize_t ibmvfc_show_host_partition_name(struct device *dev,
  2619. struct device_attribute *attr, char *buf)
  2620. {
  2621. struct Scsi_Host *shost = class_to_shost(dev);
  2622. struct ibmvfc_host *vhost = shost_priv(shost);
  2623. return snprintf(buf, PAGE_SIZE, "%s\n",
  2624. vhost->login_buf->resp.partition_name);
  2625. }
  2626. static ssize_t ibmvfc_show_host_device_name(struct device *dev,
  2627. struct device_attribute *attr, char *buf)
  2628. {
  2629. struct Scsi_Host *shost = class_to_shost(dev);
  2630. struct ibmvfc_host *vhost = shost_priv(shost);
  2631. return snprintf(buf, PAGE_SIZE, "%s\n",
  2632. vhost->login_buf->resp.device_name);
  2633. }
  2634. static ssize_t ibmvfc_show_host_loc_code(struct device *dev,
  2635. struct device_attribute *attr, char *buf)
  2636. {
  2637. struct Scsi_Host *shost = class_to_shost(dev);
  2638. struct ibmvfc_host *vhost = shost_priv(shost);
  2639. return snprintf(buf, PAGE_SIZE, "%s\n",
  2640. vhost->login_buf->resp.port_loc_code);
  2641. }
  2642. static ssize_t ibmvfc_show_host_drc_name(struct device *dev,
  2643. struct device_attribute *attr, char *buf)
  2644. {
  2645. struct Scsi_Host *shost = class_to_shost(dev);
  2646. struct ibmvfc_host *vhost = shost_priv(shost);
  2647. return snprintf(buf, PAGE_SIZE, "%s\n",
  2648. vhost->login_buf->resp.drc_name);
  2649. }
  2650. static ssize_t ibmvfc_show_host_npiv_version(struct device *dev,
  2651. struct device_attribute *attr, char *buf)
  2652. {
  2653. struct Scsi_Host *shost = class_to_shost(dev);
  2654. struct ibmvfc_host *vhost = shost_priv(shost);
  2655. return snprintf(buf, PAGE_SIZE, "%d\n", vhost->login_buf->resp.version);
  2656. }
  2657. static ssize_t ibmvfc_show_host_capabilities(struct device *dev,
  2658. struct device_attribute *attr, char *buf)
  2659. {
  2660. struct Scsi_Host *shost = class_to_shost(dev);
  2661. struct ibmvfc_host *vhost = shost_priv(shost);
  2662. return snprintf(buf, PAGE_SIZE, "%llx\n", vhost->login_buf->resp.capabilities);
  2663. }
  2664. /**
  2665. * ibmvfc_show_log_level - Show the adapter's error logging level
  2666. * @dev: class device struct
  2667. * @buf: buffer
  2668. *
  2669. * Return value:
  2670. * number of bytes printed to buffer
  2671. **/
  2672. static ssize_t ibmvfc_show_log_level(struct device *dev,
  2673. struct device_attribute *attr, char *buf)
  2674. {
  2675. struct Scsi_Host *shost = class_to_shost(dev);
  2676. struct ibmvfc_host *vhost = shost_priv(shost);
  2677. unsigned long flags = 0;
  2678. int len;
  2679. spin_lock_irqsave(shost->host_lock, flags);
  2680. len = snprintf(buf, PAGE_SIZE, "%d\n", vhost->log_level);
  2681. spin_unlock_irqrestore(shost->host_lock, flags);
  2682. return len;
  2683. }
  2684. /**
  2685. * ibmvfc_store_log_level - Change the adapter's error logging level
  2686. * @dev: class device struct
  2687. * @buf: buffer
  2688. *
  2689. * Return value:
  2690. * number of bytes printed to buffer
  2691. **/
  2692. static ssize_t ibmvfc_store_log_level(struct device *dev,
  2693. struct device_attribute *attr,
  2694. const char *buf, size_t count)
  2695. {
  2696. struct Scsi_Host *shost = class_to_shost(dev);
  2697. struct ibmvfc_host *vhost = shost_priv(shost);
  2698. unsigned long flags = 0;
  2699. spin_lock_irqsave(shost->host_lock, flags);
  2700. vhost->log_level = simple_strtoul(buf, NULL, 10);
  2701. spin_unlock_irqrestore(shost->host_lock, flags);
  2702. return strlen(buf);
  2703. }
  2704. static DEVICE_ATTR(partition_name, S_IRUGO, ibmvfc_show_host_partition_name, NULL);
  2705. static DEVICE_ATTR(device_name, S_IRUGO, ibmvfc_show_host_device_name, NULL);
  2706. static DEVICE_ATTR(port_loc_code, S_IRUGO, ibmvfc_show_host_loc_code, NULL);
  2707. static DEVICE_ATTR(drc_name, S_IRUGO, ibmvfc_show_host_drc_name, NULL);
  2708. static DEVICE_ATTR(npiv_version, S_IRUGO, ibmvfc_show_host_npiv_version, NULL);
  2709. static DEVICE_ATTR(capabilities, S_IRUGO, ibmvfc_show_host_capabilities, NULL);
  2710. static DEVICE_ATTR(log_level, S_IRUGO | S_IWUSR,
  2711. ibmvfc_show_log_level, ibmvfc_store_log_level);
  2712. #ifdef CONFIG_SCSI_IBMVFC_TRACE
  2713. /**
  2714. * ibmvfc_read_trace - Dump the adapter trace
  2715. * @filp: open sysfs file
  2716. * @kobj: kobject struct
  2717. * @bin_attr: bin_attribute struct
  2718. * @buf: buffer
  2719. * @off: offset
  2720. * @count: buffer size
  2721. *
  2722. * Return value:
  2723. * number of bytes printed to buffer
  2724. **/
  2725. static ssize_t ibmvfc_read_trace(struct file *filp, struct kobject *kobj,
  2726. struct bin_attribute *bin_attr,
  2727. char *buf, loff_t off, size_t count)
  2728. {
  2729. struct device *dev = container_of(kobj, struct device, kobj);
  2730. struct Scsi_Host *shost = class_to_shost(dev);
  2731. struct ibmvfc_host *vhost = shost_priv(shost);
  2732. unsigned long flags = 0;
  2733. int size = IBMVFC_TRACE_SIZE;
  2734. char *src = (char *)vhost->trace;
  2735. if (off > size)
  2736. return 0;
  2737. if (off + count > size) {
  2738. size -= off;
  2739. count = size;
  2740. }
  2741. spin_lock_irqsave(shost->host_lock, flags);
  2742. memcpy(buf, &src[off], count);
  2743. spin_unlock_irqrestore(shost->host_lock, flags);
  2744. return count;
  2745. }
  2746. static struct bin_attribute ibmvfc_trace_attr = {
  2747. .attr = {
  2748. .name = "trace",
  2749. .mode = S_IRUGO,
  2750. },
  2751. .size = 0,
  2752. .read = ibmvfc_read_trace,
  2753. };
  2754. #endif
  2755. static struct device_attribute *ibmvfc_attrs[] = {
  2756. &dev_attr_partition_name,
  2757. &dev_attr_device_name,
  2758. &dev_attr_port_loc_code,
  2759. &dev_attr_drc_name,
  2760. &dev_attr_npiv_version,
  2761. &dev_attr_capabilities,
  2762. &dev_attr_log_level,
  2763. NULL
  2764. };
  2765. static struct scsi_host_template driver_template = {
  2766. .module = THIS_MODULE,
  2767. .name = "IBM POWER Virtual FC Adapter",
  2768. .proc_name = IBMVFC_NAME,
  2769. .queuecommand = ibmvfc_queuecommand,
  2770. .eh_abort_handler = ibmvfc_eh_abort_handler,
  2771. .eh_device_reset_handler = ibmvfc_eh_device_reset_handler,
  2772. .eh_target_reset_handler = ibmvfc_eh_target_reset_handler,
  2773. .eh_host_reset_handler = ibmvfc_eh_host_reset_handler,
  2774. .slave_alloc = ibmvfc_slave_alloc,
  2775. .slave_configure = ibmvfc_slave_configure,
  2776. .target_alloc = ibmvfc_target_alloc,
  2777. .scan_finished = ibmvfc_scan_finished,
  2778. .change_queue_depth = ibmvfc_change_queue_depth,
  2779. .change_queue_type = ibmvfc_change_queue_type,
  2780. .cmd_per_lun = 16,
  2781. .can_queue = IBMVFC_MAX_REQUESTS_DEFAULT,
  2782. .this_id = -1,
  2783. .sg_tablesize = SG_ALL,
  2784. .max_sectors = IBMVFC_MAX_SECTORS,
  2785. .use_clustering = ENABLE_CLUSTERING,
  2786. .shost_attrs = ibmvfc_attrs,
  2787. };
  2788. /**
  2789. * ibmvfc_next_async_crq - Returns the next entry in async queue
  2790. * @vhost: ibmvfc host struct
  2791. *
  2792. * Returns:
  2793. * Pointer to next entry in queue / NULL if empty
  2794. **/
  2795. static struct ibmvfc_async_crq *ibmvfc_next_async_crq(struct ibmvfc_host *vhost)
  2796. {
  2797. struct ibmvfc_async_crq_queue *async_crq = &vhost->async_crq;
  2798. struct ibmvfc_async_crq *crq;
  2799. crq = &async_crq->msgs[async_crq->cur];
  2800. if (crq->valid & 0x80) {
  2801. if (++async_crq->cur == async_crq->size)
  2802. async_crq->cur = 0;
  2803. rmb();
  2804. } else
  2805. crq = NULL;
  2806. return crq;
  2807. }
  2808. /**
  2809. * ibmvfc_next_crq - Returns the next entry in message queue
  2810. * @vhost: ibmvfc host struct
  2811. *
  2812. * Returns:
  2813. * Pointer to next entry in queue / NULL if empty
  2814. **/
  2815. static struct ibmvfc_crq *ibmvfc_next_crq(struct ibmvfc_host *vhost)
  2816. {
  2817. struct ibmvfc_crq_queue *queue = &vhost->crq;
  2818. struct ibmvfc_crq *crq;
  2819. crq = &queue->msgs[queue->cur];
  2820. if (crq->valid & 0x80) {
  2821. if (++queue->cur == queue->size)
  2822. queue->cur = 0;
  2823. rmb();
  2824. } else
  2825. crq = NULL;
  2826. return crq;
  2827. }
  2828. /**
  2829. * ibmvfc_interrupt - Interrupt handler
  2830. * @irq: number of irq to handle, not used
  2831. * @dev_instance: ibmvfc_host that received interrupt
  2832. *
  2833. * Returns:
  2834. * IRQ_HANDLED
  2835. **/
  2836. static irqreturn_t ibmvfc_interrupt(int irq, void *dev_instance)
  2837. {
  2838. struct ibmvfc_host *vhost = (struct ibmvfc_host *)dev_instance;
  2839. unsigned long flags;
  2840. spin_lock_irqsave(vhost->host->host_lock, flags);
  2841. vio_disable_interrupts(to_vio_dev(vhost->dev));
  2842. tasklet_schedule(&vhost->tasklet);
  2843. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2844. return IRQ_HANDLED;
  2845. }
  2846. /**
  2847. * ibmvfc_tasklet - Interrupt handler tasklet
  2848. * @data: ibmvfc host struct
  2849. *
  2850. * Returns:
  2851. * Nothing
  2852. **/
  2853. static void ibmvfc_tasklet(void *data)
  2854. {
  2855. struct ibmvfc_host *vhost = data;
  2856. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  2857. struct ibmvfc_crq *crq;
  2858. struct ibmvfc_async_crq *async;
  2859. unsigned long flags;
  2860. int done = 0;
  2861. spin_lock_irqsave(vhost->host->host_lock, flags);
  2862. while (!done) {
  2863. /* Pull all the valid messages off the async CRQ */
  2864. while ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
  2865. ibmvfc_handle_async(async, vhost);
  2866. async->valid = 0;
  2867. wmb();
  2868. }
  2869. /* Pull all the valid messages off the CRQ */
  2870. while ((crq = ibmvfc_next_crq(vhost)) != NULL) {
  2871. ibmvfc_handle_crq(crq, vhost);
  2872. crq->valid = 0;
  2873. wmb();
  2874. }
  2875. vio_enable_interrupts(vdev);
  2876. if ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
  2877. vio_disable_interrupts(vdev);
  2878. ibmvfc_handle_async(async, vhost);
  2879. async->valid = 0;
  2880. wmb();
  2881. } else if ((crq = ibmvfc_next_crq(vhost)) != NULL) {
  2882. vio_disable_interrupts(vdev);
  2883. ibmvfc_handle_crq(crq, vhost);
  2884. crq->valid = 0;
  2885. wmb();
  2886. } else
  2887. done = 1;
  2888. }
  2889. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2890. }
  2891. /**
  2892. * ibmvfc_init_tgt - Set the next init job step for the target
  2893. * @tgt: ibmvfc target struct
  2894. * @job_step: job step to perform
  2895. *
  2896. **/
  2897. static void ibmvfc_init_tgt(struct ibmvfc_target *tgt,
  2898. void (*job_step) (struct ibmvfc_target *))
  2899. {
  2900. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT);
  2901. tgt->job_step = job_step;
  2902. wake_up(&tgt->vhost->work_wait_q);
  2903. }
  2904. /**
  2905. * ibmvfc_retry_tgt_init - Attempt to retry a step in target initialization
  2906. * @tgt: ibmvfc target struct
  2907. * @job_step: initialization job step
  2908. *
  2909. * Returns: 1 if step will be retried / 0 if not
  2910. *
  2911. **/
  2912. static int ibmvfc_retry_tgt_init(struct ibmvfc_target *tgt,
  2913. void (*job_step) (struct ibmvfc_target *))
  2914. {
  2915. if (++tgt->init_retries > IBMVFC_MAX_TGT_INIT_RETRIES) {
  2916. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2917. wake_up(&tgt->vhost->work_wait_q);
  2918. return 0;
  2919. } else
  2920. ibmvfc_init_tgt(tgt, job_step);
  2921. return 1;
  2922. }
  2923. /* Defined in FC-LS */
  2924. static const struct {
  2925. int code;
  2926. int retry;
  2927. int logged_in;
  2928. } prli_rsp [] = {
  2929. { 0, 1, 0 },
  2930. { 1, 0, 1 },
  2931. { 2, 1, 0 },
  2932. { 3, 1, 0 },
  2933. { 4, 0, 0 },
  2934. { 5, 0, 0 },
  2935. { 6, 0, 1 },
  2936. { 7, 0, 0 },
  2937. { 8, 1, 0 },
  2938. };
  2939. /**
  2940. * ibmvfc_get_prli_rsp - Find PRLI response index
  2941. * @flags: PRLI response flags
  2942. *
  2943. **/
  2944. static int ibmvfc_get_prli_rsp(u16 flags)
  2945. {
  2946. int i;
  2947. int code = (flags & 0x0f00) >> 8;
  2948. for (i = 0; i < ARRAY_SIZE(prli_rsp); i++)
  2949. if (prli_rsp[i].code == code)
  2950. return i;
  2951. return 0;
  2952. }
  2953. /**
  2954. * ibmvfc_tgt_prli_done - Completion handler for Process Login
  2955. * @evt: ibmvfc event struct
  2956. *
  2957. **/
  2958. static void ibmvfc_tgt_prli_done(struct ibmvfc_event *evt)
  2959. {
  2960. struct ibmvfc_target *tgt = evt->tgt;
  2961. struct ibmvfc_host *vhost = evt->vhost;
  2962. struct ibmvfc_process_login *rsp = &evt->xfer_iu->prli;
  2963. struct ibmvfc_prli_svc_parms *parms = &rsp->parms;
  2964. u32 status = rsp->common.status;
  2965. int index, level = IBMVFC_DEFAULT_LOG_LEVEL;
  2966. vhost->discovery_threads--;
  2967. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  2968. switch (status) {
  2969. case IBMVFC_MAD_SUCCESS:
  2970. tgt_dbg(tgt, "Process Login succeeded: %X %02X %04X\n",
  2971. parms->type, parms->flags, parms->service_parms);
  2972. if (parms->type == IBMVFC_SCSI_FCP_TYPE) {
  2973. index = ibmvfc_get_prli_rsp(parms->flags);
  2974. if (prli_rsp[index].logged_in) {
  2975. if (parms->flags & IBMVFC_PRLI_EST_IMG_PAIR) {
  2976. tgt->need_login = 0;
  2977. tgt->ids.roles = 0;
  2978. if (parms->service_parms & IBMVFC_PRLI_TARGET_FUNC)
  2979. tgt->ids.roles |= FC_PORT_ROLE_FCP_TARGET;
  2980. if (parms->service_parms & IBMVFC_PRLI_INITIATOR_FUNC)
  2981. tgt->ids.roles |= FC_PORT_ROLE_FCP_INITIATOR;
  2982. tgt->add_rport = 1;
  2983. } else
  2984. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2985. } else if (prli_rsp[index].retry)
  2986. ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
  2987. else
  2988. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2989. } else
  2990. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2991. break;
  2992. case IBMVFC_MAD_DRIVER_FAILED:
  2993. break;
  2994. case IBMVFC_MAD_CRQ_ERROR:
  2995. ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
  2996. break;
  2997. case IBMVFC_MAD_FAILED:
  2998. default:
  2999. if ((rsp->status & IBMVFC_VIOS_FAILURE) && rsp->error == IBMVFC_PLOGI_REQUIRED)
  3000. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
  3001. else if (tgt->logo_rcvd)
  3002. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
  3003. else if (ibmvfc_retry_cmd(rsp->status, rsp->error))
  3004. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
  3005. else
  3006. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3007. tgt_log(tgt, level, "Process Login failed: %s (%x:%x) rc=0x%02X\n",
  3008. ibmvfc_get_cmd_error(rsp->status, rsp->error),
  3009. rsp->status, rsp->error, status);
  3010. break;
  3011. };
  3012. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3013. ibmvfc_free_event(evt);
  3014. wake_up(&vhost->work_wait_q);
  3015. }
  3016. /**
  3017. * ibmvfc_tgt_send_prli - Send a process login
  3018. * @tgt: ibmvfc target struct
  3019. *
  3020. **/
  3021. static void ibmvfc_tgt_send_prli(struct ibmvfc_target *tgt)
  3022. {
  3023. struct ibmvfc_process_login *prli;
  3024. struct ibmvfc_host *vhost = tgt->vhost;
  3025. struct ibmvfc_event *evt;
  3026. if (vhost->discovery_threads >= disc_threads)
  3027. return;
  3028. kref_get(&tgt->kref);
  3029. evt = ibmvfc_get_event(vhost);
  3030. vhost->discovery_threads++;
  3031. ibmvfc_init_event(evt, ibmvfc_tgt_prli_done, IBMVFC_MAD_FORMAT);
  3032. evt->tgt = tgt;
  3033. prli = &evt->iu.prli;
  3034. memset(prli, 0, sizeof(*prli));
  3035. prli->common.version = 1;
  3036. prli->common.opcode = IBMVFC_PROCESS_LOGIN;
  3037. prli->common.length = sizeof(*prli);
  3038. prli->scsi_id = tgt->scsi_id;
  3039. prli->parms.type = IBMVFC_SCSI_FCP_TYPE;
  3040. prli->parms.flags = IBMVFC_PRLI_EST_IMG_PAIR;
  3041. prli->parms.service_parms = IBMVFC_PRLI_INITIATOR_FUNC;
  3042. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3043. if (ibmvfc_send_event(evt, vhost, default_timeout)) {
  3044. vhost->discovery_threads--;
  3045. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3046. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3047. } else
  3048. tgt_dbg(tgt, "Sent process login\n");
  3049. }
  3050. /**
  3051. * ibmvfc_tgt_plogi_done - Completion handler for Port Login
  3052. * @evt: ibmvfc event struct
  3053. *
  3054. **/
  3055. static void ibmvfc_tgt_plogi_done(struct ibmvfc_event *evt)
  3056. {
  3057. struct ibmvfc_target *tgt = evt->tgt;
  3058. struct ibmvfc_host *vhost = evt->vhost;
  3059. struct ibmvfc_port_login *rsp = &evt->xfer_iu->plogi;
  3060. u32 status = rsp->common.status;
  3061. int level = IBMVFC_DEFAULT_LOG_LEVEL;
  3062. vhost->discovery_threads--;
  3063. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3064. switch (status) {
  3065. case IBMVFC_MAD_SUCCESS:
  3066. tgt_dbg(tgt, "Port Login succeeded\n");
  3067. if (tgt->ids.port_name &&
  3068. tgt->ids.port_name != wwn_to_u64(rsp->service_parms.port_name)) {
  3069. vhost->reinit = 1;
  3070. tgt_dbg(tgt, "Port re-init required\n");
  3071. break;
  3072. }
  3073. tgt->ids.node_name = wwn_to_u64(rsp->service_parms.node_name);
  3074. tgt->ids.port_name = wwn_to_u64(rsp->service_parms.port_name);
  3075. tgt->ids.port_id = tgt->scsi_id;
  3076. memcpy(&tgt->service_parms, &rsp->service_parms,
  3077. sizeof(tgt->service_parms));
  3078. memcpy(&tgt->service_parms_change, &rsp->service_parms_change,
  3079. sizeof(tgt->service_parms_change));
  3080. ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_prli);
  3081. break;
  3082. case IBMVFC_MAD_DRIVER_FAILED:
  3083. break;
  3084. case IBMVFC_MAD_CRQ_ERROR:
  3085. ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
  3086. break;
  3087. case IBMVFC_MAD_FAILED:
  3088. default:
  3089. if (ibmvfc_retry_cmd(rsp->status, rsp->error))
  3090. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
  3091. else
  3092. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3093. tgt_log(tgt, level, "Port Login failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
  3094. ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error,
  3095. ibmvfc_get_fc_type(rsp->fc_type), rsp->fc_type,
  3096. ibmvfc_get_ls_explain(rsp->fc_explain), rsp->fc_explain, status);
  3097. break;
  3098. };
  3099. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3100. ibmvfc_free_event(evt);
  3101. wake_up(&vhost->work_wait_q);
  3102. }
  3103. /**
  3104. * ibmvfc_tgt_send_plogi - Send PLOGI to the specified target
  3105. * @tgt: ibmvfc target struct
  3106. *
  3107. **/
  3108. static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *tgt)
  3109. {
  3110. struct ibmvfc_port_login *plogi;
  3111. struct ibmvfc_host *vhost = tgt->vhost;
  3112. struct ibmvfc_event *evt;
  3113. if (vhost->discovery_threads >= disc_threads)
  3114. return;
  3115. kref_get(&tgt->kref);
  3116. tgt->logo_rcvd = 0;
  3117. evt = ibmvfc_get_event(vhost);
  3118. vhost->discovery_threads++;
  3119. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3120. ibmvfc_init_event(evt, ibmvfc_tgt_plogi_done, IBMVFC_MAD_FORMAT);
  3121. evt->tgt = tgt;
  3122. plogi = &evt->iu.plogi;
  3123. memset(plogi, 0, sizeof(*plogi));
  3124. plogi->common.version = 1;
  3125. plogi->common.opcode = IBMVFC_PORT_LOGIN;
  3126. plogi->common.length = sizeof(*plogi);
  3127. plogi->scsi_id = tgt->scsi_id;
  3128. if (ibmvfc_send_event(evt, vhost, default_timeout)) {
  3129. vhost->discovery_threads--;
  3130. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3131. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3132. } else
  3133. tgt_dbg(tgt, "Sent port login\n");
  3134. }
  3135. /**
  3136. * ibmvfc_tgt_implicit_logout_done - Completion handler for Implicit Logout MAD
  3137. * @evt: ibmvfc event struct
  3138. *
  3139. **/
  3140. static void ibmvfc_tgt_implicit_logout_done(struct ibmvfc_event *evt)
  3141. {
  3142. struct ibmvfc_target *tgt = evt->tgt;
  3143. struct ibmvfc_host *vhost = evt->vhost;
  3144. struct ibmvfc_implicit_logout *rsp = &evt->xfer_iu->implicit_logout;
  3145. u32 status = rsp->common.status;
  3146. vhost->discovery_threads--;
  3147. ibmvfc_free_event(evt);
  3148. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3149. switch (status) {
  3150. case IBMVFC_MAD_SUCCESS:
  3151. tgt_dbg(tgt, "Implicit Logout succeeded\n");
  3152. break;
  3153. case IBMVFC_MAD_DRIVER_FAILED:
  3154. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3155. wake_up(&vhost->work_wait_q);
  3156. return;
  3157. case IBMVFC_MAD_FAILED:
  3158. default:
  3159. tgt_err(tgt, "Implicit Logout failed: rc=0x%02X\n", status);
  3160. break;
  3161. };
  3162. if (vhost->action == IBMVFC_HOST_ACTION_TGT_INIT)
  3163. ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_plogi);
  3164. else if (vhost->action == IBMVFC_HOST_ACTION_QUERY_TGTS &&
  3165. tgt->scsi_id != tgt->new_scsi_id)
  3166. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3167. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3168. wake_up(&vhost->work_wait_q);
  3169. }
  3170. /**
  3171. * ibmvfc_tgt_implicit_logout - Initiate an Implicit Logout for specified target
  3172. * @tgt: ibmvfc target struct
  3173. *
  3174. **/
  3175. static void ibmvfc_tgt_implicit_logout(struct ibmvfc_target *tgt)
  3176. {
  3177. struct ibmvfc_implicit_logout *mad;
  3178. struct ibmvfc_host *vhost = tgt->vhost;
  3179. struct ibmvfc_event *evt;
  3180. if (vhost->discovery_threads >= disc_threads)
  3181. return;
  3182. kref_get(&tgt->kref);
  3183. evt = ibmvfc_get_event(vhost);
  3184. vhost->discovery_threads++;
  3185. ibmvfc_init_event(evt, ibmvfc_tgt_implicit_logout_done, IBMVFC_MAD_FORMAT);
  3186. evt->tgt = tgt;
  3187. mad = &evt->iu.implicit_logout;
  3188. memset(mad, 0, sizeof(*mad));
  3189. mad->common.version = 1;
  3190. mad->common.opcode = IBMVFC_IMPLICIT_LOGOUT;
  3191. mad->common.length = sizeof(*mad);
  3192. mad->old_scsi_id = tgt->scsi_id;
  3193. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3194. if (ibmvfc_send_event(evt, vhost, default_timeout)) {
  3195. vhost->discovery_threads--;
  3196. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3197. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3198. } else
  3199. tgt_dbg(tgt, "Sent Implicit Logout\n");
  3200. }
  3201. /**
  3202. * ibmvfc_adisc_needs_plogi - Does device need PLOGI?
  3203. * @mad: ibmvfc passthru mad struct
  3204. * @tgt: ibmvfc target struct
  3205. *
  3206. * Returns:
  3207. * 1 if PLOGI needed / 0 if PLOGI not needed
  3208. **/
  3209. static int ibmvfc_adisc_needs_plogi(struct ibmvfc_passthru_mad *mad,
  3210. struct ibmvfc_target *tgt)
  3211. {
  3212. if (memcmp(&mad->fc_iu.response[2], &tgt->ids.port_name,
  3213. sizeof(tgt->ids.port_name)))
  3214. return 1;
  3215. if (memcmp(&mad->fc_iu.response[4], &tgt->ids.node_name,
  3216. sizeof(tgt->ids.node_name)))
  3217. return 1;
  3218. if (mad->fc_iu.response[6] != tgt->scsi_id)
  3219. return 1;
  3220. return 0;
  3221. }
  3222. /**
  3223. * ibmvfc_tgt_adisc_done - Completion handler for ADISC
  3224. * @evt: ibmvfc event struct
  3225. *
  3226. **/
  3227. static void ibmvfc_tgt_adisc_done(struct ibmvfc_event *evt)
  3228. {
  3229. struct ibmvfc_target *tgt = evt->tgt;
  3230. struct ibmvfc_host *vhost = evt->vhost;
  3231. struct ibmvfc_passthru_mad *mad = &evt->xfer_iu->passthru;
  3232. u32 status = mad->common.status;
  3233. u8 fc_reason, fc_explain;
  3234. vhost->discovery_threads--;
  3235. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3236. del_timer(&tgt->timer);
  3237. switch (status) {
  3238. case IBMVFC_MAD_SUCCESS:
  3239. tgt_dbg(tgt, "ADISC succeeded\n");
  3240. if (ibmvfc_adisc_needs_plogi(mad, tgt))
  3241. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3242. break;
  3243. case IBMVFC_MAD_DRIVER_FAILED:
  3244. break;
  3245. case IBMVFC_MAD_FAILED:
  3246. default:
  3247. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3248. fc_reason = (mad->fc_iu.response[1] & 0x00ff0000) >> 16;
  3249. fc_explain = (mad->fc_iu.response[1] & 0x0000ff00) >> 8;
  3250. tgt_info(tgt, "ADISC failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
  3251. ibmvfc_get_cmd_error(mad->iu.status, mad->iu.error),
  3252. mad->iu.status, mad->iu.error,
  3253. ibmvfc_get_fc_type(fc_reason), fc_reason,
  3254. ibmvfc_get_ls_explain(fc_explain), fc_explain, status);
  3255. break;
  3256. };
  3257. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3258. ibmvfc_free_event(evt);
  3259. wake_up(&vhost->work_wait_q);
  3260. }
  3261. /**
  3262. * ibmvfc_init_passthru - Initialize an event struct for FC passthru
  3263. * @evt: ibmvfc event struct
  3264. *
  3265. **/
  3266. static void ibmvfc_init_passthru(struct ibmvfc_event *evt)
  3267. {
  3268. struct ibmvfc_passthru_mad *mad = &evt->iu.passthru;
  3269. memset(mad, 0, sizeof(*mad));
  3270. mad->common.version = 1;
  3271. mad->common.opcode = IBMVFC_PASSTHRU;
  3272. mad->common.length = sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu);
  3273. mad->cmd_ioba.va = (u64)evt->crq.ioba +
  3274. offsetof(struct ibmvfc_passthru_mad, iu);
  3275. mad->cmd_ioba.len = sizeof(mad->iu);
  3276. mad->iu.cmd_len = sizeof(mad->fc_iu.payload);
  3277. mad->iu.rsp_len = sizeof(mad->fc_iu.response);
  3278. mad->iu.cmd.va = (u64)evt->crq.ioba +
  3279. offsetof(struct ibmvfc_passthru_mad, fc_iu) +
  3280. offsetof(struct ibmvfc_passthru_fc_iu, payload);
  3281. mad->iu.cmd.len = sizeof(mad->fc_iu.payload);
  3282. mad->iu.rsp.va = (u64)evt->crq.ioba +
  3283. offsetof(struct ibmvfc_passthru_mad, fc_iu) +
  3284. offsetof(struct ibmvfc_passthru_fc_iu, response);
  3285. mad->iu.rsp.len = sizeof(mad->fc_iu.response);
  3286. }
  3287. /**
  3288. * ibmvfc_tgt_adisc_cancel_done - Completion handler when cancelling an ADISC
  3289. * @evt: ibmvfc event struct
  3290. *
  3291. * Just cleanup this event struct. Everything else is handled by
  3292. * the ADISC completion handler. If the ADISC never actually comes
  3293. * back, we still have the timer running on the ADISC event struct
  3294. * which will fire and cause the CRQ to get reset.
  3295. *
  3296. **/
  3297. static void ibmvfc_tgt_adisc_cancel_done(struct ibmvfc_event *evt)
  3298. {
  3299. struct ibmvfc_host *vhost = evt->vhost;
  3300. struct ibmvfc_target *tgt = evt->tgt;
  3301. tgt_dbg(tgt, "ADISC cancel complete\n");
  3302. vhost->abort_threads--;
  3303. ibmvfc_free_event(evt);
  3304. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3305. wake_up(&vhost->work_wait_q);
  3306. }
  3307. /**
  3308. * ibmvfc_adisc_timeout - Handle an ADISC timeout
  3309. * @tgt: ibmvfc target struct
  3310. *
  3311. * If an ADISC times out, send a cancel. If the cancel times
  3312. * out, reset the CRQ. When the ADISC comes back as cancelled,
  3313. * log back into the target.
  3314. **/
  3315. static void ibmvfc_adisc_timeout(struct ibmvfc_target *tgt)
  3316. {
  3317. struct ibmvfc_host *vhost = tgt->vhost;
  3318. struct ibmvfc_event *evt;
  3319. struct ibmvfc_tmf *tmf;
  3320. unsigned long flags;
  3321. int rc;
  3322. tgt_dbg(tgt, "ADISC timeout\n");
  3323. spin_lock_irqsave(vhost->host->host_lock, flags);
  3324. if (vhost->abort_threads >= disc_threads ||
  3325. tgt->action != IBMVFC_TGT_ACTION_INIT_WAIT ||
  3326. vhost->state != IBMVFC_INITIALIZING ||
  3327. vhost->action != IBMVFC_HOST_ACTION_QUERY_TGTS) {
  3328. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3329. return;
  3330. }
  3331. vhost->abort_threads++;
  3332. kref_get(&tgt->kref);
  3333. evt = ibmvfc_get_event(vhost);
  3334. ibmvfc_init_event(evt, ibmvfc_tgt_adisc_cancel_done, IBMVFC_MAD_FORMAT);
  3335. evt->tgt = tgt;
  3336. tmf = &evt->iu.tmf;
  3337. memset(tmf, 0, sizeof(*tmf));
  3338. tmf->common.version = 1;
  3339. tmf->common.opcode = IBMVFC_TMF_MAD;
  3340. tmf->common.length = sizeof(*tmf);
  3341. tmf->scsi_id = tgt->scsi_id;
  3342. tmf->cancel_key = tgt->cancel_key;
  3343. rc = ibmvfc_send_event(evt, vhost, default_timeout);
  3344. if (rc) {
  3345. tgt_err(tgt, "Failed to send cancel event for ADISC. rc=%d\n", rc);
  3346. vhost->abort_threads--;
  3347. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3348. __ibmvfc_reset_host(vhost);
  3349. } else
  3350. tgt_dbg(tgt, "Attempting to cancel ADISC\n");
  3351. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3352. }
  3353. /**
  3354. * ibmvfc_tgt_adisc - Initiate an ADISC for specified target
  3355. * @tgt: ibmvfc target struct
  3356. *
  3357. * When sending an ADISC we end up with two timers running. The
  3358. * first timer is the timer in the ibmvfc target struct. If this
  3359. * fires, we send a cancel to the target. The second timer is the
  3360. * timer on the ibmvfc event for the ADISC, which is longer. If that
  3361. * fires, it means the ADISC timed out and our attempt to cancel it
  3362. * also failed, so we need to reset the CRQ.
  3363. **/
  3364. static void ibmvfc_tgt_adisc(struct ibmvfc_target *tgt)
  3365. {
  3366. struct ibmvfc_passthru_mad *mad;
  3367. struct ibmvfc_host *vhost = tgt->vhost;
  3368. struct ibmvfc_event *evt;
  3369. if (vhost->discovery_threads >= disc_threads)
  3370. return;
  3371. kref_get(&tgt->kref);
  3372. evt = ibmvfc_get_event(vhost);
  3373. vhost->discovery_threads++;
  3374. ibmvfc_init_event(evt, ibmvfc_tgt_adisc_done, IBMVFC_MAD_FORMAT);
  3375. evt->tgt = tgt;
  3376. ibmvfc_init_passthru(evt);
  3377. mad = &evt->iu.passthru;
  3378. mad->iu.flags = IBMVFC_FC_ELS;
  3379. mad->iu.scsi_id = tgt->scsi_id;
  3380. mad->iu.cancel_key = tgt->cancel_key;
  3381. mad->fc_iu.payload[0] = IBMVFC_ADISC;
  3382. memcpy(&mad->fc_iu.payload[2], &vhost->login_buf->resp.port_name,
  3383. sizeof(vhost->login_buf->resp.port_name));
  3384. memcpy(&mad->fc_iu.payload[4], &vhost->login_buf->resp.node_name,
  3385. sizeof(vhost->login_buf->resp.node_name));
  3386. mad->fc_iu.payload[6] = vhost->login_buf->resp.scsi_id & 0x00ffffff;
  3387. if (timer_pending(&tgt->timer))
  3388. mod_timer(&tgt->timer, jiffies + (IBMVFC_ADISC_TIMEOUT * HZ));
  3389. else {
  3390. tgt->timer.data = (unsigned long) tgt;
  3391. tgt->timer.expires = jiffies + (IBMVFC_ADISC_TIMEOUT * HZ);
  3392. tgt->timer.function = (void (*)(unsigned long))ibmvfc_adisc_timeout;
  3393. add_timer(&tgt->timer);
  3394. }
  3395. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3396. if (ibmvfc_send_event(evt, vhost, IBMVFC_ADISC_PLUS_CANCEL_TIMEOUT)) {
  3397. vhost->discovery_threads--;
  3398. del_timer(&tgt->timer);
  3399. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3400. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3401. } else
  3402. tgt_dbg(tgt, "Sent ADISC\n");
  3403. }
  3404. /**
  3405. * ibmvfc_tgt_query_target_done - Completion handler for Query Target MAD
  3406. * @evt: ibmvfc event struct
  3407. *
  3408. **/
  3409. static void ibmvfc_tgt_query_target_done(struct ibmvfc_event *evt)
  3410. {
  3411. struct ibmvfc_target *tgt = evt->tgt;
  3412. struct ibmvfc_host *vhost = evt->vhost;
  3413. struct ibmvfc_query_tgt *rsp = &evt->xfer_iu->query_tgt;
  3414. u32 status = rsp->common.status;
  3415. int level = IBMVFC_DEFAULT_LOG_LEVEL;
  3416. vhost->discovery_threads--;
  3417. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3418. switch (status) {
  3419. case IBMVFC_MAD_SUCCESS:
  3420. tgt_dbg(tgt, "Query Target succeeded\n");
  3421. tgt->new_scsi_id = rsp->scsi_id;
  3422. if (rsp->scsi_id != tgt->scsi_id)
  3423. ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
  3424. else
  3425. ibmvfc_init_tgt(tgt, ibmvfc_tgt_adisc);
  3426. break;
  3427. case IBMVFC_MAD_DRIVER_FAILED:
  3428. break;
  3429. case IBMVFC_MAD_CRQ_ERROR:
  3430. ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
  3431. break;
  3432. case IBMVFC_MAD_FAILED:
  3433. default:
  3434. if ((rsp->status & IBMVFC_FABRIC_MAPPED) == IBMVFC_FABRIC_MAPPED &&
  3435. rsp->error == IBMVFC_UNABLE_TO_PERFORM_REQ &&
  3436. rsp->fc_explain == IBMVFC_PORT_NAME_NOT_REG)
  3437. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3438. else if (ibmvfc_retry_cmd(rsp->status, rsp->error))
  3439. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
  3440. else
  3441. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3442. tgt_log(tgt, level, "Query Target failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
  3443. ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error,
  3444. ibmvfc_get_fc_type(rsp->fc_type), rsp->fc_type,
  3445. ibmvfc_get_gs_explain(rsp->fc_explain), rsp->fc_explain, status);
  3446. break;
  3447. };
  3448. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3449. ibmvfc_free_event(evt);
  3450. wake_up(&vhost->work_wait_q);
  3451. }
  3452. /**
  3453. * ibmvfc_tgt_query_target - Initiate a Query Target for specified target
  3454. * @tgt: ibmvfc target struct
  3455. *
  3456. **/
  3457. static void ibmvfc_tgt_query_target(struct ibmvfc_target *tgt)
  3458. {
  3459. struct ibmvfc_query_tgt *query_tgt;
  3460. struct ibmvfc_host *vhost = tgt->vhost;
  3461. struct ibmvfc_event *evt;
  3462. if (vhost->discovery_threads >= disc_threads)
  3463. return;
  3464. kref_get(&tgt->kref);
  3465. evt = ibmvfc_get_event(vhost);
  3466. vhost->discovery_threads++;
  3467. evt->tgt = tgt;
  3468. ibmvfc_init_event(evt, ibmvfc_tgt_query_target_done, IBMVFC_MAD_FORMAT);
  3469. query_tgt = &evt->iu.query_tgt;
  3470. memset(query_tgt, 0, sizeof(*query_tgt));
  3471. query_tgt->common.version = 1;
  3472. query_tgt->common.opcode = IBMVFC_QUERY_TARGET;
  3473. query_tgt->common.length = sizeof(*query_tgt);
  3474. query_tgt->wwpn = tgt->ids.port_name;
  3475. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3476. if (ibmvfc_send_event(evt, vhost, default_timeout)) {
  3477. vhost->discovery_threads--;
  3478. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3479. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3480. } else
  3481. tgt_dbg(tgt, "Sent Query Target\n");
  3482. }
  3483. /**
  3484. * ibmvfc_alloc_target - Allocate and initialize an ibmvfc target
  3485. * @vhost: ibmvfc host struct
  3486. * @scsi_id: SCSI ID to allocate target for
  3487. *
  3488. * Returns:
  3489. * 0 on success / other on failure
  3490. **/
  3491. static int ibmvfc_alloc_target(struct ibmvfc_host *vhost, u64 scsi_id)
  3492. {
  3493. struct ibmvfc_target *tgt;
  3494. unsigned long flags;
  3495. spin_lock_irqsave(vhost->host->host_lock, flags);
  3496. list_for_each_entry(tgt, &vhost->targets, queue) {
  3497. if (tgt->scsi_id == scsi_id) {
  3498. if (tgt->need_login)
  3499. ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
  3500. goto unlock_out;
  3501. }
  3502. }
  3503. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3504. tgt = mempool_alloc(vhost->tgt_pool, GFP_NOIO);
  3505. if (!tgt) {
  3506. dev_err(vhost->dev, "Target allocation failure for scsi id %08llx\n",
  3507. scsi_id);
  3508. return -ENOMEM;
  3509. }
  3510. memset(tgt, 0, sizeof(*tgt));
  3511. tgt->scsi_id = scsi_id;
  3512. tgt->new_scsi_id = scsi_id;
  3513. tgt->vhost = vhost;
  3514. tgt->need_login = 1;
  3515. tgt->cancel_key = vhost->task_set++;
  3516. init_timer(&tgt->timer);
  3517. kref_init(&tgt->kref);
  3518. ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
  3519. spin_lock_irqsave(vhost->host->host_lock, flags);
  3520. list_add_tail(&tgt->queue, &vhost->targets);
  3521. unlock_out:
  3522. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3523. return 0;
  3524. }
  3525. /**
  3526. * ibmvfc_alloc_targets - Allocate and initialize ibmvfc targets
  3527. * @vhost: ibmvfc host struct
  3528. *
  3529. * Returns:
  3530. * 0 on success / other on failure
  3531. **/
  3532. static int ibmvfc_alloc_targets(struct ibmvfc_host *vhost)
  3533. {
  3534. int i, rc;
  3535. for (i = 0, rc = 0; !rc && i < vhost->num_targets; i++)
  3536. rc = ibmvfc_alloc_target(vhost,
  3537. vhost->disc_buf->scsi_id[i] & IBMVFC_DISC_TGT_SCSI_ID_MASK);
  3538. return rc;
  3539. }
  3540. /**
  3541. * ibmvfc_discover_targets_done - Completion handler for discover targets MAD
  3542. * @evt: ibmvfc event struct
  3543. *
  3544. **/
  3545. static void ibmvfc_discover_targets_done(struct ibmvfc_event *evt)
  3546. {
  3547. struct ibmvfc_host *vhost = evt->vhost;
  3548. struct ibmvfc_discover_targets *rsp = &evt->xfer_iu->discover_targets;
  3549. u32 mad_status = rsp->common.status;
  3550. int level = IBMVFC_DEFAULT_LOG_LEVEL;
  3551. switch (mad_status) {
  3552. case IBMVFC_MAD_SUCCESS:
  3553. ibmvfc_dbg(vhost, "Discover Targets succeeded\n");
  3554. vhost->num_targets = rsp->num_written;
  3555. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_ALLOC_TGTS);
  3556. break;
  3557. case IBMVFC_MAD_FAILED:
  3558. level += ibmvfc_retry_host_init(vhost);
  3559. ibmvfc_log(vhost, level, "Discover Targets failed: %s (%x:%x)\n",
  3560. ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error);
  3561. break;
  3562. case IBMVFC_MAD_DRIVER_FAILED:
  3563. break;
  3564. default:
  3565. dev_err(vhost->dev, "Invalid Discover Targets response: 0x%x\n", mad_status);
  3566. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3567. break;
  3568. }
  3569. ibmvfc_free_event(evt);
  3570. wake_up(&vhost->work_wait_q);
  3571. }
  3572. /**
  3573. * ibmvfc_discover_targets - Send Discover Targets MAD
  3574. * @vhost: ibmvfc host struct
  3575. *
  3576. **/
  3577. static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)
  3578. {
  3579. struct ibmvfc_discover_targets *mad;
  3580. struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
  3581. ibmvfc_init_event(evt, ibmvfc_discover_targets_done, IBMVFC_MAD_FORMAT);
  3582. mad = &evt->iu.discover_targets;
  3583. memset(mad, 0, sizeof(*mad));
  3584. mad->common.version = 1;
  3585. mad->common.opcode = IBMVFC_DISC_TARGETS;
  3586. mad->common.length = sizeof(*mad);
  3587. mad->bufflen = vhost->disc_buf_sz;
  3588. mad->buffer.va = vhost->disc_buf_dma;
  3589. mad->buffer.len = vhost->disc_buf_sz;
  3590. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
  3591. if (!ibmvfc_send_event(evt, vhost, default_timeout))
  3592. ibmvfc_dbg(vhost, "Sent discover targets\n");
  3593. else
  3594. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3595. }
  3596. /**
  3597. * ibmvfc_npiv_login_done - Completion handler for NPIV Login
  3598. * @evt: ibmvfc event struct
  3599. *
  3600. **/
  3601. static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
  3602. {
  3603. struct ibmvfc_host *vhost = evt->vhost;
  3604. u32 mad_status = evt->xfer_iu->npiv_login.common.status;
  3605. struct ibmvfc_npiv_login_resp *rsp = &vhost->login_buf->resp;
  3606. unsigned int npiv_max_sectors;
  3607. int level = IBMVFC_DEFAULT_LOG_LEVEL;
  3608. switch (mad_status) {
  3609. case IBMVFC_MAD_SUCCESS:
  3610. ibmvfc_free_event(evt);
  3611. break;
  3612. case IBMVFC_MAD_FAILED:
  3613. if (ibmvfc_retry_cmd(rsp->status, rsp->error))
  3614. level += ibmvfc_retry_host_init(vhost);
  3615. else
  3616. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3617. ibmvfc_log(vhost, level, "NPIV Login failed: %s (%x:%x)\n",
  3618. ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error);
  3619. ibmvfc_free_event(evt);
  3620. return;
  3621. case IBMVFC_MAD_CRQ_ERROR:
  3622. ibmvfc_retry_host_init(vhost);
  3623. case IBMVFC_MAD_DRIVER_FAILED:
  3624. ibmvfc_free_event(evt);
  3625. return;
  3626. default:
  3627. dev_err(vhost->dev, "Invalid NPIV Login response: 0x%x\n", mad_status);
  3628. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3629. ibmvfc_free_event(evt);
  3630. return;
  3631. }
  3632. vhost->client_migrated = 0;
  3633. if (!(rsp->flags & IBMVFC_NATIVE_FC)) {
  3634. dev_err(vhost->dev, "Virtual adapter does not support FC. %x\n",
  3635. rsp->flags);
  3636. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3637. wake_up(&vhost->work_wait_q);
  3638. return;
  3639. }
  3640. if (rsp->max_cmds <= IBMVFC_NUM_INTERNAL_REQ) {
  3641. dev_err(vhost->dev, "Virtual adapter supported queue depth too small: %d\n",
  3642. rsp->max_cmds);
  3643. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3644. wake_up(&vhost->work_wait_q);
  3645. return;
  3646. }
  3647. vhost->logged_in = 1;
  3648. npiv_max_sectors = min((uint)(rsp->max_dma_len >> 9), IBMVFC_MAX_SECTORS);
  3649. dev_info(vhost->dev, "Host partition: %s, device: %s %s %s max sectors %u\n",
  3650. rsp->partition_name, rsp->device_name, rsp->port_loc_code,
  3651. rsp->drc_name, npiv_max_sectors);
  3652. fc_host_fabric_name(vhost->host) = rsp->node_name;
  3653. fc_host_node_name(vhost->host) = rsp->node_name;
  3654. fc_host_port_name(vhost->host) = rsp->port_name;
  3655. fc_host_port_id(vhost->host) = rsp->scsi_id;
  3656. fc_host_port_type(vhost->host) = FC_PORTTYPE_NPIV;
  3657. fc_host_supported_classes(vhost->host) = 0;
  3658. if (rsp->service_parms.class1_parms[0] & 0x80000000)
  3659. fc_host_supported_classes(vhost->host) |= FC_COS_CLASS1;
  3660. if (rsp->service_parms.class2_parms[0] & 0x80000000)
  3661. fc_host_supported_classes(vhost->host) |= FC_COS_CLASS2;
  3662. if (rsp->service_parms.class3_parms[0] & 0x80000000)
  3663. fc_host_supported_classes(vhost->host) |= FC_COS_CLASS3;
  3664. fc_host_maxframe_size(vhost->host) =
  3665. rsp->service_parms.common.bb_rcv_sz & 0x0fff;
  3666. vhost->host->can_queue = rsp->max_cmds - IBMVFC_NUM_INTERNAL_REQ;
  3667. vhost->host->max_sectors = npiv_max_sectors;
  3668. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
  3669. wake_up(&vhost->work_wait_q);
  3670. }
  3671. /**
  3672. * ibmvfc_npiv_login - Sends NPIV login
  3673. * @vhost: ibmvfc host struct
  3674. *
  3675. **/
  3676. static void ibmvfc_npiv_login(struct ibmvfc_host *vhost)
  3677. {
  3678. struct ibmvfc_npiv_login_mad *mad;
  3679. struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
  3680. ibmvfc_gather_partition_info(vhost);
  3681. ibmvfc_set_login_info(vhost);
  3682. ibmvfc_init_event(evt, ibmvfc_npiv_login_done, IBMVFC_MAD_FORMAT);
  3683. memcpy(vhost->login_buf, &vhost->login_info, sizeof(vhost->login_info));
  3684. mad = &evt->iu.npiv_login;
  3685. memset(mad, 0, sizeof(struct ibmvfc_npiv_login_mad));
  3686. mad->common.version = 1;
  3687. mad->common.opcode = IBMVFC_NPIV_LOGIN;
  3688. mad->common.length = sizeof(struct ibmvfc_npiv_login_mad);
  3689. mad->buffer.va = vhost->login_buf_dma;
  3690. mad->buffer.len = sizeof(*vhost->login_buf);
  3691. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
  3692. if (!ibmvfc_send_event(evt, vhost, default_timeout))
  3693. ibmvfc_dbg(vhost, "Sent NPIV login\n");
  3694. else
  3695. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3696. };
  3697. /**
  3698. * ibmvfc_npiv_logout_done - Completion handler for NPIV Logout
  3699. * @vhost: ibmvfc host struct
  3700. *
  3701. **/
  3702. static void ibmvfc_npiv_logout_done(struct ibmvfc_event *evt)
  3703. {
  3704. struct ibmvfc_host *vhost = evt->vhost;
  3705. u32 mad_status = evt->xfer_iu->npiv_logout.common.status;
  3706. ibmvfc_free_event(evt);
  3707. switch (mad_status) {
  3708. case IBMVFC_MAD_SUCCESS:
  3709. if (list_empty(&vhost->sent) &&
  3710. vhost->action == IBMVFC_HOST_ACTION_LOGO_WAIT) {
  3711. ibmvfc_init_host(vhost);
  3712. return;
  3713. }
  3714. break;
  3715. case IBMVFC_MAD_FAILED:
  3716. case IBMVFC_MAD_NOT_SUPPORTED:
  3717. case IBMVFC_MAD_CRQ_ERROR:
  3718. case IBMVFC_MAD_DRIVER_FAILED:
  3719. default:
  3720. ibmvfc_dbg(vhost, "NPIV Logout failed. 0x%X\n", mad_status);
  3721. break;
  3722. }
  3723. ibmvfc_hard_reset_host(vhost);
  3724. }
  3725. /**
  3726. * ibmvfc_npiv_logout - Issue an NPIV Logout
  3727. * @vhost: ibmvfc host struct
  3728. *
  3729. **/
  3730. static void ibmvfc_npiv_logout(struct ibmvfc_host *vhost)
  3731. {
  3732. struct ibmvfc_npiv_logout_mad *mad;
  3733. struct ibmvfc_event *evt;
  3734. evt = ibmvfc_get_event(vhost);
  3735. ibmvfc_init_event(evt, ibmvfc_npiv_logout_done, IBMVFC_MAD_FORMAT);
  3736. mad = &evt->iu.npiv_logout;
  3737. memset(mad, 0, sizeof(*mad));
  3738. mad->common.version = 1;
  3739. mad->common.opcode = IBMVFC_NPIV_LOGOUT;
  3740. mad->common.length = sizeof(struct ibmvfc_npiv_logout_mad);
  3741. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO_WAIT);
  3742. if (!ibmvfc_send_event(evt, vhost, default_timeout))
  3743. ibmvfc_dbg(vhost, "Sent NPIV logout\n");
  3744. else
  3745. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3746. }
  3747. /**
  3748. * ibmvfc_dev_init_to_do - Is there target initialization work to do?
  3749. * @vhost: ibmvfc host struct
  3750. *
  3751. * Returns:
  3752. * 1 if work to do / 0 if not
  3753. **/
  3754. static int ibmvfc_dev_init_to_do(struct ibmvfc_host *vhost)
  3755. {
  3756. struct ibmvfc_target *tgt;
  3757. list_for_each_entry(tgt, &vhost->targets, queue) {
  3758. if (tgt->action == IBMVFC_TGT_ACTION_INIT ||
  3759. tgt->action == IBMVFC_TGT_ACTION_INIT_WAIT)
  3760. return 1;
  3761. }
  3762. return 0;
  3763. }
  3764. /**
  3765. * __ibmvfc_work_to_do - Is there task level work to do? (no locking)
  3766. * @vhost: ibmvfc host struct
  3767. *
  3768. * Returns:
  3769. * 1 if work to do / 0 if not
  3770. **/
  3771. static int __ibmvfc_work_to_do(struct ibmvfc_host *vhost)
  3772. {
  3773. struct ibmvfc_target *tgt;
  3774. if (kthread_should_stop())
  3775. return 1;
  3776. switch (vhost->action) {
  3777. case IBMVFC_HOST_ACTION_NONE:
  3778. case IBMVFC_HOST_ACTION_INIT_WAIT:
  3779. case IBMVFC_HOST_ACTION_LOGO_WAIT:
  3780. return 0;
  3781. case IBMVFC_HOST_ACTION_TGT_INIT:
  3782. case IBMVFC_HOST_ACTION_QUERY_TGTS:
  3783. if (vhost->discovery_threads == disc_threads)
  3784. return 0;
  3785. list_for_each_entry(tgt, &vhost->targets, queue)
  3786. if (tgt->action == IBMVFC_TGT_ACTION_INIT)
  3787. return 1;
  3788. list_for_each_entry(tgt, &vhost->targets, queue)
  3789. if (tgt->action == IBMVFC_TGT_ACTION_INIT_WAIT)
  3790. return 0;
  3791. return 1;
  3792. case IBMVFC_HOST_ACTION_LOGO:
  3793. case IBMVFC_HOST_ACTION_INIT:
  3794. case IBMVFC_HOST_ACTION_ALLOC_TGTS:
  3795. case IBMVFC_HOST_ACTION_TGT_DEL:
  3796. case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
  3797. case IBMVFC_HOST_ACTION_QUERY:
  3798. case IBMVFC_HOST_ACTION_RESET:
  3799. case IBMVFC_HOST_ACTION_REENABLE:
  3800. default:
  3801. break;
  3802. };
  3803. return 1;
  3804. }
  3805. /**
  3806. * ibmvfc_work_to_do - Is there task level work to do?
  3807. * @vhost: ibmvfc host struct
  3808. *
  3809. * Returns:
  3810. * 1 if work to do / 0 if not
  3811. **/
  3812. static int ibmvfc_work_to_do(struct ibmvfc_host *vhost)
  3813. {
  3814. unsigned long flags;
  3815. int rc;
  3816. spin_lock_irqsave(vhost->host->host_lock, flags);
  3817. rc = __ibmvfc_work_to_do(vhost);
  3818. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3819. return rc;
  3820. }
  3821. /**
  3822. * ibmvfc_log_ae - Log async events if necessary
  3823. * @vhost: ibmvfc host struct
  3824. * @events: events to log
  3825. *
  3826. **/
  3827. static void ibmvfc_log_ae(struct ibmvfc_host *vhost, int events)
  3828. {
  3829. if (events & IBMVFC_AE_RSCN)
  3830. fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_RSCN, 0);
  3831. if ((events & IBMVFC_AE_LINKDOWN) &&
  3832. vhost->state >= IBMVFC_HALTED)
  3833. fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKDOWN, 0);
  3834. if ((events & IBMVFC_AE_LINKUP) &&
  3835. vhost->state == IBMVFC_INITIALIZING)
  3836. fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKUP, 0);
  3837. }
  3838. /**
  3839. * ibmvfc_tgt_add_rport - Tell the FC transport about a new remote port
  3840. * @tgt: ibmvfc target struct
  3841. *
  3842. **/
  3843. static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
  3844. {
  3845. struct ibmvfc_host *vhost = tgt->vhost;
  3846. struct fc_rport *rport;
  3847. unsigned long flags;
  3848. tgt_dbg(tgt, "Adding rport\n");
  3849. rport = fc_remote_port_add(vhost->host, 0, &tgt->ids);
  3850. spin_lock_irqsave(vhost->host->host_lock, flags);
  3851. if (rport && tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
  3852. tgt_dbg(tgt, "Deleting rport\n");
  3853. list_del(&tgt->queue);
  3854. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
  3855. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3856. fc_remote_port_delete(rport);
  3857. del_timer_sync(&tgt->timer);
  3858. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3859. return;
  3860. } else if (rport && tgt->action == IBMVFC_TGT_ACTION_DELETED_RPORT) {
  3861. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3862. return;
  3863. }
  3864. if (rport) {
  3865. tgt_dbg(tgt, "rport add succeeded\n");
  3866. tgt->rport = rport;
  3867. rport->maxframe_size = tgt->service_parms.common.bb_rcv_sz & 0x0fff;
  3868. rport->supported_classes = 0;
  3869. tgt->target_id = rport->scsi_target_id;
  3870. if (tgt->service_parms.class1_parms[0] & 0x80000000)
  3871. rport->supported_classes |= FC_COS_CLASS1;
  3872. if (tgt->service_parms.class2_parms[0] & 0x80000000)
  3873. rport->supported_classes |= FC_COS_CLASS2;
  3874. if (tgt->service_parms.class3_parms[0] & 0x80000000)
  3875. rport->supported_classes |= FC_COS_CLASS3;
  3876. if (rport->rqst_q)
  3877. blk_queue_max_segments(rport->rqst_q, 1);
  3878. } else
  3879. tgt_dbg(tgt, "rport add failed\n");
  3880. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3881. }
  3882. /**
  3883. * ibmvfc_do_work - Do task level work
  3884. * @vhost: ibmvfc host struct
  3885. *
  3886. **/
  3887. static void ibmvfc_do_work(struct ibmvfc_host *vhost)
  3888. {
  3889. struct ibmvfc_target *tgt;
  3890. unsigned long flags;
  3891. struct fc_rport *rport;
  3892. int rc;
  3893. ibmvfc_log_ae(vhost, vhost->events_to_log);
  3894. spin_lock_irqsave(vhost->host->host_lock, flags);
  3895. vhost->events_to_log = 0;
  3896. switch (vhost->action) {
  3897. case IBMVFC_HOST_ACTION_NONE:
  3898. case IBMVFC_HOST_ACTION_LOGO_WAIT:
  3899. case IBMVFC_HOST_ACTION_INIT_WAIT:
  3900. break;
  3901. case IBMVFC_HOST_ACTION_RESET:
  3902. vhost->action = IBMVFC_HOST_ACTION_TGT_DEL;
  3903. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3904. rc = ibmvfc_reset_crq(vhost);
  3905. spin_lock_irqsave(vhost->host->host_lock, flags);
  3906. if (rc == H_CLOSED)
  3907. vio_enable_interrupts(to_vio_dev(vhost->dev));
  3908. if (rc || (rc = ibmvfc_send_crq_init(vhost)) ||
  3909. (rc = vio_enable_interrupts(to_vio_dev(vhost->dev)))) {
  3910. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3911. dev_err(vhost->dev, "Error after reset (rc=%d)\n", rc);
  3912. }
  3913. break;
  3914. case IBMVFC_HOST_ACTION_REENABLE:
  3915. vhost->action = IBMVFC_HOST_ACTION_TGT_DEL;
  3916. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3917. rc = ibmvfc_reenable_crq_queue(vhost);
  3918. spin_lock_irqsave(vhost->host->host_lock, flags);
  3919. if (rc || (rc = ibmvfc_send_crq_init(vhost))) {
  3920. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3921. dev_err(vhost->dev, "Error after enable (rc=%d)\n", rc);
  3922. }
  3923. break;
  3924. case IBMVFC_HOST_ACTION_LOGO:
  3925. vhost->job_step(vhost);
  3926. break;
  3927. case IBMVFC_HOST_ACTION_INIT:
  3928. BUG_ON(vhost->state != IBMVFC_INITIALIZING);
  3929. if (vhost->delay_init) {
  3930. vhost->delay_init = 0;
  3931. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3932. ssleep(15);
  3933. return;
  3934. } else
  3935. vhost->job_step(vhost);
  3936. break;
  3937. case IBMVFC_HOST_ACTION_QUERY:
  3938. list_for_each_entry(tgt, &vhost->targets, queue)
  3939. ibmvfc_init_tgt(tgt, ibmvfc_tgt_query_target);
  3940. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY_TGTS);
  3941. break;
  3942. case IBMVFC_HOST_ACTION_QUERY_TGTS:
  3943. list_for_each_entry(tgt, &vhost->targets, queue) {
  3944. if (tgt->action == IBMVFC_TGT_ACTION_INIT) {
  3945. tgt->job_step(tgt);
  3946. break;
  3947. }
  3948. }
  3949. if (!ibmvfc_dev_init_to_do(vhost))
  3950. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
  3951. break;
  3952. case IBMVFC_HOST_ACTION_TGT_DEL:
  3953. case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
  3954. list_for_each_entry(tgt, &vhost->targets, queue) {
  3955. if (tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
  3956. tgt_dbg(tgt, "Deleting rport\n");
  3957. rport = tgt->rport;
  3958. tgt->rport = NULL;
  3959. list_del(&tgt->queue);
  3960. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
  3961. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3962. if (rport)
  3963. fc_remote_port_delete(rport);
  3964. del_timer_sync(&tgt->timer);
  3965. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3966. return;
  3967. }
  3968. }
  3969. if (vhost->state == IBMVFC_INITIALIZING) {
  3970. if (vhost->action == IBMVFC_HOST_ACTION_TGT_DEL_FAILED) {
  3971. if (vhost->reinit) {
  3972. vhost->reinit = 0;
  3973. scsi_block_requests(vhost->host);
  3974. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
  3975. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3976. } else {
  3977. ibmvfc_set_host_state(vhost, IBMVFC_ACTIVE);
  3978. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
  3979. wake_up(&vhost->init_wait_q);
  3980. schedule_work(&vhost->rport_add_work_q);
  3981. vhost->init_retries = 0;
  3982. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3983. scsi_unblock_requests(vhost->host);
  3984. }
  3985. return;
  3986. } else {
  3987. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
  3988. vhost->job_step = ibmvfc_discover_targets;
  3989. }
  3990. } else {
  3991. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
  3992. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3993. scsi_unblock_requests(vhost->host);
  3994. wake_up(&vhost->init_wait_q);
  3995. return;
  3996. }
  3997. break;
  3998. case IBMVFC_HOST_ACTION_ALLOC_TGTS:
  3999. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_INIT);
  4000. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4001. ibmvfc_alloc_targets(vhost);
  4002. spin_lock_irqsave(vhost->host->host_lock, flags);
  4003. break;
  4004. case IBMVFC_HOST_ACTION_TGT_INIT:
  4005. list_for_each_entry(tgt, &vhost->targets, queue) {
  4006. if (tgt->action == IBMVFC_TGT_ACTION_INIT) {
  4007. tgt->job_step(tgt);
  4008. break;
  4009. }
  4010. }
  4011. if (!ibmvfc_dev_init_to_do(vhost))
  4012. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL_FAILED);
  4013. break;
  4014. default:
  4015. break;
  4016. };
  4017. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4018. }
  4019. /**
  4020. * ibmvfc_work - Do task level work
  4021. * @data: ibmvfc host struct
  4022. *
  4023. * Returns:
  4024. * zero
  4025. **/
  4026. static int ibmvfc_work(void *data)
  4027. {
  4028. struct ibmvfc_host *vhost = data;
  4029. int rc;
  4030. set_user_nice(current, -20);
  4031. while (1) {
  4032. rc = wait_event_interruptible(vhost->work_wait_q,
  4033. ibmvfc_work_to_do(vhost));
  4034. BUG_ON(rc);
  4035. if (kthread_should_stop())
  4036. break;
  4037. ibmvfc_do_work(vhost);
  4038. }
  4039. ibmvfc_dbg(vhost, "ibmvfc kthread exiting...\n");
  4040. return 0;
  4041. }
  4042. /**
  4043. * ibmvfc_init_crq - Initializes and registers CRQ with hypervisor
  4044. * @vhost: ibmvfc host struct
  4045. *
  4046. * Allocates a page for messages, maps it for dma, and registers
  4047. * the crq with the hypervisor.
  4048. *
  4049. * Return value:
  4050. * zero on success / other on failure
  4051. **/
  4052. static int ibmvfc_init_crq(struct ibmvfc_host *vhost)
  4053. {
  4054. int rc, retrc = -ENOMEM;
  4055. struct device *dev = vhost->dev;
  4056. struct vio_dev *vdev = to_vio_dev(dev);
  4057. struct ibmvfc_crq_queue *crq = &vhost->crq;
  4058. ENTER;
  4059. crq->msgs = (struct ibmvfc_crq *)get_zeroed_page(GFP_KERNEL);
  4060. if (!crq->msgs)
  4061. return -ENOMEM;
  4062. crq->size = PAGE_SIZE / sizeof(*crq->msgs);
  4063. crq->msg_token = dma_map_single(dev, crq->msgs,
  4064. PAGE_SIZE, DMA_BIDIRECTIONAL);
  4065. if (dma_mapping_error(dev, crq->msg_token))
  4066. goto map_failed;
  4067. retrc = rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
  4068. crq->msg_token, PAGE_SIZE);
  4069. if (rc == H_RESOURCE)
  4070. /* maybe kexecing and resource is busy. try a reset */
  4071. retrc = rc = ibmvfc_reset_crq(vhost);
  4072. if (rc == H_CLOSED)
  4073. dev_warn(dev, "Partner adapter not ready\n");
  4074. else if (rc) {
  4075. dev_warn(dev, "Error %d opening adapter\n", rc);
  4076. goto reg_crq_failed;
  4077. }
  4078. retrc = 0;
  4079. tasklet_init(&vhost->tasklet, (void *)ibmvfc_tasklet, (unsigned long)vhost);
  4080. if ((rc = request_irq(vdev->irq, ibmvfc_interrupt, 0, IBMVFC_NAME, vhost))) {
  4081. dev_err(dev, "Couldn't register irq 0x%x. rc=%d\n", vdev->irq, rc);
  4082. goto req_irq_failed;
  4083. }
  4084. if ((rc = vio_enable_interrupts(vdev))) {
  4085. dev_err(dev, "Error %d enabling interrupts\n", rc);
  4086. goto req_irq_failed;
  4087. }
  4088. crq->cur = 0;
  4089. LEAVE;
  4090. return retrc;
  4091. req_irq_failed:
  4092. tasklet_kill(&vhost->tasklet);
  4093. do {
  4094. rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
  4095. } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
  4096. reg_crq_failed:
  4097. dma_unmap_single(dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
  4098. map_failed:
  4099. free_page((unsigned long)crq->msgs);
  4100. return retrc;
  4101. }
  4102. /**
  4103. * ibmvfc_free_mem - Free memory for vhost
  4104. * @vhost: ibmvfc host struct
  4105. *
  4106. * Return value:
  4107. * none
  4108. **/
  4109. static void ibmvfc_free_mem(struct ibmvfc_host *vhost)
  4110. {
  4111. struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
  4112. ENTER;
  4113. mempool_destroy(vhost->tgt_pool);
  4114. kfree(vhost->trace);
  4115. dma_free_coherent(vhost->dev, vhost->disc_buf_sz, vhost->disc_buf,
  4116. vhost->disc_buf_dma);
  4117. dma_free_coherent(vhost->dev, sizeof(*vhost->login_buf),
  4118. vhost->login_buf, vhost->login_buf_dma);
  4119. dma_pool_destroy(vhost->sg_pool);
  4120. dma_unmap_single(vhost->dev, async_q->msg_token,
  4121. async_q->size * sizeof(*async_q->msgs), DMA_BIDIRECTIONAL);
  4122. free_page((unsigned long)async_q->msgs);
  4123. LEAVE;
  4124. }
  4125. /**
  4126. * ibmvfc_alloc_mem - Allocate memory for vhost
  4127. * @vhost: ibmvfc host struct
  4128. *
  4129. * Return value:
  4130. * 0 on success / non-zero on failure
  4131. **/
  4132. static int ibmvfc_alloc_mem(struct ibmvfc_host *vhost)
  4133. {
  4134. struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
  4135. struct device *dev = vhost->dev;
  4136. ENTER;
  4137. async_q->msgs = (struct ibmvfc_async_crq *)get_zeroed_page(GFP_KERNEL);
  4138. if (!async_q->msgs) {
  4139. dev_err(dev, "Couldn't allocate async queue.\n");
  4140. goto nomem;
  4141. }
  4142. async_q->size = PAGE_SIZE / sizeof(struct ibmvfc_async_crq);
  4143. async_q->msg_token = dma_map_single(dev, async_q->msgs,
  4144. async_q->size * sizeof(*async_q->msgs),
  4145. DMA_BIDIRECTIONAL);
  4146. if (dma_mapping_error(dev, async_q->msg_token)) {
  4147. dev_err(dev, "Failed to map async queue\n");
  4148. goto free_async_crq;
  4149. }
  4150. vhost->sg_pool = dma_pool_create(IBMVFC_NAME, dev,
  4151. SG_ALL * sizeof(struct srp_direct_buf),
  4152. sizeof(struct srp_direct_buf), 0);
  4153. if (!vhost->sg_pool) {
  4154. dev_err(dev, "Failed to allocate sg pool\n");
  4155. goto unmap_async_crq;
  4156. }
  4157. vhost->login_buf = dma_alloc_coherent(dev, sizeof(*vhost->login_buf),
  4158. &vhost->login_buf_dma, GFP_KERNEL);
  4159. if (!vhost->login_buf) {
  4160. dev_err(dev, "Couldn't allocate NPIV login buffer\n");
  4161. goto free_sg_pool;
  4162. }
  4163. vhost->disc_buf_sz = sizeof(vhost->disc_buf->scsi_id[0]) * max_targets;
  4164. vhost->disc_buf = dma_alloc_coherent(dev, vhost->disc_buf_sz,
  4165. &vhost->disc_buf_dma, GFP_KERNEL);
  4166. if (!vhost->disc_buf) {
  4167. dev_err(dev, "Couldn't allocate Discover Targets buffer\n");
  4168. goto free_login_buffer;
  4169. }
  4170. vhost->trace = kcalloc(IBMVFC_NUM_TRACE_ENTRIES,
  4171. sizeof(struct ibmvfc_trace_entry), GFP_KERNEL);
  4172. if (!vhost->trace)
  4173. goto free_disc_buffer;
  4174. vhost->tgt_pool = mempool_create_kmalloc_pool(IBMVFC_TGT_MEMPOOL_SZ,
  4175. sizeof(struct ibmvfc_target));
  4176. if (!vhost->tgt_pool) {
  4177. dev_err(dev, "Couldn't allocate target memory pool\n");
  4178. goto free_trace;
  4179. }
  4180. LEAVE;
  4181. return 0;
  4182. free_trace:
  4183. kfree(vhost->trace);
  4184. free_disc_buffer:
  4185. dma_free_coherent(dev, vhost->disc_buf_sz, vhost->disc_buf,
  4186. vhost->disc_buf_dma);
  4187. free_login_buffer:
  4188. dma_free_coherent(dev, sizeof(*vhost->login_buf),
  4189. vhost->login_buf, vhost->login_buf_dma);
  4190. free_sg_pool:
  4191. dma_pool_destroy(vhost->sg_pool);
  4192. unmap_async_crq:
  4193. dma_unmap_single(dev, async_q->msg_token,
  4194. async_q->size * sizeof(*async_q->msgs), DMA_BIDIRECTIONAL);
  4195. free_async_crq:
  4196. free_page((unsigned long)async_q->msgs);
  4197. nomem:
  4198. LEAVE;
  4199. return -ENOMEM;
  4200. }
  4201. /**
  4202. * ibmvfc_rport_add_thread - Worker thread for rport adds
  4203. * @work: work struct
  4204. *
  4205. **/
  4206. static void ibmvfc_rport_add_thread(struct work_struct *work)
  4207. {
  4208. struct ibmvfc_host *vhost = container_of(work, struct ibmvfc_host,
  4209. rport_add_work_q);
  4210. struct ibmvfc_target *tgt;
  4211. struct fc_rport *rport;
  4212. unsigned long flags;
  4213. int did_work;
  4214. ENTER;
  4215. spin_lock_irqsave(vhost->host->host_lock, flags);
  4216. do {
  4217. did_work = 0;
  4218. if (vhost->state != IBMVFC_ACTIVE)
  4219. break;
  4220. list_for_each_entry(tgt, &vhost->targets, queue) {
  4221. if (tgt->add_rport) {
  4222. did_work = 1;
  4223. tgt->add_rport = 0;
  4224. kref_get(&tgt->kref);
  4225. rport = tgt->rport;
  4226. if (!rport) {
  4227. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4228. ibmvfc_tgt_add_rport(tgt);
  4229. } else if (get_device(&rport->dev)) {
  4230. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4231. tgt_dbg(tgt, "Setting rport roles\n");
  4232. fc_remote_port_rolechg(rport, tgt->ids.roles);
  4233. put_device(&rport->dev);
  4234. }
  4235. kref_put(&tgt->kref, ibmvfc_release_tgt);
  4236. spin_lock_irqsave(vhost->host->host_lock, flags);
  4237. break;
  4238. }
  4239. }
  4240. } while(did_work);
  4241. if (vhost->state == IBMVFC_ACTIVE)
  4242. vhost->scan_complete = 1;
  4243. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4244. LEAVE;
  4245. }
  4246. /**
  4247. * ibmvfc_probe - Adapter hot plug add entry point
  4248. * @vdev: vio device struct
  4249. * @id: vio device id struct
  4250. *
  4251. * Return value:
  4252. * 0 on success / non-zero on failure
  4253. **/
  4254. static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
  4255. {
  4256. struct ibmvfc_host *vhost;
  4257. struct Scsi_Host *shost;
  4258. struct device *dev = &vdev->dev;
  4259. int rc = -ENOMEM;
  4260. ENTER;
  4261. shost = scsi_host_alloc(&driver_template, sizeof(*vhost));
  4262. if (!shost) {
  4263. dev_err(dev, "Couldn't allocate host data\n");
  4264. goto out;
  4265. }
  4266. shost->transportt = ibmvfc_transport_template;
  4267. shost->can_queue = max_requests;
  4268. shost->max_lun = max_lun;
  4269. shost->max_id = max_targets;
  4270. shost->max_sectors = IBMVFC_MAX_SECTORS;
  4271. shost->max_cmd_len = IBMVFC_MAX_CDB_LEN;
  4272. shost->unique_id = shost->host_no;
  4273. vhost = shost_priv(shost);
  4274. INIT_LIST_HEAD(&vhost->sent);
  4275. INIT_LIST_HEAD(&vhost->free);
  4276. INIT_LIST_HEAD(&vhost->targets);
  4277. sprintf(vhost->name, IBMVFC_NAME);
  4278. vhost->host = shost;
  4279. vhost->dev = dev;
  4280. vhost->partition_number = -1;
  4281. vhost->log_level = log_level;
  4282. vhost->task_set = 1;
  4283. strcpy(vhost->partition_name, "UNKNOWN");
  4284. init_waitqueue_head(&vhost->work_wait_q);
  4285. init_waitqueue_head(&vhost->init_wait_q);
  4286. INIT_WORK(&vhost->rport_add_work_q, ibmvfc_rport_add_thread);
  4287. mutex_init(&vhost->passthru_mutex);
  4288. if ((rc = ibmvfc_alloc_mem(vhost)))
  4289. goto free_scsi_host;
  4290. vhost->work_thread = kthread_run(ibmvfc_work, vhost, "%s_%d", IBMVFC_NAME,
  4291. shost->host_no);
  4292. if (IS_ERR(vhost->work_thread)) {
  4293. dev_err(dev, "Couldn't create kernel thread: %ld\n",
  4294. PTR_ERR(vhost->work_thread));
  4295. goto free_host_mem;
  4296. }
  4297. if ((rc = ibmvfc_init_crq(vhost))) {
  4298. dev_err(dev, "Couldn't initialize crq. rc=%d\n", rc);
  4299. goto kill_kthread;
  4300. }
  4301. if ((rc = ibmvfc_init_event_pool(vhost))) {
  4302. dev_err(dev, "Couldn't initialize event pool. rc=%d\n", rc);
  4303. goto release_crq;
  4304. }
  4305. if ((rc = scsi_add_host(shost, dev)))
  4306. goto release_event_pool;
  4307. fc_host_dev_loss_tmo(shost) = IBMVFC_DEV_LOSS_TMO;
  4308. if ((rc = ibmvfc_create_trace_file(&shost->shost_dev.kobj,
  4309. &ibmvfc_trace_attr))) {
  4310. dev_err(dev, "Failed to create trace file. rc=%d\n", rc);
  4311. goto remove_shost;
  4312. }
  4313. if (shost_to_fc_host(shost)->rqst_q)
  4314. blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);
  4315. dev_set_drvdata(dev, vhost);
  4316. spin_lock(&ibmvfc_driver_lock);
  4317. list_add_tail(&vhost->queue, &ibmvfc_head);
  4318. spin_unlock(&ibmvfc_driver_lock);
  4319. ibmvfc_send_crq_init(vhost);
  4320. scsi_scan_host(shost);
  4321. return 0;
  4322. remove_shost:
  4323. scsi_remove_host(shost);
  4324. release_event_pool:
  4325. ibmvfc_free_event_pool(vhost);
  4326. release_crq:
  4327. ibmvfc_release_crq_queue(vhost);
  4328. kill_kthread:
  4329. kthread_stop(vhost->work_thread);
  4330. free_host_mem:
  4331. ibmvfc_free_mem(vhost);
  4332. free_scsi_host:
  4333. scsi_host_put(shost);
  4334. out:
  4335. LEAVE;
  4336. return rc;
  4337. }
  4338. /**
  4339. * ibmvfc_remove - Adapter hot plug remove entry point
  4340. * @vdev: vio device struct
  4341. *
  4342. * Return value:
  4343. * 0
  4344. **/
  4345. static int ibmvfc_remove(struct vio_dev *vdev)
  4346. {
  4347. struct ibmvfc_host *vhost = dev_get_drvdata(&vdev->dev);
  4348. unsigned long flags;
  4349. ENTER;
  4350. ibmvfc_remove_trace_file(&vhost->host->shost_dev.kobj, &ibmvfc_trace_attr);
  4351. spin_lock_irqsave(vhost->host->host_lock, flags);
  4352. ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
  4353. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4354. ibmvfc_wait_while_resetting(vhost);
  4355. ibmvfc_release_crq_queue(vhost);
  4356. kthread_stop(vhost->work_thread);
  4357. fc_remove_host(vhost->host);
  4358. scsi_remove_host(vhost->host);
  4359. spin_lock_irqsave(vhost->host->host_lock, flags);
  4360. ibmvfc_purge_requests(vhost, DID_ERROR);
  4361. ibmvfc_free_event_pool(vhost);
  4362. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4363. ibmvfc_free_mem(vhost);
  4364. spin_lock(&ibmvfc_driver_lock);
  4365. list_del(&vhost->queue);
  4366. spin_unlock(&ibmvfc_driver_lock);
  4367. scsi_host_put(vhost->host);
  4368. LEAVE;
  4369. return 0;
  4370. }
  4371. /**
  4372. * ibmvfc_resume - Resume from suspend
  4373. * @dev: device struct
  4374. *
  4375. * We may have lost an interrupt across suspend/resume, so kick the
  4376. * interrupt handler
  4377. *
  4378. */
  4379. static int ibmvfc_resume(struct device *dev)
  4380. {
  4381. unsigned long flags;
  4382. struct ibmvfc_host *vhost = dev_get_drvdata(dev);
  4383. struct vio_dev *vdev = to_vio_dev(dev);
  4384. spin_lock_irqsave(vhost->host->host_lock, flags);
  4385. vio_disable_interrupts(vdev);
  4386. tasklet_schedule(&vhost->tasklet);
  4387. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4388. return 0;
  4389. }
  4390. /**
  4391. * ibmvfc_get_desired_dma - Calculate DMA resources needed by the driver
  4392. * @vdev: vio device struct
  4393. *
  4394. * Return value:
  4395. * Number of bytes the driver will need to DMA map at the same time in
  4396. * order to perform well.
  4397. */
  4398. static unsigned long ibmvfc_get_desired_dma(struct vio_dev *vdev)
  4399. {
  4400. unsigned long pool_dma = max_requests * sizeof(union ibmvfc_iu);
  4401. return pool_dma + ((512 * 1024) * driver_template.cmd_per_lun);
  4402. }
  4403. static struct vio_device_id ibmvfc_device_table[] = {
  4404. {"fcp", "IBM,vfc-client"},
  4405. { "", "" }
  4406. };
  4407. MODULE_DEVICE_TABLE(vio, ibmvfc_device_table);
  4408. static struct dev_pm_ops ibmvfc_pm_ops = {
  4409. .resume = ibmvfc_resume
  4410. };
  4411. static struct vio_driver ibmvfc_driver = {
  4412. .id_table = ibmvfc_device_table,
  4413. .probe = ibmvfc_probe,
  4414. .remove = ibmvfc_remove,
  4415. .get_desired_dma = ibmvfc_get_desired_dma,
  4416. .name = IBMVFC_NAME,
  4417. .pm = &ibmvfc_pm_ops,
  4418. };
  4419. static struct fc_function_template ibmvfc_transport_functions = {
  4420. .show_host_fabric_name = 1,
  4421. .show_host_node_name = 1,
  4422. .show_host_port_name = 1,
  4423. .show_host_supported_classes = 1,
  4424. .show_host_port_type = 1,
  4425. .show_host_port_id = 1,
  4426. .show_host_maxframe_size = 1,
  4427. .get_host_port_state = ibmvfc_get_host_port_state,
  4428. .show_host_port_state = 1,
  4429. .get_host_speed = ibmvfc_get_host_speed,
  4430. .show_host_speed = 1,
  4431. .issue_fc_host_lip = ibmvfc_issue_fc_host_lip,
  4432. .terminate_rport_io = ibmvfc_terminate_rport_io,
  4433. .show_rport_maxframe_size = 1,
  4434. .show_rport_supported_classes = 1,
  4435. .set_rport_dev_loss_tmo = ibmvfc_set_rport_dev_loss_tmo,
  4436. .show_rport_dev_loss_tmo = 1,
  4437. .get_starget_node_name = ibmvfc_get_starget_node_name,
  4438. .show_starget_node_name = 1,
  4439. .get_starget_port_name = ibmvfc_get_starget_port_name,
  4440. .show_starget_port_name = 1,
  4441. .get_starget_port_id = ibmvfc_get_starget_port_id,
  4442. .show_starget_port_id = 1,
  4443. .bsg_request = ibmvfc_bsg_request,
  4444. .bsg_timeout = ibmvfc_bsg_timeout,
  4445. };
  4446. /**
  4447. * ibmvfc_module_init - Initialize the ibmvfc module
  4448. *
  4449. * Return value:
  4450. * 0 on success / other on failure
  4451. **/
  4452. static int __init ibmvfc_module_init(void)
  4453. {
  4454. int rc;
  4455. if (!firmware_has_feature(FW_FEATURE_VIO))
  4456. return -ENODEV;
  4457. printk(KERN_INFO IBMVFC_NAME": IBM Virtual Fibre Channel Driver version: %s %s\n",
  4458. IBMVFC_DRIVER_VERSION, IBMVFC_DRIVER_DATE);
  4459. ibmvfc_transport_template = fc_attach_transport(&ibmvfc_transport_functions);
  4460. if (!ibmvfc_transport_template)
  4461. return -ENOMEM;
  4462. rc = vio_register_driver(&ibmvfc_driver);
  4463. if (rc)
  4464. fc_release_transport(ibmvfc_transport_template);
  4465. return rc;
  4466. }
  4467. /**
  4468. * ibmvfc_module_exit - Teardown the ibmvfc module
  4469. *
  4470. * Return value:
  4471. * nothing
  4472. **/
  4473. static void __exit ibmvfc_module_exit(void)
  4474. {
  4475. vio_unregister_driver(&ibmvfc_driver);
  4476. fc_release_transport(ibmvfc_transport_template);
  4477. }
  4478. module_init(ibmvfc_module_init);
  4479. module_exit(ibmvfc_module_exit);