ibmvfc.c 124 KB

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