ixgbe_main.c 140 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872
  1. /*******************************************************************************
  2. Intel 10 Gigabit PCI Express Linux driver
  3. Copyright(c) 1999 - 2009 Intel Corporation.
  4. This program is free software; you can redistribute it and/or modify it
  5. under the terms and conditions of the GNU General Public License,
  6. version 2, as published by the Free Software Foundation.
  7. This program is distributed in the hope it will be useful, but WITHOUT
  8. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  9. FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  10. more details.
  11. You should have received a copy of the GNU General Public License along with
  12. this program; if not, write to the Free Software Foundation, Inc.,
  13. 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  14. The full GNU General Public License is included in this distribution in
  15. the file called "COPYING".
  16. Contact Information:
  17. e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  18. Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  19. *******************************************************************************/
  20. #include <linux/types.h>
  21. #include <linux/module.h>
  22. #include <linux/pci.h>
  23. #include <linux/netdevice.h>
  24. #include <linux/vmalloc.h>
  25. #include <linux/string.h>
  26. #include <linux/in.h>
  27. #include <linux/ip.h>
  28. #include <linux/tcp.h>
  29. #include <linux/ipv6.h>
  30. #include <net/checksum.h>
  31. #include <net/ip6_checksum.h>
  32. #include <linux/ethtool.h>
  33. #include <linux/if_vlan.h>
  34. #include "ixgbe.h"
  35. #include "ixgbe_common.h"
  36. char ixgbe_driver_name[] = "ixgbe";
  37. static const char ixgbe_driver_string[] =
  38. "Intel(R) 10 Gigabit PCI Express Network Driver";
  39. #define DRV_VERSION "2.0.8-k2"
  40. const char ixgbe_driver_version[] = DRV_VERSION;
  41. static char ixgbe_copyright[] = "Copyright (c) 1999-2009 Intel Corporation.";
  42. static const struct ixgbe_info *ixgbe_info_tbl[] = {
  43. [board_82598] = &ixgbe_82598_info,
  44. [board_82599] = &ixgbe_82599_info,
  45. };
  46. /* ixgbe_pci_tbl - PCI Device ID Table
  47. *
  48. * Wildcard entries (PCI_ANY_ID) should come last
  49. * Last entry must be all 0s
  50. *
  51. * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  52. * Class, Class Mask, private data (not used) }
  53. */
  54. static struct pci_device_id ixgbe_pci_tbl[] = {
  55. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598),
  56. board_82598 },
  57. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AF_DUAL_PORT),
  58. board_82598 },
  59. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AF_SINGLE_PORT),
  60. board_82598 },
  61. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AT),
  62. board_82598 },
  63. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_CX4),
  64. board_82598 },
  65. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_CX4_DUAL_PORT),
  66. board_82598 },
  67. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_DA_DUAL_PORT),
  68. board_82598 },
  69. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM),
  70. board_82598 },
  71. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_XF_LR),
  72. board_82598 },
  73. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_SFP_LOM),
  74. board_82598 },
  75. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_BX),
  76. board_82598 },
  77. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_KX4),
  78. board_82599 },
  79. {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP),
  80. board_82599 },
  81. /* required last entry */
  82. {0, }
  83. };
  84. MODULE_DEVICE_TABLE(pci, ixgbe_pci_tbl);
  85. #ifdef CONFIG_IXGBE_DCA
  86. static int ixgbe_notify_dca(struct notifier_block *, unsigned long event,
  87. void *p);
  88. static struct notifier_block dca_notifier = {
  89. .notifier_call = ixgbe_notify_dca,
  90. .next = NULL,
  91. .priority = 0
  92. };
  93. #endif
  94. MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
  95. MODULE_DESCRIPTION("Intel(R) 10 Gigabit PCI Express Network Driver");
  96. MODULE_LICENSE("GPL");
  97. MODULE_VERSION(DRV_VERSION);
  98. #define DEFAULT_DEBUG_LEVEL_SHIFT 3
  99. static void ixgbe_release_hw_control(struct ixgbe_adapter *adapter)
  100. {
  101. u32 ctrl_ext;
  102. /* Let firmware take over control of h/w */
  103. ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT);
  104. IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT,
  105. ctrl_ext & ~IXGBE_CTRL_EXT_DRV_LOAD);
  106. }
  107. static void ixgbe_get_hw_control(struct ixgbe_adapter *adapter)
  108. {
  109. u32 ctrl_ext;
  110. /* Let firmware know the driver has taken over */
  111. ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT);
  112. IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT,
  113. ctrl_ext | IXGBE_CTRL_EXT_DRV_LOAD);
  114. }
  115. /*
  116. * ixgbe_set_ivar - set the IVAR registers, mapping interrupt causes to vectors
  117. * @adapter: pointer to adapter struct
  118. * @direction: 0 for Rx, 1 for Tx, -1 for other causes
  119. * @queue: queue to map the corresponding interrupt to
  120. * @msix_vector: the vector to map to the corresponding queue
  121. *
  122. */
  123. static void ixgbe_set_ivar(struct ixgbe_adapter *adapter, s8 direction,
  124. u8 queue, u8 msix_vector)
  125. {
  126. u32 ivar, index;
  127. struct ixgbe_hw *hw = &adapter->hw;
  128. switch (hw->mac.type) {
  129. case ixgbe_mac_82598EB:
  130. msix_vector |= IXGBE_IVAR_ALLOC_VAL;
  131. if (direction == -1)
  132. direction = 0;
  133. index = (((direction * 64) + queue) >> 2) & 0x1F;
  134. ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index));
  135. ivar &= ~(0xFF << (8 * (queue & 0x3)));
  136. ivar |= (msix_vector << (8 * (queue & 0x3)));
  137. IXGBE_WRITE_REG(hw, IXGBE_IVAR(index), ivar);
  138. break;
  139. case ixgbe_mac_82599EB:
  140. if (direction == -1) {
  141. /* other causes */
  142. msix_vector |= IXGBE_IVAR_ALLOC_VAL;
  143. index = ((queue & 1) * 8);
  144. ivar = IXGBE_READ_REG(&adapter->hw, IXGBE_IVAR_MISC);
  145. ivar &= ~(0xFF << index);
  146. ivar |= (msix_vector << index);
  147. IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR_MISC, ivar);
  148. break;
  149. } else {
  150. /* tx or rx causes */
  151. msix_vector |= IXGBE_IVAR_ALLOC_VAL;
  152. index = ((16 * (queue & 1)) + (8 * direction));
  153. ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(queue >> 1));
  154. ivar &= ~(0xFF << index);
  155. ivar |= (msix_vector << index);
  156. IXGBE_WRITE_REG(hw, IXGBE_IVAR(queue >> 1), ivar);
  157. break;
  158. }
  159. default:
  160. break;
  161. }
  162. }
  163. static void ixgbe_unmap_and_free_tx_resource(struct ixgbe_adapter *adapter,
  164. struct ixgbe_tx_buffer
  165. *tx_buffer_info)
  166. {
  167. if (tx_buffer_info->dma) {
  168. pci_unmap_page(adapter->pdev, tx_buffer_info->dma,
  169. tx_buffer_info->length, PCI_DMA_TODEVICE);
  170. tx_buffer_info->dma = 0;
  171. }
  172. if (tx_buffer_info->skb) {
  173. dev_kfree_skb_any(tx_buffer_info->skb);
  174. tx_buffer_info->skb = NULL;
  175. }
  176. /* tx_buffer_info must be completely set up in the transmit path */
  177. }
  178. static inline bool ixgbe_check_tx_hang(struct ixgbe_adapter *adapter,
  179. struct ixgbe_ring *tx_ring,
  180. unsigned int eop)
  181. {
  182. struct ixgbe_hw *hw = &adapter->hw;
  183. u32 head, tail;
  184. /* Detect a transmit hang in hardware, this serializes the
  185. * check with the clearing of time_stamp and movement of eop */
  186. head = IXGBE_READ_REG(hw, tx_ring->head);
  187. tail = IXGBE_READ_REG(hw, tx_ring->tail);
  188. adapter->detect_tx_hung = false;
  189. if ((head != tail) &&
  190. tx_ring->tx_buffer_info[eop].time_stamp &&
  191. time_after(jiffies, tx_ring->tx_buffer_info[eop].time_stamp + HZ) &&
  192. !(IXGBE_READ_REG(&adapter->hw, IXGBE_TFCS) & IXGBE_TFCS_TXOFF)) {
  193. /* detected Tx unit hang */
  194. union ixgbe_adv_tx_desc *tx_desc;
  195. tx_desc = IXGBE_TX_DESC_ADV(*tx_ring, eop);
  196. DPRINTK(DRV, ERR, "Detected Tx Unit Hang\n"
  197. " Tx Queue <%d>\n"
  198. " TDH, TDT <%x>, <%x>\n"
  199. " next_to_use <%x>\n"
  200. " next_to_clean <%x>\n"
  201. "tx_buffer_info[next_to_clean]\n"
  202. " time_stamp <%lx>\n"
  203. " jiffies <%lx>\n",
  204. tx_ring->queue_index,
  205. head, tail,
  206. tx_ring->next_to_use, eop,
  207. tx_ring->tx_buffer_info[eop].time_stamp, jiffies);
  208. return true;
  209. }
  210. return false;
  211. }
  212. #define IXGBE_MAX_TXD_PWR 14
  213. #define IXGBE_MAX_DATA_PER_TXD (1 << IXGBE_MAX_TXD_PWR)
  214. /* Tx Descriptors needed, worst case */
  215. #define TXD_USE_COUNT(S) (((S) >> IXGBE_MAX_TXD_PWR) + \
  216. (((S) & (IXGBE_MAX_DATA_PER_TXD - 1)) ? 1 : 0))
  217. #define DESC_NEEDED (TXD_USE_COUNT(IXGBE_MAX_DATA_PER_TXD) /* skb->data */ + \
  218. MAX_SKB_FRAGS * TXD_USE_COUNT(PAGE_SIZE) + 1) /* for context */
  219. static void ixgbe_tx_timeout(struct net_device *netdev);
  220. /**
  221. * ixgbe_clean_tx_irq - Reclaim resources after transmit completes
  222. * @adapter: board private structure
  223. * @tx_ring: tx ring to clean
  224. **/
  225. static bool ixgbe_clean_tx_irq(struct ixgbe_adapter *adapter,
  226. struct ixgbe_ring *tx_ring)
  227. {
  228. struct net_device *netdev = adapter->netdev;
  229. union ixgbe_adv_tx_desc *tx_desc, *eop_desc;
  230. struct ixgbe_tx_buffer *tx_buffer_info;
  231. unsigned int i, eop, count = 0;
  232. unsigned int total_bytes = 0, total_packets = 0;
  233. i = tx_ring->next_to_clean;
  234. eop = tx_ring->tx_buffer_info[i].next_to_watch;
  235. eop_desc = IXGBE_TX_DESC_ADV(*tx_ring, eop);
  236. while ((eop_desc->wb.status & cpu_to_le32(IXGBE_TXD_STAT_DD)) &&
  237. (count < tx_ring->count)) {
  238. bool cleaned = false;
  239. for ( ; !cleaned; count++) {
  240. struct sk_buff *skb;
  241. tx_desc = IXGBE_TX_DESC_ADV(*tx_ring, i);
  242. tx_buffer_info = &tx_ring->tx_buffer_info[i];
  243. cleaned = (i == eop);
  244. skb = tx_buffer_info->skb;
  245. if (cleaned && skb) {
  246. unsigned int segs, bytecount;
  247. /* gso_segs is currently only valid for tcp */
  248. segs = skb_shinfo(skb)->gso_segs ?: 1;
  249. /* multiply data chunks by size of headers */
  250. bytecount = ((segs - 1) * skb_headlen(skb)) +
  251. skb->len;
  252. total_packets += segs;
  253. total_bytes += bytecount;
  254. }
  255. ixgbe_unmap_and_free_tx_resource(adapter,
  256. tx_buffer_info);
  257. tx_desc->wb.status = 0;
  258. i++;
  259. if (i == tx_ring->count)
  260. i = 0;
  261. }
  262. eop = tx_ring->tx_buffer_info[i].next_to_watch;
  263. eop_desc = IXGBE_TX_DESC_ADV(*tx_ring, eop);
  264. }
  265. tx_ring->next_to_clean = i;
  266. #define TX_WAKE_THRESHOLD (DESC_NEEDED * 2)
  267. if (unlikely(count && netif_carrier_ok(netdev) &&
  268. (IXGBE_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD))) {
  269. /* Make sure that anybody stopping the queue after this
  270. * sees the new next_to_clean.
  271. */
  272. smp_mb();
  273. if (__netif_subqueue_stopped(netdev, tx_ring->queue_index) &&
  274. !test_bit(__IXGBE_DOWN, &adapter->state)) {
  275. netif_wake_subqueue(netdev, tx_ring->queue_index);
  276. ++adapter->restart_queue;
  277. }
  278. }
  279. if (adapter->detect_tx_hung) {
  280. if (ixgbe_check_tx_hang(adapter, tx_ring, i)) {
  281. /* schedule immediate reset if we believe we hung */
  282. DPRINTK(PROBE, INFO,
  283. "tx hang %d detected, resetting adapter\n",
  284. adapter->tx_timeout_count + 1);
  285. ixgbe_tx_timeout(adapter->netdev);
  286. }
  287. }
  288. /* re-arm the interrupt */
  289. if ((total_packets >= tx_ring->work_limit) ||
  290. (count == tx_ring->count))
  291. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, tx_ring->v_idx);
  292. tx_ring->total_bytes += total_bytes;
  293. tx_ring->total_packets += total_packets;
  294. tx_ring->stats.packets += total_packets;
  295. tx_ring->stats.bytes += total_bytes;
  296. adapter->net_stats.tx_bytes += total_bytes;
  297. adapter->net_stats.tx_packets += total_packets;
  298. return (total_packets ? true : false);
  299. }
  300. #ifdef CONFIG_IXGBE_DCA
  301. static void ixgbe_update_rx_dca(struct ixgbe_adapter *adapter,
  302. struct ixgbe_ring *rx_ring)
  303. {
  304. u32 rxctrl;
  305. int cpu = get_cpu();
  306. int q = rx_ring - adapter->rx_ring;
  307. if (rx_ring->cpu != cpu) {
  308. rxctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_DCA_RXCTRL(q));
  309. if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
  310. rxctrl &= ~IXGBE_DCA_RXCTRL_CPUID_MASK;
  311. rxctrl |= dca3_get_tag(&adapter->pdev->dev, cpu);
  312. } else if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
  313. rxctrl &= ~IXGBE_DCA_RXCTRL_CPUID_MASK_82599;
  314. rxctrl |= (dca3_get_tag(&adapter->pdev->dev, cpu) <<
  315. IXGBE_DCA_RXCTRL_CPUID_SHIFT_82599);
  316. }
  317. rxctrl |= IXGBE_DCA_RXCTRL_DESC_DCA_EN;
  318. rxctrl |= IXGBE_DCA_RXCTRL_HEAD_DCA_EN;
  319. rxctrl &= ~(IXGBE_DCA_RXCTRL_DESC_RRO_EN);
  320. rxctrl &= ~(IXGBE_DCA_RXCTRL_DESC_WRO_EN |
  321. IXGBE_DCA_RXCTRL_DESC_HSRO_EN);
  322. IXGBE_WRITE_REG(&adapter->hw, IXGBE_DCA_RXCTRL(q), rxctrl);
  323. rx_ring->cpu = cpu;
  324. }
  325. put_cpu();
  326. }
  327. static void ixgbe_update_tx_dca(struct ixgbe_adapter *adapter,
  328. struct ixgbe_ring *tx_ring)
  329. {
  330. u32 txctrl;
  331. int cpu = get_cpu();
  332. int q = tx_ring - adapter->tx_ring;
  333. if (tx_ring->cpu != cpu) {
  334. txctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_DCA_TXCTRL(q));
  335. if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
  336. txctrl &= ~IXGBE_DCA_TXCTRL_CPUID_MASK;
  337. txctrl |= dca3_get_tag(&adapter->pdev->dev, cpu);
  338. } else if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
  339. txctrl &= ~IXGBE_DCA_TXCTRL_CPUID_MASK_82599;
  340. txctrl |= (dca3_get_tag(&adapter->pdev->dev, cpu) <<
  341. IXGBE_DCA_TXCTRL_CPUID_SHIFT_82599);
  342. }
  343. txctrl |= IXGBE_DCA_TXCTRL_DESC_DCA_EN;
  344. IXGBE_WRITE_REG(&adapter->hw, IXGBE_DCA_TXCTRL(q), txctrl);
  345. tx_ring->cpu = cpu;
  346. }
  347. put_cpu();
  348. }
  349. static void ixgbe_setup_dca(struct ixgbe_adapter *adapter)
  350. {
  351. int i;
  352. if (!(adapter->flags & IXGBE_FLAG_DCA_ENABLED))
  353. return;
  354. for (i = 0; i < adapter->num_tx_queues; i++) {
  355. adapter->tx_ring[i].cpu = -1;
  356. ixgbe_update_tx_dca(adapter, &adapter->tx_ring[i]);
  357. }
  358. for (i = 0; i < adapter->num_rx_queues; i++) {
  359. adapter->rx_ring[i].cpu = -1;
  360. ixgbe_update_rx_dca(adapter, &adapter->rx_ring[i]);
  361. }
  362. }
  363. static int __ixgbe_notify_dca(struct device *dev, void *data)
  364. {
  365. struct net_device *netdev = dev_get_drvdata(dev);
  366. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  367. unsigned long event = *(unsigned long *)data;
  368. switch (event) {
  369. case DCA_PROVIDER_ADD:
  370. /* if we're already enabled, don't do it again */
  371. if (adapter->flags & IXGBE_FLAG_DCA_ENABLED)
  372. break;
  373. /* Always use CB2 mode, difference is masked
  374. * in the CB driver. */
  375. IXGBE_WRITE_REG(&adapter->hw, IXGBE_DCA_CTRL, 2);
  376. if (dca_add_requester(dev) == 0) {
  377. adapter->flags |= IXGBE_FLAG_DCA_ENABLED;
  378. ixgbe_setup_dca(adapter);
  379. break;
  380. }
  381. /* Fall Through since DCA is disabled. */
  382. case DCA_PROVIDER_REMOVE:
  383. if (adapter->flags & IXGBE_FLAG_DCA_ENABLED) {
  384. dca_remove_requester(dev);
  385. adapter->flags &= ~IXGBE_FLAG_DCA_ENABLED;
  386. IXGBE_WRITE_REG(&adapter->hw, IXGBE_DCA_CTRL, 1);
  387. }
  388. break;
  389. }
  390. return 0;
  391. }
  392. #endif /* CONFIG_IXGBE_DCA */
  393. /**
  394. * ixgbe_receive_skb - Send a completed packet up the stack
  395. * @adapter: board private structure
  396. * @skb: packet to send up
  397. * @status: hardware indication of status of receive
  398. * @rx_ring: rx descriptor ring (for a specific queue) to setup
  399. * @rx_desc: rx descriptor
  400. **/
  401. static void ixgbe_receive_skb(struct ixgbe_q_vector *q_vector,
  402. struct sk_buff *skb, u8 status,
  403. union ixgbe_adv_rx_desc *rx_desc)
  404. {
  405. struct ixgbe_adapter *adapter = q_vector->adapter;
  406. struct napi_struct *napi = &q_vector->napi;
  407. bool is_vlan = (status & IXGBE_RXD_STAT_VP);
  408. u16 tag = le16_to_cpu(rx_desc->wb.upper.vlan);
  409. skb_record_rx_queue(skb, q_vector - &adapter->q_vector[0]);
  410. if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
  411. if (adapter->vlgrp && is_vlan && (tag != 0))
  412. vlan_gro_receive(napi, adapter->vlgrp, tag, skb);
  413. else
  414. napi_gro_receive(napi, skb);
  415. } else {
  416. if (!(adapter->flags & IXGBE_FLAG_IN_NETPOLL)) {
  417. if (adapter->vlgrp && is_vlan && (tag != 0))
  418. vlan_hwaccel_receive_skb(skb, adapter->vlgrp, tag);
  419. else
  420. netif_receive_skb(skb);
  421. } else {
  422. if (adapter->vlgrp && is_vlan && (tag != 0))
  423. vlan_hwaccel_rx(skb, adapter->vlgrp, tag);
  424. else
  425. netif_rx(skb);
  426. }
  427. }
  428. }
  429. /**
  430. * ixgbe_rx_checksum - indicate in skb if hw indicated a good cksum
  431. * @adapter: address of board private structure
  432. * @status_err: hardware indication of status of receive
  433. * @skb: skb currently being received and modified
  434. **/
  435. static inline void ixgbe_rx_checksum(struct ixgbe_adapter *adapter,
  436. u32 status_err, struct sk_buff *skb)
  437. {
  438. skb->ip_summed = CHECKSUM_NONE;
  439. /* Rx csum disabled */
  440. if (!(adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED))
  441. return;
  442. /* if IP and error */
  443. if ((status_err & IXGBE_RXD_STAT_IPCS) &&
  444. (status_err & IXGBE_RXDADV_ERR_IPE)) {
  445. adapter->hw_csum_rx_error++;
  446. return;
  447. }
  448. if (!(status_err & IXGBE_RXD_STAT_L4CS))
  449. return;
  450. if (status_err & IXGBE_RXDADV_ERR_TCPE) {
  451. adapter->hw_csum_rx_error++;
  452. return;
  453. }
  454. /* It must be a TCP or UDP packet with a valid checksum */
  455. skb->ip_summed = CHECKSUM_UNNECESSARY;
  456. adapter->hw_csum_rx_good++;
  457. }
  458. static inline void ixgbe_release_rx_desc(struct ixgbe_hw *hw,
  459. struct ixgbe_ring *rx_ring, u32 val)
  460. {
  461. /*
  462. * Force memory writes to complete before letting h/w
  463. * know there are new descriptors to fetch. (Only
  464. * applicable for weak-ordered memory model archs,
  465. * such as IA-64).
  466. */
  467. wmb();
  468. IXGBE_WRITE_REG(hw, IXGBE_RDT(rx_ring->reg_idx), val);
  469. }
  470. /**
  471. * ixgbe_alloc_rx_buffers - Replace used receive buffers; packet split
  472. * @adapter: address of board private structure
  473. **/
  474. static void ixgbe_alloc_rx_buffers(struct ixgbe_adapter *adapter,
  475. struct ixgbe_ring *rx_ring,
  476. int cleaned_count)
  477. {
  478. struct pci_dev *pdev = adapter->pdev;
  479. union ixgbe_adv_rx_desc *rx_desc;
  480. struct ixgbe_rx_buffer *bi;
  481. unsigned int i;
  482. unsigned int bufsz = rx_ring->rx_buf_len + NET_IP_ALIGN;
  483. i = rx_ring->next_to_use;
  484. bi = &rx_ring->rx_buffer_info[i];
  485. while (cleaned_count--) {
  486. rx_desc = IXGBE_RX_DESC_ADV(*rx_ring, i);
  487. if (!bi->page_dma &&
  488. (adapter->flags & IXGBE_FLAG_RX_PS_ENABLED)) {
  489. if (!bi->page) {
  490. bi->page = alloc_page(GFP_ATOMIC);
  491. if (!bi->page) {
  492. adapter->alloc_rx_page_failed++;
  493. goto no_buffers;
  494. }
  495. bi->page_offset = 0;
  496. } else {
  497. /* use a half page if we're re-using */
  498. bi->page_offset ^= (PAGE_SIZE / 2);
  499. }
  500. bi->page_dma = pci_map_page(pdev, bi->page,
  501. bi->page_offset,
  502. (PAGE_SIZE / 2),
  503. PCI_DMA_FROMDEVICE);
  504. }
  505. if (!bi->skb) {
  506. struct sk_buff *skb;
  507. skb = netdev_alloc_skb(adapter->netdev, bufsz);
  508. if (!skb) {
  509. adapter->alloc_rx_buff_failed++;
  510. goto no_buffers;
  511. }
  512. /*
  513. * Make buffer alignment 2 beyond a 16 byte boundary
  514. * this will result in a 16 byte aligned IP header after
  515. * the 14 byte MAC header is removed
  516. */
  517. skb_reserve(skb, NET_IP_ALIGN);
  518. bi->skb = skb;
  519. bi->dma = pci_map_single(pdev, skb->data, bufsz,
  520. PCI_DMA_FROMDEVICE);
  521. }
  522. /* Refresh the desc even if buffer_addrs didn't change because
  523. * each write-back erases this info. */
  524. if (adapter->flags & IXGBE_FLAG_RX_PS_ENABLED) {
  525. rx_desc->read.pkt_addr = cpu_to_le64(bi->page_dma);
  526. rx_desc->read.hdr_addr = cpu_to_le64(bi->dma);
  527. } else {
  528. rx_desc->read.pkt_addr = cpu_to_le64(bi->dma);
  529. }
  530. i++;
  531. if (i == rx_ring->count)
  532. i = 0;
  533. bi = &rx_ring->rx_buffer_info[i];
  534. }
  535. no_buffers:
  536. if (rx_ring->next_to_use != i) {
  537. rx_ring->next_to_use = i;
  538. if (i-- == 0)
  539. i = (rx_ring->count - 1);
  540. ixgbe_release_rx_desc(&adapter->hw, rx_ring, i);
  541. }
  542. }
  543. static inline u16 ixgbe_get_hdr_info(union ixgbe_adv_rx_desc *rx_desc)
  544. {
  545. return rx_desc->wb.lower.lo_dword.hs_rss.hdr_info;
  546. }
  547. static inline u16 ixgbe_get_pkt_info(union ixgbe_adv_rx_desc *rx_desc)
  548. {
  549. return rx_desc->wb.lower.lo_dword.hs_rss.pkt_info;
  550. }
  551. static bool ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
  552. struct ixgbe_ring *rx_ring,
  553. int *work_done, int work_to_do)
  554. {
  555. struct ixgbe_adapter *adapter = q_vector->adapter;
  556. struct pci_dev *pdev = adapter->pdev;
  557. union ixgbe_adv_rx_desc *rx_desc, *next_rxd;
  558. struct ixgbe_rx_buffer *rx_buffer_info, *next_buffer;
  559. struct sk_buff *skb;
  560. unsigned int i;
  561. u32 len, staterr;
  562. u16 hdr_info;
  563. bool cleaned = false;
  564. int cleaned_count = 0;
  565. unsigned int total_rx_bytes = 0, total_rx_packets = 0;
  566. i = rx_ring->next_to_clean;
  567. rx_desc = IXGBE_RX_DESC_ADV(*rx_ring, i);
  568. staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
  569. rx_buffer_info = &rx_ring->rx_buffer_info[i];
  570. while (staterr & IXGBE_RXD_STAT_DD) {
  571. u32 upper_len = 0;
  572. if (*work_done >= work_to_do)
  573. break;
  574. (*work_done)++;
  575. if (adapter->flags & IXGBE_FLAG_RX_PS_ENABLED) {
  576. hdr_info = le16_to_cpu(ixgbe_get_hdr_info(rx_desc));
  577. len = (hdr_info & IXGBE_RXDADV_HDRBUFLEN_MASK) >>
  578. IXGBE_RXDADV_HDRBUFLEN_SHIFT;
  579. if (hdr_info & IXGBE_RXDADV_SPH)
  580. adapter->rx_hdr_split++;
  581. if (len > IXGBE_RX_HDR_SIZE)
  582. len = IXGBE_RX_HDR_SIZE;
  583. upper_len = le16_to_cpu(rx_desc->wb.upper.length);
  584. } else {
  585. len = le16_to_cpu(rx_desc->wb.upper.length);
  586. }
  587. cleaned = true;
  588. skb = rx_buffer_info->skb;
  589. prefetch(skb->data - NET_IP_ALIGN);
  590. rx_buffer_info->skb = NULL;
  591. if (len && !skb_shinfo(skb)->nr_frags) {
  592. pci_unmap_single(pdev, rx_buffer_info->dma,
  593. rx_ring->rx_buf_len,
  594. PCI_DMA_FROMDEVICE);
  595. skb_put(skb, len);
  596. }
  597. if (upper_len) {
  598. pci_unmap_page(pdev, rx_buffer_info->page_dma,
  599. PAGE_SIZE / 2, PCI_DMA_FROMDEVICE);
  600. rx_buffer_info->page_dma = 0;
  601. skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags,
  602. rx_buffer_info->page,
  603. rx_buffer_info->page_offset,
  604. upper_len);
  605. if ((rx_ring->rx_buf_len > (PAGE_SIZE / 2)) ||
  606. (page_count(rx_buffer_info->page) != 1))
  607. rx_buffer_info->page = NULL;
  608. else
  609. get_page(rx_buffer_info->page);
  610. skb->len += upper_len;
  611. skb->data_len += upper_len;
  612. skb->truesize += upper_len;
  613. }
  614. i++;
  615. if (i == rx_ring->count)
  616. i = 0;
  617. next_buffer = &rx_ring->rx_buffer_info[i];
  618. next_rxd = IXGBE_RX_DESC_ADV(*rx_ring, i);
  619. prefetch(next_rxd);
  620. cleaned_count++;
  621. if (staterr & IXGBE_RXD_STAT_EOP) {
  622. rx_ring->stats.packets++;
  623. rx_ring->stats.bytes += skb->len;
  624. } else {
  625. rx_buffer_info->skb = next_buffer->skb;
  626. rx_buffer_info->dma = next_buffer->dma;
  627. next_buffer->skb = skb;
  628. next_buffer->dma = 0;
  629. adapter->non_eop_descs++;
  630. goto next_desc;
  631. }
  632. if (staterr & IXGBE_RXDADV_ERR_FRAME_ERR_MASK) {
  633. dev_kfree_skb_irq(skb);
  634. goto next_desc;
  635. }
  636. ixgbe_rx_checksum(adapter, staterr, skb);
  637. /* probably a little skewed due to removing CRC */
  638. total_rx_bytes += skb->len;
  639. total_rx_packets++;
  640. skb->protocol = eth_type_trans(skb, adapter->netdev);
  641. ixgbe_receive_skb(q_vector, skb, staterr, rx_desc);
  642. next_desc:
  643. rx_desc->wb.upper.status_error = 0;
  644. /* return some buffers to hardware, one at a time is too slow */
  645. if (cleaned_count >= IXGBE_RX_BUFFER_WRITE) {
  646. ixgbe_alloc_rx_buffers(adapter, rx_ring, cleaned_count);
  647. cleaned_count = 0;
  648. }
  649. /* use prefetched values */
  650. rx_desc = next_rxd;
  651. rx_buffer_info = next_buffer;
  652. staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
  653. }
  654. rx_ring->next_to_clean = i;
  655. cleaned_count = IXGBE_DESC_UNUSED(rx_ring);
  656. if (cleaned_count)
  657. ixgbe_alloc_rx_buffers(adapter, rx_ring, cleaned_count);
  658. rx_ring->total_packets += total_rx_packets;
  659. rx_ring->total_bytes += total_rx_bytes;
  660. adapter->net_stats.rx_bytes += total_rx_bytes;
  661. adapter->net_stats.rx_packets += total_rx_packets;
  662. return cleaned;
  663. }
  664. static int ixgbe_clean_rxonly(struct napi_struct *, int);
  665. /**
  666. * ixgbe_configure_msix - Configure MSI-X hardware
  667. * @adapter: board private structure
  668. *
  669. * ixgbe_configure_msix sets up the hardware to properly generate MSI-X
  670. * interrupts.
  671. **/
  672. static void ixgbe_configure_msix(struct ixgbe_adapter *adapter)
  673. {
  674. struct ixgbe_q_vector *q_vector;
  675. int i, j, q_vectors, v_idx, r_idx;
  676. u32 mask;
  677. q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
  678. /* Populate the IVAR table and set the ITR values to the
  679. * corresponding register.
  680. */
  681. for (v_idx = 0; v_idx < q_vectors; v_idx++) {
  682. q_vector = &adapter->q_vector[v_idx];
  683. /* XXX for_each_bit(...) */
  684. r_idx = find_first_bit(q_vector->rxr_idx,
  685. adapter->num_rx_queues);
  686. for (i = 0; i < q_vector->rxr_count; i++) {
  687. j = adapter->rx_ring[r_idx].reg_idx;
  688. ixgbe_set_ivar(adapter, 0, j, v_idx);
  689. r_idx = find_next_bit(q_vector->rxr_idx,
  690. adapter->num_rx_queues,
  691. r_idx + 1);
  692. }
  693. r_idx = find_first_bit(q_vector->txr_idx,
  694. adapter->num_tx_queues);
  695. for (i = 0; i < q_vector->txr_count; i++) {
  696. j = adapter->tx_ring[r_idx].reg_idx;
  697. ixgbe_set_ivar(adapter, 1, j, v_idx);
  698. r_idx = find_next_bit(q_vector->txr_idx,
  699. adapter->num_tx_queues,
  700. r_idx + 1);
  701. }
  702. /* if this is a tx only vector halve the interrupt rate */
  703. if (q_vector->txr_count && !q_vector->rxr_count)
  704. q_vector->eitr = (adapter->eitr_param >> 1);
  705. else
  706. /* rx only */
  707. q_vector->eitr = adapter->eitr_param;
  708. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(v_idx),
  709. EITR_INTS_PER_SEC_TO_REG(q_vector->eitr));
  710. }
  711. if (adapter->hw.mac.type == ixgbe_mac_82598EB)
  712. ixgbe_set_ivar(adapter, -1, IXGBE_IVAR_OTHER_CAUSES_INDEX,
  713. v_idx);
  714. else if (adapter->hw.mac.type == ixgbe_mac_82599EB)
  715. ixgbe_set_ivar(adapter, -1, 1, v_idx);
  716. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(v_idx), 1950);
  717. /* set up to autoclear timer, and the vectors */
  718. mask = IXGBE_EIMS_ENABLE_MASK;
  719. mask &= ~(IXGBE_EIMS_OTHER | IXGBE_EIMS_LSC);
  720. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, mask);
  721. }
  722. enum latency_range {
  723. lowest_latency = 0,
  724. low_latency = 1,
  725. bulk_latency = 2,
  726. latency_invalid = 255
  727. };
  728. /**
  729. * ixgbe_update_itr - update the dynamic ITR value based on statistics
  730. * @adapter: pointer to adapter
  731. * @eitr: eitr setting (ints per sec) to give last timeslice
  732. * @itr_setting: current throttle rate in ints/second
  733. * @packets: the number of packets during this measurement interval
  734. * @bytes: the number of bytes during this measurement interval
  735. *
  736. * Stores a new ITR value based on packets and byte
  737. * counts during the last interrupt. The advantage of per interrupt
  738. * computation is faster updates and more accurate ITR for the current
  739. * traffic pattern. Constants in this function were computed
  740. * based on theoretical maximum wire speed and thresholds were set based
  741. * on testing data as well as attempting to minimize response time
  742. * while increasing bulk throughput.
  743. * this functionality is controlled by the InterruptThrottleRate module
  744. * parameter (see ixgbe_param.c)
  745. **/
  746. static u8 ixgbe_update_itr(struct ixgbe_adapter *adapter,
  747. u32 eitr, u8 itr_setting,
  748. int packets, int bytes)
  749. {
  750. unsigned int retval = itr_setting;
  751. u32 timepassed_us;
  752. u64 bytes_perint;
  753. if (packets == 0)
  754. goto update_itr_done;
  755. /* simple throttlerate management
  756. * 0-20MB/s lowest (100000 ints/s)
  757. * 20-100MB/s low (20000 ints/s)
  758. * 100-1249MB/s bulk (8000 ints/s)
  759. */
  760. /* what was last interrupt timeslice? */
  761. timepassed_us = 1000000/eitr;
  762. bytes_perint = bytes / timepassed_us; /* bytes/usec */
  763. switch (itr_setting) {
  764. case lowest_latency:
  765. if (bytes_perint > adapter->eitr_low)
  766. retval = low_latency;
  767. break;
  768. case low_latency:
  769. if (bytes_perint > adapter->eitr_high)
  770. retval = bulk_latency;
  771. else if (bytes_perint <= adapter->eitr_low)
  772. retval = lowest_latency;
  773. break;
  774. case bulk_latency:
  775. if (bytes_perint <= adapter->eitr_high)
  776. retval = low_latency;
  777. break;
  778. }
  779. update_itr_done:
  780. return retval;
  781. }
  782. static void ixgbe_set_itr_msix(struct ixgbe_q_vector *q_vector)
  783. {
  784. struct ixgbe_adapter *adapter = q_vector->adapter;
  785. struct ixgbe_hw *hw = &adapter->hw;
  786. u32 new_itr;
  787. u8 current_itr, ret_itr;
  788. int i, r_idx, v_idx = ((void *)q_vector - (void *)(adapter->q_vector)) /
  789. sizeof(struct ixgbe_q_vector);
  790. struct ixgbe_ring *rx_ring, *tx_ring;
  791. r_idx = find_first_bit(q_vector->txr_idx, adapter->num_tx_queues);
  792. for (i = 0; i < q_vector->txr_count; i++) {
  793. tx_ring = &(adapter->tx_ring[r_idx]);
  794. ret_itr = ixgbe_update_itr(adapter, q_vector->eitr,
  795. q_vector->tx_itr,
  796. tx_ring->total_packets,
  797. tx_ring->total_bytes);
  798. /* if the result for this queue would decrease interrupt
  799. * rate for this vector then use that result */
  800. q_vector->tx_itr = ((q_vector->tx_itr > ret_itr) ?
  801. q_vector->tx_itr - 1 : ret_itr);
  802. r_idx = find_next_bit(q_vector->txr_idx, adapter->num_tx_queues,
  803. r_idx + 1);
  804. }
  805. r_idx = find_first_bit(q_vector->rxr_idx, adapter->num_rx_queues);
  806. for (i = 0; i < q_vector->rxr_count; i++) {
  807. rx_ring = &(adapter->rx_ring[r_idx]);
  808. ret_itr = ixgbe_update_itr(adapter, q_vector->eitr,
  809. q_vector->rx_itr,
  810. rx_ring->total_packets,
  811. rx_ring->total_bytes);
  812. /* if the result for this queue would decrease interrupt
  813. * rate for this vector then use that result */
  814. q_vector->rx_itr = ((q_vector->rx_itr > ret_itr) ?
  815. q_vector->rx_itr - 1 : ret_itr);
  816. r_idx = find_next_bit(q_vector->rxr_idx, adapter->num_rx_queues,
  817. r_idx + 1);
  818. }
  819. current_itr = max(q_vector->rx_itr, q_vector->tx_itr);
  820. switch (current_itr) {
  821. /* counts and packets in update_itr are dependent on these numbers */
  822. case lowest_latency:
  823. new_itr = 100000;
  824. break;
  825. case low_latency:
  826. new_itr = 20000; /* aka hwitr = ~200 */
  827. break;
  828. case bulk_latency:
  829. default:
  830. new_itr = 8000;
  831. break;
  832. }
  833. if (new_itr != q_vector->eitr) {
  834. u32 itr_reg;
  835. /* do an exponential smoothing */
  836. new_itr = ((q_vector->eitr * 90)/100) + ((new_itr * 10)/100);
  837. q_vector->eitr = new_itr;
  838. itr_reg = EITR_INTS_PER_SEC_TO_REG(new_itr);
  839. if (adapter->hw.mac.type == ixgbe_mac_82599EB)
  840. /* Resolution is 2 usec on 82599, so halve the rate */
  841. itr_reg >>= 1;
  842. /* must write high and low 16 bits to reset counter */
  843. DPRINTK(TX_ERR, DEBUG, "writing eitr(%d): %08X\n", v_idx,
  844. itr_reg);
  845. IXGBE_WRITE_REG(hw, IXGBE_EITR(v_idx), itr_reg | (itr_reg)<<16);
  846. }
  847. return;
  848. }
  849. static void ixgbe_check_fan_failure(struct ixgbe_adapter *adapter, u32 eicr)
  850. {
  851. struct ixgbe_hw *hw = &adapter->hw;
  852. if ((adapter->flags & IXGBE_FLAG_FAN_FAIL_CAPABLE) &&
  853. (eicr & IXGBE_EICR_GPI_SDP1)) {
  854. DPRINTK(PROBE, CRIT, "Fan has stopped, replace the adapter\n");
  855. /* write to clear the interrupt */
  856. IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1);
  857. }
  858. }
  859. static void ixgbe_check_sfp_event(struct ixgbe_adapter *adapter, u32 eicr)
  860. {
  861. struct ixgbe_hw *hw = &adapter->hw;
  862. if (eicr & IXGBE_EICR_GPI_SDP1) {
  863. /* Clear the interrupt */
  864. IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1);
  865. schedule_work(&adapter->multispeed_fiber_task);
  866. } else if (eicr & IXGBE_EICR_GPI_SDP2) {
  867. /* Clear the interrupt */
  868. IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP2);
  869. schedule_work(&adapter->sfp_config_module_task);
  870. } else {
  871. /* Interrupt isn't for us... */
  872. return;
  873. }
  874. }
  875. static void ixgbe_check_lsc(struct ixgbe_adapter *adapter)
  876. {
  877. struct ixgbe_hw *hw = &adapter->hw;
  878. adapter->lsc_int++;
  879. adapter->flags |= IXGBE_FLAG_NEED_LINK_UPDATE;
  880. adapter->link_check_timeout = jiffies;
  881. if (!test_bit(__IXGBE_DOWN, &adapter->state)) {
  882. IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC);
  883. schedule_work(&adapter->watchdog_task);
  884. }
  885. }
  886. static irqreturn_t ixgbe_msix_lsc(int irq, void *data)
  887. {
  888. struct net_device *netdev = data;
  889. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  890. struct ixgbe_hw *hw = &adapter->hw;
  891. u32 eicr;
  892. /*
  893. * Workaround for Silicon errata. Use clear-by-write instead
  894. * of clear-by-read. Reading with EICS will return the
  895. * interrupt causes without clearing, which later be done
  896. * with the write to EICR.
  897. */
  898. eicr = IXGBE_READ_REG(hw, IXGBE_EICS);
  899. IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr);
  900. if (eicr & IXGBE_EICR_LSC)
  901. ixgbe_check_lsc(adapter);
  902. if (hw->mac.type == ixgbe_mac_82598EB)
  903. ixgbe_check_fan_failure(adapter, eicr);
  904. if (hw->mac.type == ixgbe_mac_82599EB)
  905. ixgbe_check_sfp_event(adapter, eicr);
  906. if (!test_bit(__IXGBE_DOWN, &adapter->state))
  907. IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_OTHER);
  908. return IRQ_HANDLED;
  909. }
  910. static irqreturn_t ixgbe_msix_clean_tx(int irq, void *data)
  911. {
  912. struct ixgbe_q_vector *q_vector = data;
  913. struct ixgbe_adapter *adapter = q_vector->adapter;
  914. struct ixgbe_ring *tx_ring;
  915. int i, r_idx;
  916. if (!q_vector->txr_count)
  917. return IRQ_HANDLED;
  918. r_idx = find_first_bit(q_vector->txr_idx, adapter->num_tx_queues);
  919. for (i = 0; i < q_vector->txr_count; i++) {
  920. tx_ring = &(adapter->tx_ring[r_idx]);
  921. #ifdef CONFIG_IXGBE_DCA
  922. if (adapter->flags & IXGBE_FLAG_DCA_ENABLED)
  923. ixgbe_update_tx_dca(adapter, tx_ring);
  924. #endif
  925. tx_ring->total_bytes = 0;
  926. tx_ring->total_packets = 0;
  927. ixgbe_clean_tx_irq(adapter, tx_ring);
  928. r_idx = find_next_bit(q_vector->txr_idx, adapter->num_tx_queues,
  929. r_idx + 1);
  930. }
  931. return IRQ_HANDLED;
  932. }
  933. /**
  934. * ixgbe_msix_clean_rx - single unshared vector rx clean (all queues)
  935. * @irq: unused
  936. * @data: pointer to our q_vector struct for this interrupt vector
  937. **/
  938. static irqreturn_t ixgbe_msix_clean_rx(int irq, void *data)
  939. {
  940. struct ixgbe_q_vector *q_vector = data;
  941. struct ixgbe_adapter *adapter = q_vector->adapter;
  942. struct ixgbe_ring *rx_ring;
  943. int r_idx;
  944. int i;
  945. r_idx = find_first_bit(q_vector->rxr_idx, adapter->num_rx_queues);
  946. for (i = 0; i < q_vector->rxr_count; i++) {
  947. rx_ring = &(adapter->rx_ring[r_idx]);
  948. rx_ring->total_bytes = 0;
  949. rx_ring->total_packets = 0;
  950. r_idx = find_next_bit(q_vector->rxr_idx, adapter->num_rx_queues,
  951. r_idx + 1);
  952. }
  953. if (!q_vector->rxr_count)
  954. return IRQ_HANDLED;
  955. r_idx = find_first_bit(q_vector->rxr_idx, adapter->num_rx_queues);
  956. rx_ring = &(adapter->rx_ring[r_idx]);
  957. /* disable interrupts on this vector only */
  958. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, rx_ring->v_idx);
  959. napi_schedule(&q_vector->napi);
  960. return IRQ_HANDLED;
  961. }
  962. static irqreturn_t ixgbe_msix_clean_many(int irq, void *data)
  963. {
  964. ixgbe_msix_clean_rx(irq, data);
  965. ixgbe_msix_clean_tx(irq, data);
  966. return IRQ_HANDLED;
  967. }
  968. /**
  969. * ixgbe_clean_rxonly - msix (aka one shot) rx clean routine
  970. * @napi: napi struct with our devices info in it
  971. * @budget: amount of work driver is allowed to do this pass, in packets
  972. *
  973. * This function is optimized for cleaning one queue only on a single
  974. * q_vector!!!
  975. **/
  976. static int ixgbe_clean_rxonly(struct napi_struct *napi, int budget)
  977. {
  978. struct ixgbe_q_vector *q_vector =
  979. container_of(napi, struct ixgbe_q_vector, napi);
  980. struct ixgbe_adapter *adapter = q_vector->adapter;
  981. struct ixgbe_ring *rx_ring = NULL;
  982. int work_done = 0;
  983. long r_idx;
  984. r_idx = find_first_bit(q_vector->rxr_idx, adapter->num_rx_queues);
  985. rx_ring = &(adapter->rx_ring[r_idx]);
  986. #ifdef CONFIG_IXGBE_DCA
  987. if (adapter->flags & IXGBE_FLAG_DCA_ENABLED)
  988. ixgbe_update_rx_dca(adapter, rx_ring);
  989. #endif
  990. ixgbe_clean_rx_irq(q_vector, rx_ring, &work_done, budget);
  991. /* If all Rx work done, exit the polling mode */
  992. if (work_done < budget) {
  993. napi_complete(napi);
  994. if (adapter->itr_setting & 3)
  995. ixgbe_set_itr_msix(q_vector);
  996. if (!test_bit(__IXGBE_DOWN, &adapter->state))
  997. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, rx_ring->v_idx);
  998. }
  999. return work_done;
  1000. }
  1001. /**
  1002. * ixgbe_clean_rxonly_many - msix (aka one shot) rx clean routine
  1003. * @napi: napi struct with our devices info in it
  1004. * @budget: amount of work driver is allowed to do this pass, in packets
  1005. *
  1006. * This function will clean more than one rx queue associated with a
  1007. * q_vector.
  1008. **/
  1009. static int ixgbe_clean_rxonly_many(struct napi_struct *napi, int budget)
  1010. {
  1011. struct ixgbe_q_vector *q_vector =
  1012. container_of(napi, struct ixgbe_q_vector, napi);
  1013. struct ixgbe_adapter *adapter = q_vector->adapter;
  1014. struct ixgbe_ring *rx_ring = NULL;
  1015. int work_done = 0, i;
  1016. long r_idx;
  1017. u16 enable_mask = 0;
  1018. /* attempt to distribute budget to each queue fairly, but don't allow
  1019. * the budget to go below 1 because we'll exit polling */
  1020. budget /= (q_vector->rxr_count ?: 1);
  1021. budget = max(budget, 1);
  1022. r_idx = find_first_bit(q_vector->rxr_idx, adapter->num_rx_queues);
  1023. for (i = 0; i < q_vector->rxr_count; i++) {
  1024. rx_ring = &(adapter->rx_ring[r_idx]);
  1025. #ifdef CONFIG_IXGBE_DCA
  1026. if (adapter->flags & IXGBE_FLAG_DCA_ENABLED)
  1027. ixgbe_update_rx_dca(adapter, rx_ring);
  1028. #endif
  1029. ixgbe_clean_rx_irq(q_vector, rx_ring, &work_done, budget);
  1030. enable_mask |= rx_ring->v_idx;
  1031. r_idx = find_next_bit(q_vector->rxr_idx, adapter->num_rx_queues,
  1032. r_idx + 1);
  1033. }
  1034. r_idx = find_first_bit(q_vector->rxr_idx, adapter->num_rx_queues);
  1035. rx_ring = &(adapter->rx_ring[r_idx]);
  1036. /* If all Rx work done, exit the polling mode */
  1037. if (work_done < budget) {
  1038. napi_complete(napi);
  1039. if (adapter->itr_setting & 3)
  1040. ixgbe_set_itr_msix(q_vector);
  1041. if (!test_bit(__IXGBE_DOWN, &adapter->state))
  1042. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, enable_mask);
  1043. return 0;
  1044. }
  1045. return work_done;
  1046. }
  1047. static inline void map_vector_to_rxq(struct ixgbe_adapter *a, int v_idx,
  1048. int r_idx)
  1049. {
  1050. a->q_vector[v_idx].adapter = a;
  1051. set_bit(r_idx, a->q_vector[v_idx].rxr_idx);
  1052. a->q_vector[v_idx].rxr_count++;
  1053. a->rx_ring[r_idx].v_idx = 1 << v_idx;
  1054. }
  1055. static inline void map_vector_to_txq(struct ixgbe_adapter *a, int v_idx,
  1056. int r_idx)
  1057. {
  1058. a->q_vector[v_idx].adapter = a;
  1059. set_bit(r_idx, a->q_vector[v_idx].txr_idx);
  1060. a->q_vector[v_idx].txr_count++;
  1061. a->tx_ring[r_idx].v_idx = 1 << v_idx;
  1062. }
  1063. /**
  1064. * ixgbe_map_rings_to_vectors - Maps descriptor rings to vectors
  1065. * @adapter: board private structure to initialize
  1066. * @vectors: allotted vector count for descriptor rings
  1067. *
  1068. * This function maps descriptor rings to the queue-specific vectors
  1069. * we were allotted through the MSI-X enabling code. Ideally, we'd have
  1070. * one vector per ring/queue, but on a constrained vector budget, we
  1071. * group the rings as "efficiently" as possible. You would add new
  1072. * mapping configurations in here.
  1073. **/
  1074. static int ixgbe_map_rings_to_vectors(struct ixgbe_adapter *adapter,
  1075. int vectors)
  1076. {
  1077. int v_start = 0;
  1078. int rxr_idx = 0, txr_idx = 0;
  1079. int rxr_remaining = adapter->num_rx_queues;
  1080. int txr_remaining = adapter->num_tx_queues;
  1081. int i, j;
  1082. int rqpv, tqpv;
  1083. int err = 0;
  1084. /* No mapping required if MSI-X is disabled. */
  1085. if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED))
  1086. goto out;
  1087. /*
  1088. * The ideal configuration...
  1089. * We have enough vectors to map one per queue.
  1090. */
  1091. if (vectors == adapter->num_rx_queues + adapter->num_tx_queues) {
  1092. for (; rxr_idx < rxr_remaining; v_start++, rxr_idx++)
  1093. map_vector_to_rxq(adapter, v_start, rxr_idx);
  1094. for (; txr_idx < txr_remaining; v_start++, txr_idx++)
  1095. map_vector_to_txq(adapter, v_start, txr_idx);
  1096. goto out;
  1097. }
  1098. /*
  1099. * If we don't have enough vectors for a 1-to-1
  1100. * mapping, we'll have to group them so there are
  1101. * multiple queues per vector.
  1102. */
  1103. /* Re-adjusting *qpv takes care of the remainder. */
  1104. for (i = v_start; i < vectors; i++) {
  1105. rqpv = DIV_ROUND_UP(rxr_remaining, vectors - i);
  1106. for (j = 0; j < rqpv; j++) {
  1107. map_vector_to_rxq(adapter, i, rxr_idx);
  1108. rxr_idx++;
  1109. rxr_remaining--;
  1110. }
  1111. }
  1112. for (i = v_start; i < vectors; i++) {
  1113. tqpv = DIV_ROUND_UP(txr_remaining, vectors - i);
  1114. for (j = 0; j < tqpv; j++) {
  1115. map_vector_to_txq(adapter, i, txr_idx);
  1116. txr_idx++;
  1117. txr_remaining--;
  1118. }
  1119. }
  1120. out:
  1121. return err;
  1122. }
  1123. /**
  1124. * ixgbe_request_msix_irqs - Initialize MSI-X interrupts
  1125. * @adapter: board private structure
  1126. *
  1127. * ixgbe_request_msix_irqs allocates MSI-X vectors and requests
  1128. * interrupts from the kernel.
  1129. **/
  1130. static int ixgbe_request_msix_irqs(struct ixgbe_adapter *adapter)
  1131. {
  1132. struct net_device *netdev = adapter->netdev;
  1133. irqreturn_t (*handler)(int, void *);
  1134. int i, vector, q_vectors, err;
  1135. int ri=0, ti=0;
  1136. /* Decrement for Other and TCP Timer vectors */
  1137. q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
  1138. /* Map the Tx/Rx rings to the vectors we were allotted. */
  1139. err = ixgbe_map_rings_to_vectors(adapter, q_vectors);
  1140. if (err)
  1141. goto out;
  1142. #define SET_HANDLER(_v) ((!(_v)->rxr_count) ? &ixgbe_msix_clean_tx : \
  1143. (!(_v)->txr_count) ? &ixgbe_msix_clean_rx : \
  1144. &ixgbe_msix_clean_many)
  1145. for (vector = 0; vector < q_vectors; vector++) {
  1146. handler = SET_HANDLER(&adapter->q_vector[vector]);
  1147. if(handler == &ixgbe_msix_clean_rx) {
  1148. sprintf(adapter->name[vector], "%s-%s-%d",
  1149. netdev->name, "rx", ri++);
  1150. }
  1151. else if(handler == &ixgbe_msix_clean_tx) {
  1152. sprintf(adapter->name[vector], "%s-%s-%d",
  1153. netdev->name, "tx", ti++);
  1154. }
  1155. else
  1156. sprintf(adapter->name[vector], "%s-%s-%d",
  1157. netdev->name, "TxRx", vector);
  1158. err = request_irq(adapter->msix_entries[vector].vector,
  1159. handler, 0, adapter->name[vector],
  1160. &(adapter->q_vector[vector]));
  1161. if (err) {
  1162. DPRINTK(PROBE, ERR,
  1163. "request_irq failed for MSIX interrupt "
  1164. "Error: %d\n", err);
  1165. goto free_queue_irqs;
  1166. }
  1167. }
  1168. sprintf(adapter->name[vector], "%s:lsc", netdev->name);
  1169. err = request_irq(adapter->msix_entries[vector].vector,
  1170. &ixgbe_msix_lsc, 0, adapter->name[vector], netdev);
  1171. if (err) {
  1172. DPRINTK(PROBE, ERR,
  1173. "request_irq for msix_lsc failed: %d\n", err);
  1174. goto free_queue_irqs;
  1175. }
  1176. return 0;
  1177. free_queue_irqs:
  1178. for (i = vector - 1; i >= 0; i--)
  1179. free_irq(adapter->msix_entries[--vector].vector,
  1180. &(adapter->q_vector[i]));
  1181. adapter->flags &= ~IXGBE_FLAG_MSIX_ENABLED;
  1182. pci_disable_msix(adapter->pdev);
  1183. kfree(adapter->msix_entries);
  1184. adapter->msix_entries = NULL;
  1185. out:
  1186. return err;
  1187. }
  1188. static void ixgbe_set_itr(struct ixgbe_adapter *adapter)
  1189. {
  1190. struct ixgbe_hw *hw = &adapter->hw;
  1191. struct ixgbe_q_vector *q_vector = adapter->q_vector;
  1192. u8 current_itr;
  1193. u32 new_itr = q_vector->eitr;
  1194. struct ixgbe_ring *rx_ring = &adapter->rx_ring[0];
  1195. struct ixgbe_ring *tx_ring = &adapter->tx_ring[0];
  1196. q_vector->tx_itr = ixgbe_update_itr(adapter, new_itr,
  1197. q_vector->tx_itr,
  1198. tx_ring->total_packets,
  1199. tx_ring->total_bytes);
  1200. q_vector->rx_itr = ixgbe_update_itr(adapter, new_itr,
  1201. q_vector->rx_itr,
  1202. rx_ring->total_packets,
  1203. rx_ring->total_bytes);
  1204. current_itr = max(q_vector->rx_itr, q_vector->tx_itr);
  1205. switch (current_itr) {
  1206. /* counts and packets in update_itr are dependent on these numbers */
  1207. case lowest_latency:
  1208. new_itr = 100000;
  1209. break;
  1210. case low_latency:
  1211. new_itr = 20000; /* aka hwitr = ~200 */
  1212. break;
  1213. case bulk_latency:
  1214. new_itr = 8000;
  1215. break;
  1216. default:
  1217. break;
  1218. }
  1219. if (new_itr != q_vector->eitr) {
  1220. u32 itr_reg;
  1221. /* do an exponential smoothing */
  1222. new_itr = ((q_vector->eitr * 90)/100) + ((new_itr * 10)/100);
  1223. q_vector->eitr = new_itr;
  1224. itr_reg = EITR_INTS_PER_SEC_TO_REG(new_itr);
  1225. if (adapter->hw.mac.type == ixgbe_mac_82599EB)
  1226. /* Resolution is 2 usec on 82599, so halve the rate */
  1227. itr_reg >>= 1;
  1228. /* must write high and low 16 bits to reset counter */
  1229. IXGBE_WRITE_REG(hw, IXGBE_EITR(0), itr_reg | (itr_reg)<<16);
  1230. }
  1231. return;
  1232. }
  1233. /**
  1234. * ixgbe_irq_disable - Mask off interrupt generation on the NIC
  1235. * @adapter: board private structure
  1236. **/
  1237. static inline void ixgbe_irq_disable(struct ixgbe_adapter *adapter)
  1238. {
  1239. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~0);
  1240. if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
  1241. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC_EX(1), ~0);
  1242. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC_EX(2), ~0);
  1243. }
  1244. IXGBE_WRITE_FLUSH(&adapter->hw);
  1245. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
  1246. int i;
  1247. for (i = 0; i < adapter->num_msix_vectors; i++)
  1248. synchronize_irq(adapter->msix_entries[i].vector);
  1249. } else {
  1250. synchronize_irq(adapter->pdev->irq);
  1251. }
  1252. }
  1253. /**
  1254. * ixgbe_irq_enable - Enable default interrupt generation settings
  1255. * @adapter: board private structure
  1256. **/
  1257. static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter)
  1258. {
  1259. u32 mask;
  1260. mask = IXGBE_EIMS_ENABLE_MASK;
  1261. if (adapter->flags & IXGBE_FLAG_FAN_FAIL_CAPABLE)
  1262. mask |= IXGBE_EIMS_GPI_SDP1;
  1263. if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
  1264. mask |= IXGBE_EIMS_GPI_SDP1;
  1265. mask |= IXGBE_EIMS_GPI_SDP2;
  1266. }
  1267. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, mask);
  1268. if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
  1269. /* enable the rest of the queue vectors */
  1270. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS_EX(1),
  1271. (IXGBE_EIMS_RTX_QUEUE << 16));
  1272. IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS_EX(2),
  1273. ((IXGBE_EIMS_RTX_QUEUE << 16) |
  1274. IXGBE_EIMS_RTX_QUEUE));
  1275. }
  1276. IXGBE_WRITE_FLUSH(&adapter->hw);
  1277. }
  1278. /**
  1279. * ixgbe_intr - legacy mode Interrupt Handler
  1280. * @irq: interrupt number
  1281. * @data: pointer to a network interface device structure
  1282. **/
  1283. static irqreturn_t ixgbe_intr(int irq, void *data)
  1284. {
  1285. struct net_device *netdev = data;
  1286. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  1287. struct ixgbe_hw *hw = &adapter->hw;
  1288. u32 eicr;
  1289. /*
  1290. * Workaround for silicon errata. Mask the interrupts
  1291. * before the read of EICR.
  1292. */
  1293. IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK);
  1294. /* for NAPI, using EIAM to auto-mask tx/rx interrupt bits on read
  1295. * therefore no explict interrupt disable is necessary */
  1296. eicr = IXGBE_READ_REG(hw, IXGBE_EICR);
  1297. if (!eicr) {
  1298. /* shared interrupt alert!
  1299. * make sure interrupts are enabled because the read will
  1300. * have disabled interrupts due to EIAM */
  1301. ixgbe_irq_enable(adapter);
  1302. return IRQ_NONE; /* Not our interrupt */
  1303. }
  1304. if (eicr & IXGBE_EICR_LSC)
  1305. ixgbe_check_lsc(adapter);
  1306. if (hw->mac.type == ixgbe_mac_82599EB)
  1307. ixgbe_check_sfp_event(adapter, eicr);
  1308. ixgbe_check_fan_failure(adapter, eicr);
  1309. if (napi_schedule_prep(&adapter->q_vector[0].napi)) {
  1310. adapter->tx_ring[0].total_packets = 0;
  1311. adapter->tx_ring[0].total_bytes = 0;
  1312. adapter->rx_ring[0].total_packets = 0;
  1313. adapter->rx_ring[0].total_bytes = 0;
  1314. /* would disable interrupts here but EIAM disabled it */
  1315. __napi_schedule(&adapter->q_vector[0].napi);
  1316. }
  1317. return IRQ_HANDLED;
  1318. }
  1319. static inline void ixgbe_reset_q_vectors(struct ixgbe_adapter *adapter)
  1320. {
  1321. int i, q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
  1322. for (i = 0; i < q_vectors; i++) {
  1323. struct ixgbe_q_vector *q_vector = &adapter->q_vector[i];
  1324. bitmap_zero(q_vector->rxr_idx, MAX_RX_QUEUES);
  1325. bitmap_zero(q_vector->txr_idx, MAX_TX_QUEUES);
  1326. q_vector->rxr_count = 0;
  1327. q_vector->txr_count = 0;
  1328. }
  1329. }
  1330. /**
  1331. * ixgbe_request_irq - initialize interrupts
  1332. * @adapter: board private structure
  1333. *
  1334. * Attempts to configure interrupts using the best available
  1335. * capabilities of the hardware and kernel.
  1336. **/
  1337. static int ixgbe_request_irq(struct ixgbe_adapter *adapter)
  1338. {
  1339. struct net_device *netdev = adapter->netdev;
  1340. int err;
  1341. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
  1342. err = ixgbe_request_msix_irqs(adapter);
  1343. } else if (adapter->flags & IXGBE_FLAG_MSI_ENABLED) {
  1344. err = request_irq(adapter->pdev->irq, &ixgbe_intr, 0,
  1345. netdev->name, netdev);
  1346. } else {
  1347. err = request_irq(adapter->pdev->irq, &ixgbe_intr, IRQF_SHARED,
  1348. netdev->name, netdev);
  1349. }
  1350. if (err)
  1351. DPRINTK(PROBE, ERR, "request_irq failed, Error %d\n", err);
  1352. return err;
  1353. }
  1354. static void ixgbe_free_irq(struct ixgbe_adapter *adapter)
  1355. {
  1356. struct net_device *netdev = adapter->netdev;
  1357. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
  1358. int i, q_vectors;
  1359. q_vectors = adapter->num_msix_vectors;
  1360. i = q_vectors - 1;
  1361. free_irq(adapter->msix_entries[i].vector, netdev);
  1362. i--;
  1363. for (; i >= 0; i--) {
  1364. free_irq(adapter->msix_entries[i].vector,
  1365. &(adapter->q_vector[i]));
  1366. }
  1367. ixgbe_reset_q_vectors(adapter);
  1368. } else {
  1369. free_irq(adapter->pdev->irq, netdev);
  1370. }
  1371. }
  1372. /**
  1373. * ixgbe_configure_msi_and_legacy - Initialize PIN (INTA...) and MSI interrupts
  1374. *
  1375. **/
  1376. static void ixgbe_configure_msi_and_legacy(struct ixgbe_adapter *adapter)
  1377. {
  1378. struct ixgbe_hw *hw = &adapter->hw;
  1379. IXGBE_WRITE_REG(hw, IXGBE_EITR(0),
  1380. EITR_INTS_PER_SEC_TO_REG(adapter->eitr_param));
  1381. ixgbe_set_ivar(adapter, 0, 0, 0);
  1382. ixgbe_set_ivar(adapter, 1, 0, 0);
  1383. map_vector_to_rxq(adapter, 0, 0);
  1384. map_vector_to_txq(adapter, 0, 0);
  1385. DPRINTK(HW, INFO, "Legacy interrupt IVAR setup done\n");
  1386. }
  1387. /**
  1388. * ixgbe_configure_tx - Configure 8259x Transmit Unit after Reset
  1389. * @adapter: board private structure
  1390. *
  1391. * Configure the Tx unit of the MAC after a reset.
  1392. **/
  1393. static void ixgbe_configure_tx(struct ixgbe_adapter *adapter)
  1394. {
  1395. u64 tdba;
  1396. struct ixgbe_hw *hw = &adapter->hw;
  1397. u32 i, j, tdlen, txctrl;
  1398. /* Setup the HW Tx Head and Tail descriptor pointers */
  1399. for (i = 0; i < adapter->num_tx_queues; i++) {
  1400. struct ixgbe_ring *ring = &adapter->tx_ring[i];
  1401. j = ring->reg_idx;
  1402. tdba = ring->dma;
  1403. tdlen = ring->count * sizeof(union ixgbe_adv_tx_desc);
  1404. IXGBE_WRITE_REG(hw, IXGBE_TDBAL(j),
  1405. (tdba & DMA_32BIT_MASK));
  1406. IXGBE_WRITE_REG(hw, IXGBE_TDBAH(j), (tdba >> 32));
  1407. IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j), tdlen);
  1408. IXGBE_WRITE_REG(hw, IXGBE_TDH(j), 0);
  1409. IXGBE_WRITE_REG(hw, IXGBE_TDT(j), 0);
  1410. adapter->tx_ring[i].head = IXGBE_TDH(j);
  1411. adapter->tx_ring[i].tail = IXGBE_TDT(j);
  1412. /* Disable Tx Head Writeback RO bit, since this hoses
  1413. * bookkeeping if things aren't delivered in order.
  1414. */
  1415. txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(j));
  1416. txctrl &= ~IXGBE_DCA_TXCTRL_TX_WB_RO_EN;
  1417. IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(j), txctrl);
  1418. }
  1419. if (hw->mac.type == ixgbe_mac_82599EB) {
  1420. /* We enable 8 traffic classes, DCB only */
  1421. if (adapter->flags & IXGBE_FLAG_DCB_ENABLED)
  1422. IXGBE_WRITE_REG(hw, IXGBE_MTQC, (IXGBE_MTQC_RT_ENA |
  1423. IXGBE_MTQC_8TC_8TQ));
  1424. }
  1425. }
  1426. #define IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT 2
  1427. static void ixgbe_configure_srrctl(struct ixgbe_adapter *adapter, int index)
  1428. {
  1429. struct ixgbe_ring *rx_ring;
  1430. u32 srrctl;
  1431. int queue0 = 0;
  1432. unsigned long mask;
  1433. if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
  1434. queue0 = index;
  1435. } else {
  1436. mask = (unsigned long) adapter->ring_feature[RING_F_RSS].mask;
  1437. queue0 = index & mask;
  1438. index = index & mask;
  1439. }
  1440. rx_ring = &adapter->rx_ring[queue0];
  1441. srrctl = IXGBE_READ_REG(&adapter->hw, IXGBE_SRRCTL(index));
  1442. srrctl &= ~IXGBE_SRRCTL_BSIZEHDR_MASK;
  1443. srrctl &= ~IXGBE_SRRCTL_BSIZEPKT_MASK;
  1444. if (adapter->flags & IXGBE_FLAG_RX_PS_ENABLED) {
  1445. u16 bufsz = IXGBE_RXBUFFER_2048;
  1446. /* grow the amount we can receive on large page machines */
  1447. if (bufsz < (PAGE_SIZE / 2))
  1448. bufsz = (PAGE_SIZE / 2);
  1449. /* cap the bufsz at our largest descriptor size */
  1450. bufsz = min((u16)IXGBE_MAX_RXBUFFER, bufsz);
  1451. srrctl |= bufsz >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
  1452. srrctl |= IXGBE_SRRCTL_DESCTYPE_HDR_SPLIT_ALWAYS;
  1453. srrctl |= ((IXGBE_RX_HDR_SIZE <<
  1454. IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT) &
  1455. IXGBE_SRRCTL_BSIZEHDR_MASK);
  1456. } else {
  1457. srrctl |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
  1458. if (rx_ring->rx_buf_len == MAXIMUM_ETHERNET_VLAN_SIZE)
  1459. srrctl |= IXGBE_RXBUFFER_2048 >>
  1460. IXGBE_SRRCTL_BSIZEPKT_SHIFT;
  1461. else
  1462. srrctl |= rx_ring->rx_buf_len >>
  1463. IXGBE_SRRCTL_BSIZEPKT_SHIFT;
  1464. }
  1465. if (adapter->hw.mac.type == ixgbe_mac_82599EB)
  1466. srrctl |= IXGBE_SRRCTL_DROP_EN;
  1467. IXGBE_WRITE_REG(&adapter->hw, IXGBE_SRRCTL(index), srrctl);
  1468. }
  1469. /**
  1470. * ixgbe_configure_rx - Configure 8259x Receive Unit after Reset
  1471. * @adapter: board private structure
  1472. *
  1473. * Configure the Rx unit of the MAC after a reset.
  1474. **/
  1475. static void ixgbe_configure_rx(struct ixgbe_adapter *adapter)
  1476. {
  1477. u64 rdba;
  1478. struct ixgbe_hw *hw = &adapter->hw;
  1479. struct net_device *netdev = adapter->netdev;
  1480. int max_frame = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
  1481. int i, j;
  1482. u32 rdlen, rxctrl, rxcsum;
  1483. static const u32 seed[10] = { 0xE291D73D, 0x1805EC6C, 0x2A94B30D,
  1484. 0xA54F2BEC, 0xEA49AF7C, 0xE214AD3D, 0xB855AABE,
  1485. 0x6A3E67EA, 0x14364D17, 0x3BED200D};
  1486. u32 fctrl, hlreg0;
  1487. u32 reta = 0, mrqc;
  1488. u32 rdrxctl;
  1489. int rx_buf_len;
  1490. /* Decide whether to use packet split mode or not */
  1491. adapter->flags |= IXGBE_FLAG_RX_PS_ENABLED;
  1492. /* Set the RX buffer length according to the mode */
  1493. if (adapter->flags & IXGBE_FLAG_RX_PS_ENABLED) {
  1494. rx_buf_len = IXGBE_RX_HDR_SIZE;
  1495. if (hw->mac.type == ixgbe_mac_82599EB) {
  1496. /* PSRTYPE must be initialized in 82599 */
  1497. u32 psrtype = IXGBE_PSRTYPE_TCPHDR |
  1498. IXGBE_PSRTYPE_UDPHDR |
  1499. IXGBE_PSRTYPE_IPV4HDR |
  1500. IXGBE_PSRTYPE_IPV6HDR;
  1501. IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(0), psrtype);
  1502. }
  1503. } else {
  1504. if (netdev->mtu <= ETH_DATA_LEN)
  1505. rx_buf_len = MAXIMUM_ETHERNET_VLAN_SIZE;
  1506. else
  1507. rx_buf_len = ALIGN(max_frame, 1024);
  1508. }
  1509. fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL);
  1510. fctrl |= IXGBE_FCTRL_BAM;
  1511. fctrl |= IXGBE_FCTRL_DPF; /* discard pause frames when FC enabled */
  1512. fctrl |= IXGBE_FCTRL_PMCF;
  1513. IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl);
  1514. hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
  1515. if (adapter->netdev->mtu <= ETH_DATA_LEN)
  1516. hlreg0 &= ~IXGBE_HLREG0_JUMBOEN;
  1517. else
  1518. hlreg0 |= IXGBE_HLREG0_JUMBOEN;
  1519. IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0);
  1520. rdlen = adapter->rx_ring[0].count * sizeof(union ixgbe_adv_rx_desc);
  1521. /* disable receives while setting up the descriptors */
  1522. rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
  1523. IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, rxctrl & ~IXGBE_RXCTRL_RXEN);
  1524. /* Setup the HW Rx Head and Tail Descriptor Pointers and
  1525. * the Base and Length of the Rx Descriptor Ring */
  1526. for (i = 0; i < adapter->num_rx_queues; i++) {
  1527. rdba = adapter->rx_ring[i].dma;
  1528. j = adapter->rx_ring[i].reg_idx;
  1529. IXGBE_WRITE_REG(hw, IXGBE_RDBAL(j), (rdba & DMA_32BIT_MASK));
  1530. IXGBE_WRITE_REG(hw, IXGBE_RDBAH(j), (rdba >> 32));
  1531. IXGBE_WRITE_REG(hw, IXGBE_RDLEN(j), rdlen);
  1532. IXGBE_WRITE_REG(hw, IXGBE_RDH(j), 0);
  1533. IXGBE_WRITE_REG(hw, IXGBE_RDT(j), 0);
  1534. adapter->rx_ring[i].head = IXGBE_RDH(j);
  1535. adapter->rx_ring[i].tail = IXGBE_RDT(j);
  1536. adapter->rx_ring[i].rx_buf_len = rx_buf_len;
  1537. ixgbe_configure_srrctl(adapter, j);
  1538. }
  1539. if (hw->mac.type == ixgbe_mac_82598EB) {
  1540. /*
  1541. * For VMDq support of different descriptor types or
  1542. * buffer sizes through the use of multiple SRRCTL
  1543. * registers, RDRXCTL.MVMEN must be set to 1
  1544. *
  1545. * also, the manual doesn't mention it clearly but DCA hints
  1546. * will only use queue 0's tags unless this bit is set. Side
  1547. * effects of setting this bit are only that SRRCTL must be
  1548. * fully programmed [0..15]
  1549. */
  1550. if (adapter->flags &
  1551. (IXGBE_FLAG_RSS_ENABLED | IXGBE_FLAG_VMDQ_ENABLED)) {
  1552. rdrxctl = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
  1553. rdrxctl |= IXGBE_RDRXCTL_MVMEN;
  1554. IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, rdrxctl);
  1555. }
  1556. }
  1557. /* Program MRQC for the distribution of queues */
  1558. if (hw->mac.type == ixgbe_mac_82599EB) {
  1559. int mask = adapter->flags & (
  1560. IXGBE_FLAG_RSS_ENABLED
  1561. | IXGBE_FLAG_DCB_ENABLED
  1562. );
  1563. switch (mask) {
  1564. case (IXGBE_FLAG_RSS_ENABLED):
  1565. mrqc = IXGBE_MRQC_RSSEN;
  1566. break;
  1567. case (IXGBE_FLAG_DCB_ENABLED):
  1568. mrqc = IXGBE_MRQC_RT8TCEN;
  1569. break;
  1570. default:
  1571. break;
  1572. }
  1573. }
  1574. if (adapter->flags & IXGBE_FLAG_RSS_ENABLED) {
  1575. /* Fill out redirection table */
  1576. for (i = 0, j = 0; i < 128; i++, j++) {
  1577. if (j == adapter->ring_feature[RING_F_RSS].indices)
  1578. j = 0;
  1579. /* reta = 4-byte sliding window of
  1580. * 0x00..(indices-1)(indices-1)00..etc. */
  1581. reta = (reta << 8) | (j * 0x11);
  1582. if ((i & 3) == 3)
  1583. IXGBE_WRITE_REG(hw, IXGBE_RETA(i >> 2), reta);
  1584. }
  1585. /* Fill out hash function seeds */
  1586. for (i = 0; i < 10; i++)
  1587. IXGBE_WRITE_REG(hw, IXGBE_RSSRK(i), seed[i]);
  1588. mrqc = IXGBE_MRQC_RSSEN
  1589. /* Perform hash on these packet types */
  1590. | IXGBE_MRQC_RSS_FIELD_IPV4
  1591. | IXGBE_MRQC_RSS_FIELD_IPV4_TCP
  1592. | IXGBE_MRQC_RSS_FIELD_IPV4_UDP
  1593. | IXGBE_MRQC_RSS_FIELD_IPV6
  1594. | IXGBE_MRQC_RSS_FIELD_IPV6_TCP
  1595. | IXGBE_MRQC_RSS_FIELD_IPV6_UDP;
  1596. IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
  1597. }
  1598. rxcsum = IXGBE_READ_REG(hw, IXGBE_RXCSUM);
  1599. if (adapter->flags & IXGBE_FLAG_RSS_ENABLED ||
  1600. adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED) {
  1601. /* Disable indicating checksum in descriptor, enables
  1602. * RSS hash */
  1603. rxcsum |= IXGBE_RXCSUM_PCSD;
  1604. }
  1605. if (!(rxcsum & IXGBE_RXCSUM_PCSD)) {
  1606. /* Enable IPv4 payload checksum for UDP fragments
  1607. * if PCSD is not set */
  1608. rxcsum |= IXGBE_RXCSUM_IPPCSE;
  1609. }
  1610. IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum);
  1611. if (hw->mac.type == ixgbe_mac_82599EB) {
  1612. rdrxctl = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
  1613. rdrxctl |= IXGBE_RDRXCTL_CRCSTRIP;
  1614. IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, rdrxctl);
  1615. }
  1616. }
  1617. static void ixgbe_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
  1618. {
  1619. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  1620. struct ixgbe_hw *hw = &adapter->hw;
  1621. /* add VID to filter table */
  1622. hw->mac.ops.set_vfta(&adapter->hw, vid, 0, true);
  1623. }
  1624. static void ixgbe_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
  1625. {
  1626. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  1627. struct ixgbe_hw *hw = &adapter->hw;
  1628. if (!test_bit(__IXGBE_DOWN, &adapter->state))
  1629. ixgbe_irq_disable(adapter);
  1630. vlan_group_set_device(adapter->vlgrp, vid, NULL);
  1631. if (!test_bit(__IXGBE_DOWN, &adapter->state))
  1632. ixgbe_irq_enable(adapter);
  1633. /* remove VID from filter table */
  1634. hw->mac.ops.set_vfta(&adapter->hw, vid, 0, false);
  1635. }
  1636. static void ixgbe_vlan_rx_register(struct net_device *netdev,
  1637. struct vlan_group *grp)
  1638. {
  1639. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  1640. u32 ctrl;
  1641. int i, j;
  1642. if (!test_bit(__IXGBE_DOWN, &adapter->state))
  1643. ixgbe_irq_disable(adapter);
  1644. adapter->vlgrp = grp;
  1645. /*
  1646. * For a DCB driver, always enable VLAN tag stripping so we can
  1647. * still receive traffic from a DCB-enabled host even if we're
  1648. * not in DCB mode.
  1649. */
  1650. ctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_VLNCTRL);
  1651. if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
  1652. ctrl |= IXGBE_VLNCTRL_VME | IXGBE_VLNCTRL_VFE;
  1653. ctrl &= ~IXGBE_VLNCTRL_CFIEN;
  1654. IXGBE_WRITE_REG(&adapter->hw, IXGBE_VLNCTRL, ctrl);
  1655. } else if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
  1656. ctrl |= IXGBE_VLNCTRL_VFE;
  1657. /* enable VLAN tag insert/strip */
  1658. ctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_VLNCTRL);
  1659. ctrl &= ~IXGBE_VLNCTRL_CFIEN;
  1660. IXGBE_WRITE_REG(&adapter->hw, IXGBE_VLNCTRL, ctrl);
  1661. for (i = 0; i < adapter->num_rx_queues; i++) {
  1662. j = adapter->rx_ring[i].reg_idx;
  1663. ctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_RXDCTL(j));
  1664. ctrl |= IXGBE_RXDCTL_VME;
  1665. IXGBE_WRITE_REG(&adapter->hw, IXGBE_RXDCTL(j), ctrl);
  1666. }
  1667. }
  1668. ixgbe_vlan_rx_add_vid(netdev, 0);
  1669. if (!test_bit(__IXGBE_DOWN, &adapter->state))
  1670. ixgbe_irq_enable(adapter);
  1671. }
  1672. static void ixgbe_restore_vlan(struct ixgbe_adapter *adapter)
  1673. {
  1674. ixgbe_vlan_rx_register(adapter->netdev, adapter->vlgrp);
  1675. if (adapter->vlgrp) {
  1676. u16 vid;
  1677. for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
  1678. if (!vlan_group_get_device(adapter->vlgrp, vid))
  1679. continue;
  1680. ixgbe_vlan_rx_add_vid(adapter->netdev, vid);
  1681. }
  1682. }
  1683. }
  1684. static u8 *ixgbe_addr_list_itr(struct ixgbe_hw *hw, u8 **mc_addr_ptr, u32 *vmdq)
  1685. {
  1686. struct dev_mc_list *mc_ptr;
  1687. u8 *addr = *mc_addr_ptr;
  1688. *vmdq = 0;
  1689. mc_ptr = container_of(addr, struct dev_mc_list, dmi_addr[0]);
  1690. if (mc_ptr->next)
  1691. *mc_addr_ptr = mc_ptr->next->dmi_addr;
  1692. else
  1693. *mc_addr_ptr = NULL;
  1694. return addr;
  1695. }
  1696. /**
  1697. * ixgbe_set_rx_mode - Unicast, Multicast and Promiscuous mode set
  1698. * @netdev: network interface device structure
  1699. *
  1700. * The set_rx_method entry point is called whenever the unicast/multicast
  1701. * address list or the network interface flags are updated. This routine is
  1702. * responsible for configuring the hardware for proper unicast, multicast and
  1703. * promiscuous mode.
  1704. **/
  1705. static void ixgbe_set_rx_mode(struct net_device *netdev)
  1706. {
  1707. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  1708. struct ixgbe_hw *hw = &adapter->hw;
  1709. u32 fctrl, vlnctrl;
  1710. u8 *addr_list = NULL;
  1711. int addr_count = 0;
  1712. /* Check for Promiscuous and All Multicast modes */
  1713. fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
  1714. vlnctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL);
  1715. if (netdev->flags & IFF_PROMISC) {
  1716. hw->addr_ctrl.user_set_promisc = 1;
  1717. fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE);
  1718. vlnctrl &= ~IXGBE_VLNCTRL_VFE;
  1719. } else {
  1720. if (netdev->flags & IFF_ALLMULTI) {
  1721. fctrl |= IXGBE_FCTRL_MPE;
  1722. fctrl &= ~IXGBE_FCTRL_UPE;
  1723. } else {
  1724. fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE);
  1725. }
  1726. vlnctrl |= IXGBE_VLNCTRL_VFE;
  1727. hw->addr_ctrl.user_set_promisc = 0;
  1728. }
  1729. IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
  1730. IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlnctrl);
  1731. /* reprogram secondary unicast list */
  1732. addr_count = netdev->uc_count;
  1733. if (addr_count)
  1734. addr_list = netdev->uc_list->dmi_addr;
  1735. hw->mac.ops.update_uc_addr_list(hw, addr_list, addr_count,
  1736. ixgbe_addr_list_itr);
  1737. /* reprogram multicast list */
  1738. addr_count = netdev->mc_count;
  1739. if (addr_count)
  1740. addr_list = netdev->mc_list->dmi_addr;
  1741. hw->mac.ops.update_mc_addr_list(hw, addr_list, addr_count,
  1742. ixgbe_addr_list_itr);
  1743. }
  1744. static void ixgbe_napi_enable_all(struct ixgbe_adapter *adapter)
  1745. {
  1746. int q_idx;
  1747. struct ixgbe_q_vector *q_vector;
  1748. int q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
  1749. /* legacy and MSI only use one vector */
  1750. if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED))
  1751. q_vectors = 1;
  1752. for (q_idx = 0; q_idx < q_vectors; q_idx++) {
  1753. struct napi_struct *napi;
  1754. q_vector = &adapter->q_vector[q_idx];
  1755. if (!q_vector->rxr_count)
  1756. continue;
  1757. napi = &q_vector->napi;
  1758. if ((adapter->flags & IXGBE_FLAG_MSIX_ENABLED) &&
  1759. (q_vector->rxr_count > 1))
  1760. napi->poll = &ixgbe_clean_rxonly_many;
  1761. napi_enable(napi);
  1762. }
  1763. }
  1764. static void ixgbe_napi_disable_all(struct ixgbe_adapter *adapter)
  1765. {
  1766. int q_idx;
  1767. struct ixgbe_q_vector *q_vector;
  1768. int q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
  1769. /* legacy and MSI only use one vector */
  1770. if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED))
  1771. q_vectors = 1;
  1772. for (q_idx = 0; q_idx < q_vectors; q_idx++) {
  1773. q_vector = &adapter->q_vector[q_idx];
  1774. if (!q_vector->rxr_count)
  1775. continue;
  1776. napi_disable(&q_vector->napi);
  1777. }
  1778. }
  1779. #ifdef CONFIG_IXGBE_DCB
  1780. /*
  1781. * ixgbe_configure_dcb - Configure DCB hardware
  1782. * @adapter: ixgbe adapter struct
  1783. *
  1784. * This is called by the driver on open to configure the DCB hardware.
  1785. * This is also called by the gennetlink interface when reconfiguring
  1786. * the DCB state.
  1787. */
  1788. static void ixgbe_configure_dcb(struct ixgbe_adapter *adapter)
  1789. {
  1790. struct ixgbe_hw *hw = &adapter->hw;
  1791. u32 txdctl, vlnctrl;
  1792. int i, j;
  1793. ixgbe_dcb_check_config(&adapter->dcb_cfg);
  1794. ixgbe_dcb_calculate_tc_credits(&adapter->dcb_cfg, DCB_TX_CONFIG);
  1795. ixgbe_dcb_calculate_tc_credits(&adapter->dcb_cfg, DCB_RX_CONFIG);
  1796. /* reconfigure the hardware */
  1797. ixgbe_dcb_hw_config(&adapter->hw, &adapter->dcb_cfg);
  1798. for (i = 0; i < adapter->num_tx_queues; i++) {
  1799. j = adapter->tx_ring[i].reg_idx;
  1800. txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(j));
  1801. /* PThresh workaround for Tx hang with DFP enabled. */
  1802. txdctl |= 32;
  1803. IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(j), txdctl);
  1804. }
  1805. /* Enable VLAN tag insert/strip */
  1806. vlnctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL);
  1807. if (hw->mac.type == ixgbe_mac_82598EB) {
  1808. vlnctrl |= IXGBE_VLNCTRL_VME | IXGBE_VLNCTRL_VFE;
  1809. vlnctrl &= ~IXGBE_VLNCTRL_CFIEN;
  1810. IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlnctrl);
  1811. } else if (hw->mac.type == ixgbe_mac_82599EB) {
  1812. vlnctrl |= IXGBE_VLNCTRL_VFE;
  1813. vlnctrl &= ~IXGBE_VLNCTRL_CFIEN;
  1814. IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlnctrl);
  1815. for (i = 0; i < adapter->num_rx_queues; i++) {
  1816. j = adapter->rx_ring[i].reg_idx;
  1817. vlnctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(j));
  1818. vlnctrl |= IXGBE_RXDCTL_VME;
  1819. IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(j), vlnctrl);
  1820. }
  1821. }
  1822. hw->mac.ops.set_vfta(&adapter->hw, 0, 0, true);
  1823. }
  1824. #endif
  1825. static void ixgbe_configure(struct ixgbe_adapter *adapter)
  1826. {
  1827. struct net_device *netdev = adapter->netdev;
  1828. int i;
  1829. ixgbe_set_rx_mode(netdev);
  1830. ixgbe_restore_vlan(adapter);
  1831. #ifdef CONFIG_IXGBE_DCB
  1832. if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
  1833. netif_set_gso_max_size(netdev, 32768);
  1834. ixgbe_configure_dcb(adapter);
  1835. } else {
  1836. netif_set_gso_max_size(netdev, 65536);
  1837. }
  1838. #else
  1839. netif_set_gso_max_size(netdev, 65536);
  1840. #endif
  1841. ixgbe_configure_tx(adapter);
  1842. ixgbe_configure_rx(adapter);
  1843. for (i = 0; i < adapter->num_rx_queues; i++)
  1844. ixgbe_alloc_rx_buffers(adapter, &adapter->rx_ring[i],
  1845. (adapter->rx_ring[i].count - 1));
  1846. }
  1847. static inline bool ixgbe_is_sfp(struct ixgbe_hw *hw)
  1848. {
  1849. switch (hw->phy.type) {
  1850. case ixgbe_phy_sfp_avago:
  1851. case ixgbe_phy_sfp_ftl:
  1852. case ixgbe_phy_sfp_intel:
  1853. case ixgbe_phy_sfp_unknown:
  1854. case ixgbe_phy_tw_tyco:
  1855. case ixgbe_phy_tw_unknown:
  1856. return true;
  1857. default:
  1858. return false;
  1859. }
  1860. }
  1861. /**
  1862. * ixgbe_sfp_link_config - set up SFP+ link
  1863. * @adapter: pointer to private adapter struct
  1864. **/
  1865. static void ixgbe_sfp_link_config(struct ixgbe_adapter *adapter)
  1866. {
  1867. struct ixgbe_hw *hw = &adapter->hw;
  1868. if (hw->phy.multispeed_fiber) {
  1869. /*
  1870. * In multispeed fiber setups, the device may not have
  1871. * had a physical connection when the driver loaded.
  1872. * If that's the case, the initial link configuration
  1873. * couldn't get the MAC into 10G or 1G mode, so we'll
  1874. * never have a link status change interrupt fire.
  1875. * We need to try and force an autonegotiation
  1876. * session, then bring up link.
  1877. */
  1878. hw->mac.ops.setup_sfp(hw);
  1879. if (!(adapter->flags & IXGBE_FLAG_IN_SFP_LINK_TASK))
  1880. schedule_work(&adapter->multispeed_fiber_task);
  1881. } else {
  1882. /*
  1883. * Direct Attach Cu and non-multispeed fiber modules
  1884. * still need to be configured properly prior to
  1885. * attempting link.
  1886. */
  1887. if (!(adapter->flags & IXGBE_FLAG_IN_SFP_MOD_TASK))
  1888. schedule_work(&adapter->sfp_config_module_task);
  1889. }
  1890. }
  1891. /**
  1892. * ixgbe_non_sfp_link_config - set up non-SFP+ link
  1893. * @hw: pointer to private hardware struct
  1894. *
  1895. * Returns 0 on success, negative on failure
  1896. **/
  1897. static int ixgbe_non_sfp_link_config(struct ixgbe_hw *hw)
  1898. {
  1899. u32 autoneg;
  1900. bool link_up = false;
  1901. u32 ret = IXGBE_ERR_LINK_SETUP;
  1902. if (hw->mac.ops.check_link)
  1903. ret = hw->mac.ops.check_link(hw, &autoneg, &link_up, false);
  1904. if (ret)
  1905. goto link_cfg_out;
  1906. if (hw->mac.ops.get_link_capabilities)
  1907. ret = hw->mac.ops.get_link_capabilities(hw, &autoneg,
  1908. &hw->mac.autoneg);
  1909. if (ret)
  1910. goto link_cfg_out;
  1911. if (hw->mac.ops.setup_link_speed)
  1912. ret = hw->mac.ops.setup_link_speed(hw, autoneg, true, link_up);
  1913. link_cfg_out:
  1914. return ret;
  1915. }
  1916. #define IXGBE_MAX_RX_DESC_POLL 10
  1917. static inline void ixgbe_rx_desc_queue_enable(struct ixgbe_adapter *adapter,
  1918. int rxr)
  1919. {
  1920. int j = adapter->rx_ring[rxr].reg_idx;
  1921. int k;
  1922. for (k = 0; k < IXGBE_MAX_RX_DESC_POLL; k++) {
  1923. if (IXGBE_READ_REG(&adapter->hw,
  1924. IXGBE_RXDCTL(j)) & IXGBE_RXDCTL_ENABLE)
  1925. break;
  1926. else
  1927. msleep(1);
  1928. }
  1929. if (k >= IXGBE_MAX_RX_DESC_POLL) {
  1930. DPRINTK(DRV, ERR, "RXDCTL.ENABLE on Rx queue %d "
  1931. "not set within the polling period\n", rxr);
  1932. }
  1933. ixgbe_release_rx_desc(&adapter->hw, &adapter->rx_ring[rxr],
  1934. (adapter->rx_ring[rxr].count - 1));
  1935. }
  1936. static int ixgbe_up_complete(struct ixgbe_adapter *adapter)
  1937. {
  1938. struct net_device *netdev = adapter->netdev;
  1939. struct ixgbe_hw *hw = &adapter->hw;
  1940. int i, j = 0;
  1941. int num_rx_rings = adapter->num_rx_queues;
  1942. int err;
  1943. int max_frame = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
  1944. u32 txdctl, rxdctl, mhadd;
  1945. u32 dmatxctl;
  1946. u32 gpie;
  1947. ixgbe_get_hw_control(adapter);
  1948. if ((adapter->flags & IXGBE_FLAG_MSIX_ENABLED) ||
  1949. (adapter->flags & IXGBE_FLAG_MSI_ENABLED)) {
  1950. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
  1951. gpie = (IXGBE_GPIE_MSIX_MODE | IXGBE_GPIE_EIAME |
  1952. IXGBE_GPIE_PBA_SUPPORT | IXGBE_GPIE_OCD);
  1953. } else {
  1954. /* MSI only */
  1955. gpie = 0;
  1956. }
  1957. /* XXX: to interrupt immediately for EICS writes, enable this */
  1958. /* gpie |= IXGBE_GPIE_EIMEN; */
  1959. IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);
  1960. }
  1961. if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED)) {
  1962. /* legacy interrupts, use EIAM to auto-mask when reading EICR,
  1963. * specifically only auto mask tx and rx interrupts */
  1964. IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE);
  1965. }
  1966. /* Enable fan failure interrupt if media type is copper */
  1967. if (adapter->flags & IXGBE_FLAG_FAN_FAIL_CAPABLE) {
  1968. gpie = IXGBE_READ_REG(hw, IXGBE_GPIE);
  1969. gpie |= IXGBE_SDP1_GPIEN;
  1970. IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);
  1971. }
  1972. if (hw->mac.type == ixgbe_mac_82599EB) {
  1973. gpie = IXGBE_READ_REG(hw, IXGBE_GPIE);
  1974. gpie |= IXGBE_SDP1_GPIEN;
  1975. gpie |= IXGBE_SDP2_GPIEN;
  1976. IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);
  1977. }
  1978. mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD);
  1979. if (max_frame != (mhadd >> IXGBE_MHADD_MFS_SHIFT)) {
  1980. mhadd &= ~IXGBE_MHADD_MFS_MASK;
  1981. mhadd |= max_frame << IXGBE_MHADD_MFS_SHIFT;
  1982. IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd);
  1983. }
  1984. for (i = 0; i < adapter->num_tx_queues; i++) {
  1985. j = adapter->tx_ring[i].reg_idx;
  1986. txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(j));
  1987. /* enable WTHRESH=8 descriptors, to encourage burst writeback */
  1988. txdctl |= (8 << 16);
  1989. IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(j), txdctl);
  1990. }
  1991. if (hw->mac.type == ixgbe_mac_82599EB) {
  1992. /* DMATXCTL.EN must be set after all Tx queue config is done */
  1993. dmatxctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL);
  1994. dmatxctl |= IXGBE_DMATXCTL_TE;
  1995. IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, dmatxctl);
  1996. }
  1997. for (i = 0; i < adapter->num_tx_queues; i++) {
  1998. j = adapter->tx_ring[i].reg_idx;
  1999. txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(j));
  2000. txdctl |= IXGBE_TXDCTL_ENABLE;
  2001. IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(j), txdctl);
  2002. }
  2003. for (i = 0; i < num_rx_rings; i++) {
  2004. j = adapter->rx_ring[i].reg_idx;
  2005. rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(j));
  2006. /* enable PTHRESH=32 descriptors (half the internal cache)
  2007. * and HTHRESH=0 descriptors (to minimize latency on fetch),
  2008. * this also removes a pesky rx_no_buffer_count increment */
  2009. rxdctl |= 0x0020;
  2010. rxdctl |= IXGBE_RXDCTL_ENABLE;
  2011. IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(j), rxdctl);
  2012. if (hw->mac.type == ixgbe_mac_82599EB)
  2013. ixgbe_rx_desc_queue_enable(adapter, i);
  2014. }
  2015. /* enable all receives */
  2016. rxdctl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
  2017. if (hw->mac.type == ixgbe_mac_82598EB)
  2018. rxdctl |= (IXGBE_RXCTRL_DMBYPS | IXGBE_RXCTRL_RXEN);
  2019. else
  2020. rxdctl |= IXGBE_RXCTRL_RXEN;
  2021. hw->mac.ops.enable_rx_dma(hw, rxdctl);
  2022. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED)
  2023. ixgbe_configure_msix(adapter);
  2024. else
  2025. ixgbe_configure_msi_and_legacy(adapter);
  2026. ixgbe_napi_add_all(adapter);
  2027. clear_bit(__IXGBE_DOWN, &adapter->state);
  2028. ixgbe_napi_enable_all(adapter);
  2029. /* clear any pending interrupts, may auto mask */
  2030. IXGBE_READ_REG(hw, IXGBE_EICR);
  2031. ixgbe_irq_enable(adapter);
  2032. /*
  2033. * For hot-pluggable SFP+ devices, a new SFP+ module may have
  2034. * arrived before interrupts were enabled. We need to kick off
  2035. * the SFP+ module setup first, then try to bring up link.
  2036. * If we're not hot-pluggable SFP+, we just need to configure link
  2037. * and bring it up.
  2038. */
  2039. err = hw->phy.ops.identify(hw);
  2040. if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
  2041. DPRINTK(PROBE, ERR, "PHY not supported on this NIC %d\n", err);
  2042. ixgbe_down(adapter);
  2043. return err;
  2044. }
  2045. if (ixgbe_is_sfp(hw)) {
  2046. ixgbe_sfp_link_config(adapter);
  2047. } else {
  2048. err = ixgbe_non_sfp_link_config(hw);
  2049. if (err)
  2050. DPRINTK(PROBE, ERR, "link_config FAILED %d\n", err);
  2051. }
  2052. /* enable transmits */
  2053. netif_tx_start_all_queues(netdev);
  2054. /* bring the link up in the watchdog, this could race with our first
  2055. * link up interrupt but shouldn't be a problem */
  2056. adapter->flags |= IXGBE_FLAG_NEED_LINK_UPDATE;
  2057. adapter->link_check_timeout = jiffies;
  2058. mod_timer(&adapter->watchdog_timer, jiffies);
  2059. return 0;
  2060. }
  2061. void ixgbe_reinit_locked(struct ixgbe_adapter *adapter)
  2062. {
  2063. WARN_ON(in_interrupt());
  2064. while (test_and_set_bit(__IXGBE_RESETTING, &adapter->state))
  2065. msleep(1);
  2066. ixgbe_down(adapter);
  2067. ixgbe_up(adapter);
  2068. clear_bit(__IXGBE_RESETTING, &adapter->state);
  2069. }
  2070. int ixgbe_up(struct ixgbe_adapter *adapter)
  2071. {
  2072. /* hardware has been reset, we need to reload some things */
  2073. ixgbe_configure(adapter);
  2074. return ixgbe_up_complete(adapter);
  2075. }
  2076. void ixgbe_reset(struct ixgbe_adapter *adapter)
  2077. {
  2078. struct ixgbe_hw *hw = &adapter->hw;
  2079. if (hw->mac.ops.init_hw(hw))
  2080. dev_err(&adapter->pdev->dev, "Hardware Error\n");
  2081. /* reprogram the RAR[0] in case user changed it. */
  2082. hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
  2083. }
  2084. /**
  2085. * ixgbe_clean_rx_ring - Free Rx Buffers per Queue
  2086. * @adapter: board private structure
  2087. * @rx_ring: ring to free buffers from
  2088. **/
  2089. static void ixgbe_clean_rx_ring(struct ixgbe_adapter *adapter,
  2090. struct ixgbe_ring *rx_ring)
  2091. {
  2092. struct pci_dev *pdev = adapter->pdev;
  2093. unsigned long size;
  2094. unsigned int i;
  2095. /* Free all the Rx ring sk_buffs */
  2096. for (i = 0; i < rx_ring->count; i++) {
  2097. struct ixgbe_rx_buffer *rx_buffer_info;
  2098. rx_buffer_info = &rx_ring->rx_buffer_info[i];
  2099. if (rx_buffer_info->dma) {
  2100. pci_unmap_single(pdev, rx_buffer_info->dma,
  2101. rx_ring->rx_buf_len,
  2102. PCI_DMA_FROMDEVICE);
  2103. rx_buffer_info->dma = 0;
  2104. }
  2105. if (rx_buffer_info->skb) {
  2106. dev_kfree_skb(rx_buffer_info->skb);
  2107. rx_buffer_info->skb = NULL;
  2108. }
  2109. if (!rx_buffer_info->page)
  2110. continue;
  2111. pci_unmap_page(pdev, rx_buffer_info->page_dma, PAGE_SIZE / 2,
  2112. PCI_DMA_FROMDEVICE);
  2113. rx_buffer_info->page_dma = 0;
  2114. put_page(rx_buffer_info->page);
  2115. rx_buffer_info->page = NULL;
  2116. rx_buffer_info->page_offset = 0;
  2117. }
  2118. size = sizeof(struct ixgbe_rx_buffer) * rx_ring->count;
  2119. memset(rx_ring->rx_buffer_info, 0, size);
  2120. /* Zero out the descriptor ring */
  2121. memset(rx_ring->desc, 0, rx_ring->size);
  2122. rx_ring->next_to_clean = 0;
  2123. rx_ring->next_to_use = 0;
  2124. writel(0, adapter->hw.hw_addr + rx_ring->head);
  2125. writel(0, adapter->hw.hw_addr + rx_ring->tail);
  2126. }
  2127. /**
  2128. * ixgbe_clean_tx_ring - Free Tx Buffers
  2129. * @adapter: board private structure
  2130. * @tx_ring: ring to be cleaned
  2131. **/
  2132. static void ixgbe_clean_tx_ring(struct ixgbe_adapter *adapter,
  2133. struct ixgbe_ring *tx_ring)
  2134. {
  2135. struct ixgbe_tx_buffer *tx_buffer_info;
  2136. unsigned long size;
  2137. unsigned int i;
  2138. /* Free all the Tx ring sk_buffs */
  2139. for (i = 0; i < tx_ring->count; i++) {
  2140. tx_buffer_info = &tx_ring->tx_buffer_info[i];
  2141. ixgbe_unmap_and_free_tx_resource(adapter, tx_buffer_info);
  2142. }
  2143. size = sizeof(struct ixgbe_tx_buffer) * tx_ring->count;
  2144. memset(tx_ring->tx_buffer_info, 0, size);
  2145. /* Zero out the descriptor ring */
  2146. memset(tx_ring->desc, 0, tx_ring->size);
  2147. tx_ring->next_to_use = 0;
  2148. tx_ring->next_to_clean = 0;
  2149. writel(0, adapter->hw.hw_addr + tx_ring->head);
  2150. writel(0, adapter->hw.hw_addr + tx_ring->tail);
  2151. }
  2152. /**
  2153. * ixgbe_clean_all_rx_rings - Free Rx Buffers for all queues
  2154. * @adapter: board private structure
  2155. **/
  2156. static void ixgbe_clean_all_rx_rings(struct ixgbe_adapter *adapter)
  2157. {
  2158. int i;
  2159. for (i = 0; i < adapter->num_rx_queues; i++)
  2160. ixgbe_clean_rx_ring(adapter, &adapter->rx_ring[i]);
  2161. }
  2162. /**
  2163. * ixgbe_clean_all_tx_rings - Free Tx Buffers for all queues
  2164. * @adapter: board private structure
  2165. **/
  2166. static void ixgbe_clean_all_tx_rings(struct ixgbe_adapter *adapter)
  2167. {
  2168. int i;
  2169. for (i = 0; i < adapter->num_tx_queues; i++)
  2170. ixgbe_clean_tx_ring(adapter, &adapter->tx_ring[i]);
  2171. }
  2172. void ixgbe_down(struct ixgbe_adapter *adapter)
  2173. {
  2174. struct net_device *netdev = adapter->netdev;
  2175. struct ixgbe_hw *hw = &adapter->hw;
  2176. u32 rxctrl;
  2177. u32 txdctl;
  2178. int i, j;
  2179. /* signal that we are down to the interrupt handler */
  2180. set_bit(__IXGBE_DOWN, &adapter->state);
  2181. /* disable receives */
  2182. rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
  2183. IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, rxctrl & ~IXGBE_RXCTRL_RXEN);
  2184. netif_tx_disable(netdev);
  2185. IXGBE_WRITE_FLUSH(hw);
  2186. msleep(10);
  2187. netif_tx_stop_all_queues(netdev);
  2188. ixgbe_irq_disable(adapter);
  2189. ixgbe_napi_disable_all(adapter);
  2190. del_timer_sync(&adapter->watchdog_timer);
  2191. cancel_work_sync(&adapter->watchdog_task);
  2192. /* disable transmits in the hardware now that interrupts are off */
  2193. for (i = 0; i < adapter->num_tx_queues; i++) {
  2194. j = adapter->tx_ring[i].reg_idx;
  2195. txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(j));
  2196. IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(j),
  2197. (txdctl & ~IXGBE_TXDCTL_ENABLE));
  2198. }
  2199. netif_carrier_off(netdev);
  2200. #ifdef CONFIG_IXGBE_DCA
  2201. if (adapter->flags & IXGBE_FLAG_DCA_ENABLED) {
  2202. adapter->flags &= ~IXGBE_FLAG_DCA_ENABLED;
  2203. dca_remove_requester(&adapter->pdev->dev);
  2204. }
  2205. #endif
  2206. if (!pci_channel_offline(adapter->pdev))
  2207. ixgbe_reset(adapter);
  2208. ixgbe_clean_all_tx_rings(adapter);
  2209. ixgbe_clean_all_rx_rings(adapter);
  2210. #ifdef CONFIG_IXGBE_DCA
  2211. /* since we reset the hardware DCA settings were cleared */
  2212. if (dca_add_requester(&adapter->pdev->dev) == 0) {
  2213. adapter->flags |= IXGBE_FLAG_DCA_ENABLED;
  2214. /* always use CB2 mode, difference is masked
  2215. * in the CB driver */
  2216. IXGBE_WRITE_REG(hw, IXGBE_DCA_CTRL, 2);
  2217. ixgbe_setup_dca(adapter);
  2218. }
  2219. #endif
  2220. }
  2221. /**
  2222. * ixgbe_poll - NAPI Rx polling callback
  2223. * @napi: structure for representing this polling device
  2224. * @budget: how many packets driver is allowed to clean
  2225. *
  2226. * This function is used for legacy and MSI, NAPI mode
  2227. **/
  2228. static int ixgbe_poll(struct napi_struct *napi, int budget)
  2229. {
  2230. struct ixgbe_q_vector *q_vector = container_of(napi,
  2231. struct ixgbe_q_vector, napi);
  2232. struct ixgbe_adapter *adapter = q_vector->adapter;
  2233. int tx_cleaned, work_done = 0;
  2234. #ifdef CONFIG_IXGBE_DCA
  2235. if (adapter->flags & IXGBE_FLAG_DCA_ENABLED) {
  2236. ixgbe_update_tx_dca(adapter, adapter->tx_ring);
  2237. ixgbe_update_rx_dca(adapter, adapter->rx_ring);
  2238. }
  2239. #endif
  2240. tx_cleaned = ixgbe_clean_tx_irq(adapter, adapter->tx_ring);
  2241. ixgbe_clean_rx_irq(q_vector, adapter->rx_ring, &work_done, budget);
  2242. if (tx_cleaned)
  2243. work_done = budget;
  2244. /* If budget not fully consumed, exit the polling mode */
  2245. if (work_done < budget) {
  2246. napi_complete(napi);
  2247. if (adapter->itr_setting & 3)
  2248. ixgbe_set_itr(adapter);
  2249. if (!test_bit(__IXGBE_DOWN, &adapter->state))
  2250. ixgbe_irq_enable(adapter);
  2251. }
  2252. return work_done;
  2253. }
  2254. /**
  2255. * ixgbe_tx_timeout - Respond to a Tx Hang
  2256. * @netdev: network interface device structure
  2257. **/
  2258. static void ixgbe_tx_timeout(struct net_device *netdev)
  2259. {
  2260. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  2261. /* Do the reset outside of interrupt context */
  2262. schedule_work(&adapter->reset_task);
  2263. }
  2264. static void ixgbe_reset_task(struct work_struct *work)
  2265. {
  2266. struct ixgbe_adapter *adapter;
  2267. adapter = container_of(work, struct ixgbe_adapter, reset_task);
  2268. /* If we're already down or resetting, just bail */
  2269. if (test_bit(__IXGBE_DOWN, &adapter->state) ||
  2270. test_bit(__IXGBE_RESETTING, &adapter->state))
  2271. return;
  2272. adapter->tx_timeout_count++;
  2273. ixgbe_reinit_locked(adapter);
  2274. }
  2275. #ifdef CONFIG_IXGBE_DCB
  2276. static inline bool ixgbe_set_dcb_queues(struct ixgbe_adapter *adapter)
  2277. {
  2278. bool ret = false;
  2279. if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
  2280. adapter->ring_feature[RING_F_DCB].mask = 0x7 << 3;
  2281. adapter->num_rx_queues =
  2282. adapter->ring_feature[RING_F_DCB].indices;
  2283. adapter->num_tx_queues =
  2284. adapter->ring_feature[RING_F_DCB].indices;
  2285. ret = true;
  2286. } else {
  2287. ret = false;
  2288. }
  2289. return ret;
  2290. }
  2291. #endif
  2292. static inline bool ixgbe_set_rss_queues(struct ixgbe_adapter *adapter)
  2293. {
  2294. bool ret = false;
  2295. if (adapter->flags & IXGBE_FLAG_RSS_ENABLED) {
  2296. adapter->ring_feature[RING_F_RSS].mask = 0xF;
  2297. adapter->num_rx_queues =
  2298. adapter->ring_feature[RING_F_RSS].indices;
  2299. adapter->num_tx_queues =
  2300. adapter->ring_feature[RING_F_RSS].indices;
  2301. ret = true;
  2302. } else {
  2303. ret = false;
  2304. }
  2305. return ret;
  2306. }
  2307. static void ixgbe_set_num_queues(struct ixgbe_adapter *adapter)
  2308. {
  2309. /* Start with base case */
  2310. adapter->num_rx_queues = 1;
  2311. adapter->num_tx_queues = 1;
  2312. #ifdef CONFIG_IXGBE_DCB
  2313. if (ixgbe_set_dcb_queues(adapter))
  2314. return;
  2315. #endif
  2316. if (ixgbe_set_rss_queues(adapter))
  2317. return;
  2318. }
  2319. static void ixgbe_acquire_msix_vectors(struct ixgbe_adapter *adapter,
  2320. int vectors)
  2321. {
  2322. int err, vector_threshold;
  2323. /* We'll want at least 3 (vector_threshold):
  2324. * 1) TxQ[0] Cleanup
  2325. * 2) RxQ[0] Cleanup
  2326. * 3) Other (Link Status Change, etc.)
  2327. * 4) TCP Timer (optional)
  2328. */
  2329. vector_threshold = MIN_MSIX_COUNT;
  2330. /* The more we get, the more we will assign to Tx/Rx Cleanup
  2331. * for the separate queues...where Rx Cleanup >= Tx Cleanup.
  2332. * Right now, we simply care about how many we'll get; we'll
  2333. * set them up later while requesting irq's.
  2334. */
  2335. while (vectors >= vector_threshold) {
  2336. err = pci_enable_msix(adapter->pdev, adapter->msix_entries,
  2337. vectors);
  2338. if (!err) /* Success in acquiring all requested vectors. */
  2339. break;
  2340. else if (err < 0)
  2341. vectors = 0; /* Nasty failure, quit now */
  2342. else /* err == number of vectors we should try again with */
  2343. vectors = err;
  2344. }
  2345. if (vectors < vector_threshold) {
  2346. /* Can't allocate enough MSI-X interrupts? Oh well.
  2347. * This just means we'll go with either a single MSI
  2348. * vector or fall back to legacy interrupts.
  2349. */
  2350. DPRINTK(HW, DEBUG, "Unable to allocate MSI-X interrupts\n");
  2351. adapter->flags &= ~IXGBE_FLAG_MSIX_ENABLED;
  2352. kfree(adapter->msix_entries);
  2353. adapter->msix_entries = NULL;
  2354. adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
  2355. adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
  2356. ixgbe_set_num_queues(adapter);
  2357. } else {
  2358. adapter->flags |= IXGBE_FLAG_MSIX_ENABLED; /* Woot! */
  2359. /*
  2360. * Adjust for only the vectors we'll use, which is minimum
  2361. * of max_msix_q_vectors + NON_Q_VECTORS, or the number of
  2362. * vectors we were allocated.
  2363. */
  2364. adapter->num_msix_vectors = min(vectors,
  2365. adapter->max_msix_q_vectors + NON_Q_VECTORS);
  2366. }
  2367. }
  2368. /**
  2369. * ixgbe_cache_ring_rss - Descriptor ring to register mapping for RSS
  2370. * @adapter: board private structure to initialize
  2371. *
  2372. * Cache the descriptor ring offsets for RSS to the assigned rings.
  2373. *
  2374. **/
  2375. static inline bool ixgbe_cache_ring_rss(struct ixgbe_adapter *adapter)
  2376. {
  2377. int i;
  2378. bool ret = false;
  2379. if (adapter->flags & IXGBE_FLAG_RSS_ENABLED) {
  2380. for (i = 0; i < adapter->num_rx_queues; i++)
  2381. adapter->rx_ring[i].reg_idx = i;
  2382. for (i = 0; i < adapter->num_tx_queues; i++)
  2383. adapter->tx_ring[i].reg_idx = i;
  2384. ret = true;
  2385. } else {
  2386. ret = false;
  2387. }
  2388. return ret;
  2389. }
  2390. #ifdef CONFIG_IXGBE_DCB
  2391. /**
  2392. * ixgbe_cache_ring_dcb - Descriptor ring to register mapping for DCB
  2393. * @adapter: board private structure to initialize
  2394. *
  2395. * Cache the descriptor ring offsets for DCB to the assigned rings.
  2396. *
  2397. **/
  2398. static inline bool ixgbe_cache_ring_dcb(struct ixgbe_adapter *adapter)
  2399. {
  2400. int i;
  2401. bool ret = false;
  2402. int dcb_i = adapter->ring_feature[RING_F_DCB].indices;
  2403. if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
  2404. if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
  2405. /* the number of queues is assumed to be symmetric */
  2406. for (i = 0; i < dcb_i; i++) {
  2407. adapter->rx_ring[i].reg_idx = i << 3;
  2408. adapter->tx_ring[i].reg_idx = i << 2;
  2409. }
  2410. ret = true;
  2411. } else if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
  2412. for (i = 0; i < dcb_i; i++) {
  2413. adapter->rx_ring[i].reg_idx = i << 4;
  2414. adapter->tx_ring[i].reg_idx = i << 4;
  2415. }
  2416. ret = true;
  2417. } else {
  2418. ret = false;
  2419. }
  2420. } else {
  2421. ret = false;
  2422. }
  2423. return ret;
  2424. }
  2425. #endif
  2426. /**
  2427. * ixgbe_cache_ring_register - Descriptor ring to register mapping
  2428. * @adapter: board private structure to initialize
  2429. *
  2430. * Once we know the feature-set enabled for the device, we'll cache
  2431. * the register offset the descriptor ring is assigned to.
  2432. *
  2433. * Note, the order the various feature calls is important. It must start with
  2434. * the "most" features enabled at the same time, then trickle down to the
  2435. * least amount of features turned on at once.
  2436. **/
  2437. static void ixgbe_cache_ring_register(struct ixgbe_adapter *adapter)
  2438. {
  2439. /* start with default case */
  2440. adapter->rx_ring[0].reg_idx = 0;
  2441. adapter->tx_ring[0].reg_idx = 0;
  2442. #ifdef CONFIG_IXGBE_DCB
  2443. if (ixgbe_cache_ring_dcb(adapter))
  2444. return;
  2445. #endif
  2446. if (ixgbe_cache_ring_rss(adapter))
  2447. return;
  2448. }
  2449. /**
  2450. * ixgbe_alloc_queues - Allocate memory for all rings
  2451. * @adapter: board private structure to initialize
  2452. *
  2453. * We allocate one ring per queue at run-time since we don't know the
  2454. * number of queues at compile-time.
  2455. **/
  2456. static int ixgbe_alloc_queues(struct ixgbe_adapter *adapter)
  2457. {
  2458. int i;
  2459. adapter->tx_ring = kcalloc(adapter->num_tx_queues,
  2460. sizeof(struct ixgbe_ring), GFP_KERNEL);
  2461. if (!adapter->tx_ring)
  2462. goto err_tx_ring_allocation;
  2463. adapter->rx_ring = kcalloc(adapter->num_rx_queues,
  2464. sizeof(struct ixgbe_ring), GFP_KERNEL);
  2465. if (!adapter->rx_ring)
  2466. goto err_rx_ring_allocation;
  2467. for (i = 0; i < adapter->num_tx_queues; i++) {
  2468. adapter->tx_ring[i].count = adapter->tx_ring_count;
  2469. adapter->tx_ring[i].queue_index = i;
  2470. }
  2471. for (i = 0; i < adapter->num_rx_queues; i++) {
  2472. adapter->rx_ring[i].count = adapter->rx_ring_count;
  2473. adapter->rx_ring[i].queue_index = i;
  2474. }
  2475. ixgbe_cache_ring_register(adapter);
  2476. return 0;
  2477. err_rx_ring_allocation:
  2478. kfree(adapter->tx_ring);
  2479. err_tx_ring_allocation:
  2480. return -ENOMEM;
  2481. }
  2482. /**
  2483. * ixgbe_set_interrupt_capability - set MSI-X or MSI if supported
  2484. * @adapter: board private structure to initialize
  2485. *
  2486. * Attempt to configure the interrupts using the best available
  2487. * capabilities of the hardware and the kernel.
  2488. **/
  2489. static int ixgbe_set_interrupt_capability(struct ixgbe_adapter *adapter)
  2490. {
  2491. int err = 0;
  2492. int vector, v_budget;
  2493. /*
  2494. * It's easy to be greedy for MSI-X vectors, but it really
  2495. * doesn't do us much good if we have a lot more vectors
  2496. * than CPU's. So let's be conservative and only ask for
  2497. * (roughly) twice the number of vectors as there are CPU's.
  2498. */
  2499. v_budget = min(adapter->num_rx_queues + adapter->num_tx_queues,
  2500. (int)(num_online_cpus() * 2)) + NON_Q_VECTORS;
  2501. /*
  2502. * At the same time, hardware can only support a maximum of
  2503. * MAX_MSIX_COUNT vectors. With features such as RSS and VMDq,
  2504. * we can easily reach upwards of 64 Rx descriptor queues and
  2505. * 32 Tx queues. Thus, we cap it off in those rare cases where
  2506. * the cpu count also exceeds our vector limit.
  2507. */
  2508. v_budget = min(v_budget, MAX_MSIX_COUNT);
  2509. /* A failure in MSI-X entry allocation isn't fatal, but it does
  2510. * mean we disable MSI-X capabilities of the adapter. */
  2511. adapter->msix_entries = kcalloc(v_budget,
  2512. sizeof(struct msix_entry), GFP_KERNEL);
  2513. if (!adapter->msix_entries) {
  2514. adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
  2515. adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
  2516. ixgbe_set_num_queues(adapter);
  2517. kfree(adapter->tx_ring);
  2518. kfree(adapter->rx_ring);
  2519. err = ixgbe_alloc_queues(adapter);
  2520. if (err) {
  2521. DPRINTK(PROBE, ERR, "Unable to allocate memory "
  2522. "for queues\n");
  2523. goto out;
  2524. }
  2525. goto try_msi;
  2526. }
  2527. for (vector = 0; vector < v_budget; vector++)
  2528. adapter->msix_entries[vector].entry = vector;
  2529. ixgbe_acquire_msix_vectors(adapter, v_budget);
  2530. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED)
  2531. goto out;
  2532. try_msi:
  2533. err = pci_enable_msi(adapter->pdev);
  2534. if (!err) {
  2535. adapter->flags |= IXGBE_FLAG_MSI_ENABLED;
  2536. } else {
  2537. DPRINTK(HW, DEBUG, "Unable to allocate MSI interrupt, "
  2538. "falling back to legacy. Error: %d\n", err);
  2539. /* reset err */
  2540. err = 0;
  2541. }
  2542. out:
  2543. /* Notify the stack of the (possibly) reduced Tx Queue count. */
  2544. adapter->netdev->real_num_tx_queues = adapter->num_tx_queues;
  2545. return err;
  2546. }
  2547. void ixgbe_reset_interrupt_capability(struct ixgbe_adapter *adapter)
  2548. {
  2549. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
  2550. adapter->flags &= ~IXGBE_FLAG_MSIX_ENABLED;
  2551. pci_disable_msix(adapter->pdev);
  2552. kfree(adapter->msix_entries);
  2553. adapter->msix_entries = NULL;
  2554. } else if (adapter->flags & IXGBE_FLAG_MSI_ENABLED) {
  2555. adapter->flags &= ~IXGBE_FLAG_MSI_ENABLED;
  2556. pci_disable_msi(adapter->pdev);
  2557. }
  2558. return;
  2559. }
  2560. /**
  2561. * ixgbe_init_interrupt_scheme - Determine proper interrupt scheme
  2562. * @adapter: board private structure to initialize
  2563. *
  2564. * We determine which interrupt scheme to use based on...
  2565. * - Kernel support (MSI, MSI-X)
  2566. * - which can be user-defined (via MODULE_PARAM)
  2567. * - Hardware queue count (num_*_queues)
  2568. * - defined by miscellaneous hardware support/features (RSS, etc.)
  2569. **/
  2570. int ixgbe_init_interrupt_scheme(struct ixgbe_adapter *adapter)
  2571. {
  2572. int err;
  2573. /* Number of supported queues */
  2574. ixgbe_set_num_queues(adapter);
  2575. err = ixgbe_alloc_queues(adapter);
  2576. if (err) {
  2577. DPRINTK(PROBE, ERR, "Unable to allocate memory for queues\n");
  2578. goto err_alloc_queues;
  2579. }
  2580. err = ixgbe_set_interrupt_capability(adapter);
  2581. if (err) {
  2582. DPRINTK(PROBE, ERR, "Unable to setup interrupt capabilities\n");
  2583. goto err_set_interrupt;
  2584. }
  2585. DPRINTK(DRV, INFO, "Multiqueue %s: Rx Queue count = %u, "
  2586. "Tx Queue count = %u\n",
  2587. (adapter->num_rx_queues > 1) ? "Enabled" :
  2588. "Disabled", adapter->num_rx_queues, adapter->num_tx_queues);
  2589. set_bit(__IXGBE_DOWN, &adapter->state);
  2590. return 0;
  2591. err_set_interrupt:
  2592. kfree(adapter->tx_ring);
  2593. kfree(adapter->rx_ring);
  2594. err_alloc_queues:
  2595. return err;
  2596. }
  2597. /**
  2598. * ixgbe_sfp_timer - worker thread to find a missing module
  2599. * @data: pointer to our adapter struct
  2600. **/
  2601. static void ixgbe_sfp_timer(unsigned long data)
  2602. {
  2603. struct ixgbe_adapter *adapter = (struct ixgbe_adapter *)data;
  2604. /* Do the sfp_timer outside of interrupt context due to the
  2605. * delays that sfp+ detection requires
  2606. */
  2607. schedule_work(&adapter->sfp_task);
  2608. }
  2609. /**
  2610. * ixgbe_sfp_task - worker thread to find a missing module
  2611. * @work: pointer to work_struct containing our data
  2612. **/
  2613. static void ixgbe_sfp_task(struct work_struct *work)
  2614. {
  2615. struct ixgbe_adapter *adapter = container_of(work,
  2616. struct ixgbe_adapter,
  2617. sfp_task);
  2618. struct ixgbe_hw *hw = &adapter->hw;
  2619. if ((hw->phy.type == ixgbe_phy_nl) &&
  2620. (hw->phy.sfp_type == ixgbe_sfp_type_not_present)) {
  2621. s32 ret = hw->phy.ops.identify_sfp(hw);
  2622. if (ret)
  2623. goto reschedule;
  2624. ret = hw->phy.ops.reset(hw);
  2625. if (ret == IXGBE_ERR_SFP_NOT_SUPPORTED) {
  2626. DPRINTK(PROBE, ERR, "failed to initialize because an "
  2627. "unsupported SFP+ module type was detected.\n"
  2628. "Reload the driver after installing a "
  2629. "supported module.\n");
  2630. unregister_netdev(adapter->netdev);
  2631. } else {
  2632. DPRINTK(PROBE, INFO, "detected SFP+: %d\n",
  2633. hw->phy.sfp_type);
  2634. }
  2635. /* don't need this routine any more */
  2636. clear_bit(__IXGBE_SFP_MODULE_NOT_FOUND, &adapter->state);
  2637. }
  2638. return;
  2639. reschedule:
  2640. if (test_bit(__IXGBE_SFP_MODULE_NOT_FOUND, &adapter->state))
  2641. mod_timer(&adapter->sfp_timer,
  2642. round_jiffies(jiffies + (2 * HZ)));
  2643. }
  2644. /**
  2645. * ixgbe_sw_init - Initialize general software structures (struct ixgbe_adapter)
  2646. * @adapter: board private structure to initialize
  2647. *
  2648. * ixgbe_sw_init initializes the Adapter private data structure.
  2649. * Fields are initialized based on PCI device information and
  2650. * OS network device settings (MTU size).
  2651. **/
  2652. static int __devinit ixgbe_sw_init(struct ixgbe_adapter *adapter)
  2653. {
  2654. struct ixgbe_hw *hw = &adapter->hw;
  2655. struct pci_dev *pdev = adapter->pdev;
  2656. unsigned int rss;
  2657. #ifdef CONFIG_IXGBE_DCB
  2658. int j;
  2659. struct tc_configuration *tc;
  2660. #endif
  2661. /* PCI config space info */
  2662. hw->vendor_id = pdev->vendor;
  2663. hw->device_id = pdev->device;
  2664. hw->revision_id = pdev->revision;
  2665. hw->subsystem_vendor_id = pdev->subsystem_vendor;
  2666. hw->subsystem_device_id = pdev->subsystem_device;
  2667. /* Set capability flags */
  2668. rss = min(IXGBE_MAX_RSS_INDICES, (int)num_online_cpus());
  2669. adapter->ring_feature[RING_F_RSS].indices = rss;
  2670. adapter->flags |= IXGBE_FLAG_RSS_ENABLED;
  2671. adapter->ring_feature[RING_F_DCB].indices = IXGBE_MAX_DCB_INDICES;
  2672. if (hw->mac.type == ixgbe_mac_82598EB)
  2673. adapter->max_msix_q_vectors = MAX_MSIX_Q_VECTORS_82598;
  2674. else if (hw->mac.type == ixgbe_mac_82599EB)
  2675. adapter->max_msix_q_vectors = MAX_MSIX_Q_VECTORS_82599;
  2676. #ifdef CONFIG_IXGBE_DCB
  2677. /* Configure DCB traffic classes */
  2678. for (j = 0; j < MAX_TRAFFIC_CLASS; j++) {
  2679. tc = &adapter->dcb_cfg.tc_config[j];
  2680. tc->path[DCB_TX_CONFIG].bwg_id = 0;
  2681. tc->path[DCB_TX_CONFIG].bwg_percent = 12 + (j & 1);
  2682. tc->path[DCB_RX_CONFIG].bwg_id = 0;
  2683. tc->path[DCB_RX_CONFIG].bwg_percent = 12 + (j & 1);
  2684. tc->dcb_pfc = pfc_disabled;
  2685. }
  2686. adapter->dcb_cfg.bw_percentage[DCB_TX_CONFIG][0] = 100;
  2687. adapter->dcb_cfg.bw_percentage[DCB_RX_CONFIG][0] = 100;
  2688. adapter->dcb_cfg.rx_pba_cfg = pba_equal;
  2689. adapter->dcb_cfg.round_robin_enable = false;
  2690. adapter->dcb_set_bitmap = 0x00;
  2691. ixgbe_copy_dcb_cfg(&adapter->dcb_cfg, &adapter->temp_dcb_cfg,
  2692. adapter->ring_feature[RING_F_DCB].indices);
  2693. #endif
  2694. /* default flow control settings */
  2695. hw->fc.requested_mode = ixgbe_fc_none;
  2696. hw->fc.high_water = IXGBE_DEFAULT_FCRTH;
  2697. hw->fc.low_water = IXGBE_DEFAULT_FCRTL;
  2698. hw->fc.pause_time = IXGBE_DEFAULT_FCPAUSE;
  2699. hw->fc.send_xon = true;
  2700. /* enable itr by default in dynamic mode */
  2701. adapter->itr_setting = 1;
  2702. adapter->eitr_param = 20000;
  2703. /* set defaults for eitr in MegaBytes */
  2704. adapter->eitr_low = 10;
  2705. adapter->eitr_high = 20;
  2706. /* set default ring sizes */
  2707. adapter->tx_ring_count = IXGBE_DEFAULT_TXD;
  2708. adapter->rx_ring_count = IXGBE_DEFAULT_RXD;
  2709. /* initialize eeprom parameters */
  2710. if (ixgbe_init_eeprom_params_generic(hw)) {
  2711. dev_err(&pdev->dev, "EEPROM initialization failed\n");
  2712. return -EIO;
  2713. }
  2714. /* enable rx csum by default */
  2715. adapter->flags |= IXGBE_FLAG_RX_CSUM_ENABLED;
  2716. set_bit(__IXGBE_DOWN, &adapter->state);
  2717. return 0;
  2718. }
  2719. /**
  2720. * ixgbe_setup_tx_resources - allocate Tx resources (Descriptors)
  2721. * @adapter: board private structure
  2722. * @tx_ring: tx descriptor ring (for a specific queue) to setup
  2723. *
  2724. * Return 0 on success, negative on failure
  2725. **/
  2726. int ixgbe_setup_tx_resources(struct ixgbe_adapter *adapter,
  2727. struct ixgbe_ring *tx_ring)
  2728. {
  2729. struct pci_dev *pdev = adapter->pdev;
  2730. int size;
  2731. size = sizeof(struct ixgbe_tx_buffer) * tx_ring->count;
  2732. tx_ring->tx_buffer_info = vmalloc(size);
  2733. if (!tx_ring->tx_buffer_info)
  2734. goto err;
  2735. memset(tx_ring->tx_buffer_info, 0, size);
  2736. /* round up to nearest 4K */
  2737. tx_ring->size = tx_ring->count * sizeof(union ixgbe_adv_tx_desc);
  2738. tx_ring->size = ALIGN(tx_ring->size, 4096);
  2739. tx_ring->desc = pci_alloc_consistent(pdev, tx_ring->size,
  2740. &tx_ring->dma);
  2741. if (!tx_ring->desc)
  2742. goto err;
  2743. tx_ring->next_to_use = 0;
  2744. tx_ring->next_to_clean = 0;
  2745. tx_ring->work_limit = tx_ring->count;
  2746. return 0;
  2747. err:
  2748. vfree(tx_ring->tx_buffer_info);
  2749. tx_ring->tx_buffer_info = NULL;
  2750. DPRINTK(PROBE, ERR, "Unable to allocate memory for the transmit "
  2751. "descriptor ring\n");
  2752. return -ENOMEM;
  2753. }
  2754. /**
  2755. * ixgbe_setup_all_tx_resources - allocate all queues Tx resources
  2756. * @adapter: board private structure
  2757. *
  2758. * If this function returns with an error, then it's possible one or
  2759. * more of the rings is populated (while the rest are not). It is the
  2760. * callers duty to clean those orphaned rings.
  2761. *
  2762. * Return 0 on success, negative on failure
  2763. **/
  2764. static int ixgbe_setup_all_tx_resources(struct ixgbe_adapter *adapter)
  2765. {
  2766. int i, err = 0;
  2767. for (i = 0; i < adapter->num_tx_queues; i++) {
  2768. err = ixgbe_setup_tx_resources(adapter, &adapter->tx_ring[i]);
  2769. if (!err)
  2770. continue;
  2771. DPRINTK(PROBE, ERR, "Allocation for Tx Queue %u failed\n", i);
  2772. break;
  2773. }
  2774. return err;
  2775. }
  2776. /**
  2777. * ixgbe_setup_rx_resources - allocate Rx resources (Descriptors)
  2778. * @adapter: board private structure
  2779. * @rx_ring: rx descriptor ring (for a specific queue) to setup
  2780. *
  2781. * Returns 0 on success, negative on failure
  2782. **/
  2783. int ixgbe_setup_rx_resources(struct ixgbe_adapter *adapter,
  2784. struct ixgbe_ring *rx_ring)
  2785. {
  2786. struct pci_dev *pdev = adapter->pdev;
  2787. int size;
  2788. size = sizeof(struct ixgbe_rx_buffer) * rx_ring->count;
  2789. rx_ring->rx_buffer_info = vmalloc(size);
  2790. if (!rx_ring->rx_buffer_info) {
  2791. DPRINTK(PROBE, ERR,
  2792. "vmalloc allocation failed for the rx desc ring\n");
  2793. goto alloc_failed;
  2794. }
  2795. memset(rx_ring->rx_buffer_info, 0, size);
  2796. /* Round up to nearest 4K */
  2797. rx_ring->size = rx_ring->count * sizeof(union ixgbe_adv_rx_desc);
  2798. rx_ring->size = ALIGN(rx_ring->size, 4096);
  2799. rx_ring->desc = pci_alloc_consistent(pdev, rx_ring->size, &rx_ring->dma);
  2800. if (!rx_ring->desc) {
  2801. DPRINTK(PROBE, ERR,
  2802. "Memory allocation failed for the rx desc ring\n");
  2803. vfree(rx_ring->rx_buffer_info);
  2804. goto alloc_failed;
  2805. }
  2806. rx_ring->next_to_clean = 0;
  2807. rx_ring->next_to_use = 0;
  2808. return 0;
  2809. alloc_failed:
  2810. return -ENOMEM;
  2811. }
  2812. /**
  2813. * ixgbe_setup_all_rx_resources - allocate all queues Rx resources
  2814. * @adapter: board private structure
  2815. *
  2816. * If this function returns with an error, then it's possible one or
  2817. * more of the rings is populated (while the rest are not). It is the
  2818. * callers duty to clean those orphaned rings.
  2819. *
  2820. * Return 0 on success, negative on failure
  2821. **/
  2822. static int ixgbe_setup_all_rx_resources(struct ixgbe_adapter *adapter)
  2823. {
  2824. int i, err = 0;
  2825. for (i = 0; i < adapter->num_rx_queues; i++) {
  2826. err = ixgbe_setup_rx_resources(adapter, &adapter->rx_ring[i]);
  2827. if (!err)
  2828. continue;
  2829. DPRINTK(PROBE, ERR, "Allocation for Rx Queue %u failed\n", i);
  2830. break;
  2831. }
  2832. return err;
  2833. }
  2834. /**
  2835. * ixgbe_free_tx_resources - Free Tx Resources per Queue
  2836. * @adapter: board private structure
  2837. * @tx_ring: Tx descriptor ring for a specific queue
  2838. *
  2839. * Free all transmit software resources
  2840. **/
  2841. void ixgbe_free_tx_resources(struct ixgbe_adapter *adapter,
  2842. struct ixgbe_ring *tx_ring)
  2843. {
  2844. struct pci_dev *pdev = adapter->pdev;
  2845. ixgbe_clean_tx_ring(adapter, tx_ring);
  2846. vfree(tx_ring->tx_buffer_info);
  2847. tx_ring->tx_buffer_info = NULL;
  2848. pci_free_consistent(pdev, tx_ring->size, tx_ring->desc, tx_ring->dma);
  2849. tx_ring->desc = NULL;
  2850. }
  2851. /**
  2852. * ixgbe_free_all_tx_resources - Free Tx Resources for All Queues
  2853. * @adapter: board private structure
  2854. *
  2855. * Free all transmit software resources
  2856. **/
  2857. static void ixgbe_free_all_tx_resources(struct ixgbe_adapter *adapter)
  2858. {
  2859. int i;
  2860. for (i = 0; i < adapter->num_tx_queues; i++)
  2861. ixgbe_free_tx_resources(adapter, &adapter->tx_ring[i]);
  2862. }
  2863. /**
  2864. * ixgbe_free_rx_resources - Free Rx Resources
  2865. * @adapter: board private structure
  2866. * @rx_ring: ring to clean the resources from
  2867. *
  2868. * Free all receive software resources
  2869. **/
  2870. void ixgbe_free_rx_resources(struct ixgbe_adapter *adapter,
  2871. struct ixgbe_ring *rx_ring)
  2872. {
  2873. struct pci_dev *pdev = adapter->pdev;
  2874. ixgbe_clean_rx_ring(adapter, rx_ring);
  2875. vfree(rx_ring->rx_buffer_info);
  2876. rx_ring->rx_buffer_info = NULL;
  2877. pci_free_consistent(pdev, rx_ring->size, rx_ring->desc, rx_ring->dma);
  2878. rx_ring->desc = NULL;
  2879. }
  2880. /**
  2881. * ixgbe_free_all_rx_resources - Free Rx Resources for All Queues
  2882. * @adapter: board private structure
  2883. *
  2884. * Free all receive software resources
  2885. **/
  2886. static void ixgbe_free_all_rx_resources(struct ixgbe_adapter *adapter)
  2887. {
  2888. int i;
  2889. for (i = 0; i < adapter->num_rx_queues; i++)
  2890. ixgbe_free_rx_resources(adapter, &adapter->rx_ring[i]);
  2891. }
  2892. /**
  2893. * ixgbe_change_mtu - Change the Maximum Transfer Unit
  2894. * @netdev: network interface device structure
  2895. * @new_mtu: new value for maximum frame size
  2896. *
  2897. * Returns 0 on success, negative on failure
  2898. **/
  2899. static int ixgbe_change_mtu(struct net_device *netdev, int new_mtu)
  2900. {
  2901. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  2902. int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
  2903. /* MTU < 68 is an error and causes problems on some kernels */
  2904. if ((new_mtu < 68) || (max_frame > IXGBE_MAX_JUMBO_FRAME_SIZE))
  2905. return -EINVAL;
  2906. DPRINTK(PROBE, INFO, "changing MTU from %d to %d\n",
  2907. netdev->mtu, new_mtu);
  2908. /* must set new MTU before calling down or up */
  2909. netdev->mtu = new_mtu;
  2910. if (netif_running(netdev))
  2911. ixgbe_reinit_locked(adapter);
  2912. return 0;
  2913. }
  2914. /**
  2915. * ixgbe_open - Called when a network interface is made active
  2916. * @netdev: network interface device structure
  2917. *
  2918. * Returns 0 on success, negative value on failure
  2919. *
  2920. * The open entry point is called when a network interface is made
  2921. * active by the system (IFF_UP). At this point all resources needed
  2922. * for transmit and receive operations are allocated, the interrupt
  2923. * handler is registered with the OS, the watchdog timer is started,
  2924. * and the stack is notified that the interface is ready.
  2925. **/
  2926. static int ixgbe_open(struct net_device *netdev)
  2927. {
  2928. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  2929. int err;
  2930. /* disallow open during test */
  2931. if (test_bit(__IXGBE_TESTING, &adapter->state))
  2932. return -EBUSY;
  2933. /* allocate transmit descriptors */
  2934. err = ixgbe_setup_all_tx_resources(adapter);
  2935. if (err)
  2936. goto err_setup_tx;
  2937. /* allocate receive descriptors */
  2938. err = ixgbe_setup_all_rx_resources(adapter);
  2939. if (err)
  2940. goto err_setup_rx;
  2941. ixgbe_configure(adapter);
  2942. err = ixgbe_request_irq(adapter);
  2943. if (err)
  2944. goto err_req_irq;
  2945. err = ixgbe_up_complete(adapter);
  2946. if (err)
  2947. goto err_up;
  2948. netif_tx_start_all_queues(netdev);
  2949. return 0;
  2950. err_up:
  2951. ixgbe_release_hw_control(adapter);
  2952. ixgbe_free_irq(adapter);
  2953. err_req_irq:
  2954. ixgbe_free_all_rx_resources(adapter);
  2955. err_setup_rx:
  2956. ixgbe_free_all_tx_resources(adapter);
  2957. err_setup_tx:
  2958. ixgbe_reset(adapter);
  2959. return err;
  2960. }
  2961. /**
  2962. * ixgbe_close - Disables a network interface
  2963. * @netdev: network interface device structure
  2964. *
  2965. * Returns 0, this is not allowed to fail
  2966. *
  2967. * The close entry point is called when an interface is de-activated
  2968. * by the OS. The hardware is still under the drivers control, but
  2969. * needs to be disabled. A global MAC reset is issued to stop the
  2970. * hardware, and all transmit and receive resources are freed.
  2971. **/
  2972. static int ixgbe_close(struct net_device *netdev)
  2973. {
  2974. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  2975. ixgbe_down(adapter);
  2976. ixgbe_free_irq(adapter);
  2977. ixgbe_free_all_tx_resources(adapter);
  2978. ixgbe_free_all_rx_resources(adapter);
  2979. ixgbe_release_hw_control(adapter);
  2980. return 0;
  2981. }
  2982. /**
  2983. * ixgbe_napi_add_all - prep napi structs for use
  2984. * @adapter: private struct
  2985. * helper function to napi_add each possible q_vector->napi
  2986. */
  2987. void ixgbe_napi_add_all(struct ixgbe_adapter *adapter)
  2988. {
  2989. int q_idx, q_vectors;
  2990. struct net_device *netdev = adapter->netdev;
  2991. int (*poll)(struct napi_struct *, int);
  2992. /* check if we already have our netdev->napi_list populated */
  2993. if (&netdev->napi_list != netdev->napi_list.next)
  2994. return;
  2995. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
  2996. poll = &ixgbe_clean_rxonly;
  2997. /* Only enable as many vectors as we have rx queues. */
  2998. q_vectors = adapter->num_rx_queues;
  2999. } else {
  3000. poll = &ixgbe_poll;
  3001. /* only one q_vector for legacy modes */
  3002. q_vectors = 1;
  3003. }
  3004. for (q_idx = 0; q_idx < q_vectors; q_idx++) {
  3005. struct ixgbe_q_vector *q_vector = &adapter->q_vector[q_idx];
  3006. netif_napi_add(adapter->netdev, &q_vector->napi, (*poll), 64);
  3007. }
  3008. }
  3009. void ixgbe_napi_del_all(struct ixgbe_adapter *adapter)
  3010. {
  3011. int q_idx;
  3012. int q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
  3013. /* legacy and MSI only use one vector */
  3014. if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED))
  3015. q_vectors = 1;
  3016. for (q_idx = 0; q_idx < q_vectors; q_idx++) {
  3017. struct ixgbe_q_vector *q_vector = &adapter->q_vector[q_idx];
  3018. if (!q_vector->rxr_count)
  3019. continue;
  3020. netif_napi_del(&q_vector->napi);
  3021. }
  3022. }
  3023. #ifdef CONFIG_PM
  3024. static int ixgbe_resume(struct pci_dev *pdev)
  3025. {
  3026. struct net_device *netdev = pci_get_drvdata(pdev);
  3027. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  3028. u32 err;
  3029. pci_set_power_state(pdev, PCI_D0);
  3030. pci_restore_state(pdev);
  3031. err = pci_enable_device(pdev);
  3032. if (err) {
  3033. printk(KERN_ERR "ixgbe: Cannot enable PCI device from "
  3034. "suspend\n");
  3035. return err;
  3036. }
  3037. pci_set_master(pdev);
  3038. pci_enable_wake(pdev, PCI_D3hot, 0);
  3039. pci_enable_wake(pdev, PCI_D3cold, 0);
  3040. err = ixgbe_init_interrupt_scheme(adapter);
  3041. if (err) {
  3042. printk(KERN_ERR "ixgbe: Cannot initialize interrupts for "
  3043. "device\n");
  3044. return err;
  3045. }
  3046. ixgbe_napi_add_all(adapter);
  3047. ixgbe_reset(adapter);
  3048. if (netif_running(netdev)) {
  3049. err = ixgbe_open(adapter->netdev);
  3050. if (err)
  3051. return err;
  3052. }
  3053. netif_device_attach(netdev);
  3054. return 0;
  3055. }
  3056. #endif /* CONFIG_PM */
  3057. static int ixgbe_suspend(struct pci_dev *pdev, pm_message_t state)
  3058. {
  3059. struct net_device *netdev = pci_get_drvdata(pdev);
  3060. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  3061. struct ixgbe_hw *hw = &adapter->hw;
  3062. u32 ctrl, fctrl;
  3063. u32 wufc = adapter->wol;
  3064. #ifdef CONFIG_PM
  3065. int retval = 0;
  3066. #endif
  3067. netif_device_detach(netdev);
  3068. if (netif_running(netdev)) {
  3069. ixgbe_down(adapter);
  3070. ixgbe_free_irq(adapter);
  3071. ixgbe_free_all_tx_resources(adapter);
  3072. ixgbe_free_all_rx_resources(adapter);
  3073. }
  3074. ixgbe_reset_interrupt_capability(adapter);
  3075. ixgbe_napi_del_all(adapter);
  3076. INIT_LIST_HEAD(&netdev->napi_list);
  3077. kfree(adapter->tx_ring);
  3078. kfree(adapter->rx_ring);
  3079. #ifdef CONFIG_PM
  3080. retval = pci_save_state(pdev);
  3081. if (retval)
  3082. return retval;
  3083. #endif
  3084. if (wufc) {
  3085. ixgbe_set_rx_mode(netdev);
  3086. /* turn on all-multi mode if wake on multicast is enabled */
  3087. if (wufc & IXGBE_WUFC_MC) {
  3088. fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
  3089. fctrl |= IXGBE_FCTRL_MPE;
  3090. IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
  3091. }
  3092. ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
  3093. ctrl |= IXGBE_CTRL_GIO_DIS;
  3094. IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl);
  3095. IXGBE_WRITE_REG(hw, IXGBE_WUFC, wufc);
  3096. } else {
  3097. IXGBE_WRITE_REG(hw, IXGBE_WUC, 0);
  3098. IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0);
  3099. }
  3100. if (wufc && hw->mac.type == ixgbe_mac_82599EB) {
  3101. pci_enable_wake(pdev, PCI_D3hot, 1);
  3102. pci_enable_wake(pdev, PCI_D3cold, 1);
  3103. } else {
  3104. pci_enable_wake(pdev, PCI_D3hot, 0);
  3105. pci_enable_wake(pdev, PCI_D3cold, 0);
  3106. }
  3107. ixgbe_release_hw_control(adapter);
  3108. pci_disable_device(pdev);
  3109. pci_set_power_state(pdev, pci_choose_state(pdev, state));
  3110. return 0;
  3111. }
  3112. static void ixgbe_shutdown(struct pci_dev *pdev)
  3113. {
  3114. ixgbe_suspend(pdev, PMSG_SUSPEND);
  3115. }
  3116. /**
  3117. * ixgbe_update_stats - Update the board statistics counters.
  3118. * @adapter: board private structure
  3119. **/
  3120. void ixgbe_update_stats(struct ixgbe_adapter *adapter)
  3121. {
  3122. struct ixgbe_hw *hw = &adapter->hw;
  3123. u64 total_mpc = 0;
  3124. u32 i, missed_rx = 0, mpc, bprc, lxon, lxoff, xon_off_tot;
  3125. adapter->stats.crcerrs += IXGBE_READ_REG(hw, IXGBE_CRCERRS);
  3126. for (i = 0; i < 8; i++) {
  3127. /* for packet buffers not used, the register should read 0 */
  3128. mpc = IXGBE_READ_REG(hw, IXGBE_MPC(i));
  3129. missed_rx += mpc;
  3130. adapter->stats.mpc[i] += mpc;
  3131. total_mpc += adapter->stats.mpc[i];
  3132. if (hw->mac.type == ixgbe_mac_82598EB)
  3133. adapter->stats.rnbc[i] += IXGBE_READ_REG(hw, IXGBE_RNBC(i));
  3134. adapter->stats.qptc[i] += IXGBE_READ_REG(hw, IXGBE_QPTC(i));
  3135. adapter->stats.qbtc[i] += IXGBE_READ_REG(hw, IXGBE_QBTC(i));
  3136. adapter->stats.qprc[i] += IXGBE_READ_REG(hw, IXGBE_QPRC(i));
  3137. adapter->stats.qbrc[i] += IXGBE_READ_REG(hw, IXGBE_QBRC(i));
  3138. if (hw->mac.type == ixgbe_mac_82599EB) {
  3139. adapter->stats.pxonrxc[i] += IXGBE_READ_REG(hw,
  3140. IXGBE_PXONRXCNT(i));
  3141. adapter->stats.pxoffrxc[i] += IXGBE_READ_REG(hw,
  3142. IXGBE_PXOFFRXCNT(i));
  3143. adapter->stats.qprdc[i] += IXGBE_READ_REG(hw, IXGBE_QPRDC(i));
  3144. adapter->hw_rx_no_dma_resources += adapter->stats.qprdc[i];
  3145. } else {
  3146. adapter->stats.pxonrxc[i] += IXGBE_READ_REG(hw,
  3147. IXGBE_PXONRXC(i));
  3148. adapter->stats.pxoffrxc[i] += IXGBE_READ_REG(hw,
  3149. IXGBE_PXOFFRXC(i));
  3150. }
  3151. adapter->stats.pxontxc[i] += IXGBE_READ_REG(hw,
  3152. IXGBE_PXONTXC(i));
  3153. adapter->stats.pxofftxc[i] += IXGBE_READ_REG(hw,
  3154. IXGBE_PXOFFTXC(i));
  3155. }
  3156. adapter->stats.gprc += IXGBE_READ_REG(hw, IXGBE_GPRC);
  3157. /* work around hardware counting issue */
  3158. adapter->stats.gprc -= missed_rx;
  3159. /* 82598 hardware only has a 32 bit counter in the high register */
  3160. if (hw->mac.type == ixgbe_mac_82599EB) {
  3161. adapter->stats.gorc += IXGBE_READ_REG(hw, IXGBE_GORCL);
  3162. IXGBE_READ_REG(hw, IXGBE_GORCH); /* to clear */
  3163. adapter->stats.gotc += IXGBE_READ_REG(hw, IXGBE_GOTCL);
  3164. IXGBE_READ_REG(hw, IXGBE_GOTCH); /* to clear */
  3165. adapter->stats.tor += IXGBE_READ_REG(hw, IXGBE_TORL);
  3166. IXGBE_READ_REG(hw, IXGBE_TORH); /* to clear */
  3167. adapter->stats.lxonrxc += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT);
  3168. adapter->stats.lxoffrxc += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT);
  3169. } else {
  3170. adapter->stats.lxonrxc += IXGBE_READ_REG(hw, IXGBE_LXONRXC);
  3171. adapter->stats.lxoffrxc += IXGBE_READ_REG(hw, IXGBE_LXOFFRXC);
  3172. adapter->stats.gorc += IXGBE_READ_REG(hw, IXGBE_GORCH);
  3173. adapter->stats.gotc += IXGBE_READ_REG(hw, IXGBE_GOTCH);
  3174. adapter->stats.tor += IXGBE_READ_REG(hw, IXGBE_TORH);
  3175. }
  3176. bprc = IXGBE_READ_REG(hw, IXGBE_BPRC);
  3177. adapter->stats.bprc += bprc;
  3178. adapter->stats.mprc += IXGBE_READ_REG(hw, IXGBE_MPRC);
  3179. if (hw->mac.type == ixgbe_mac_82598EB)
  3180. adapter->stats.mprc -= bprc;
  3181. adapter->stats.roc += IXGBE_READ_REG(hw, IXGBE_ROC);
  3182. adapter->stats.prc64 += IXGBE_READ_REG(hw, IXGBE_PRC64);
  3183. adapter->stats.prc127 += IXGBE_READ_REG(hw, IXGBE_PRC127);
  3184. adapter->stats.prc255 += IXGBE_READ_REG(hw, IXGBE_PRC255);
  3185. adapter->stats.prc511 += IXGBE_READ_REG(hw, IXGBE_PRC511);
  3186. adapter->stats.prc1023 += IXGBE_READ_REG(hw, IXGBE_PRC1023);
  3187. adapter->stats.prc1522 += IXGBE_READ_REG(hw, IXGBE_PRC1522);
  3188. adapter->stats.rlec += IXGBE_READ_REG(hw, IXGBE_RLEC);
  3189. lxon = IXGBE_READ_REG(hw, IXGBE_LXONTXC);
  3190. adapter->stats.lxontxc += lxon;
  3191. lxoff = IXGBE_READ_REG(hw, IXGBE_LXOFFTXC);
  3192. adapter->stats.lxofftxc += lxoff;
  3193. adapter->stats.ruc += IXGBE_READ_REG(hw, IXGBE_RUC);
  3194. adapter->stats.gptc += IXGBE_READ_REG(hw, IXGBE_GPTC);
  3195. adapter->stats.mptc += IXGBE_READ_REG(hw, IXGBE_MPTC);
  3196. /*
  3197. * 82598 errata - tx of flow control packets is included in tx counters
  3198. */
  3199. xon_off_tot = lxon + lxoff;
  3200. adapter->stats.gptc -= xon_off_tot;
  3201. adapter->stats.mptc -= xon_off_tot;
  3202. adapter->stats.gotc -= (xon_off_tot * (ETH_ZLEN + ETH_FCS_LEN));
  3203. adapter->stats.ruc += IXGBE_READ_REG(hw, IXGBE_RUC);
  3204. adapter->stats.rfc += IXGBE_READ_REG(hw, IXGBE_RFC);
  3205. adapter->stats.rjc += IXGBE_READ_REG(hw, IXGBE_RJC);
  3206. adapter->stats.tpr += IXGBE_READ_REG(hw, IXGBE_TPR);
  3207. adapter->stats.ptc64 += IXGBE_READ_REG(hw, IXGBE_PTC64);
  3208. adapter->stats.ptc64 -= xon_off_tot;
  3209. adapter->stats.ptc127 += IXGBE_READ_REG(hw, IXGBE_PTC127);
  3210. adapter->stats.ptc255 += IXGBE_READ_REG(hw, IXGBE_PTC255);
  3211. adapter->stats.ptc511 += IXGBE_READ_REG(hw, IXGBE_PTC511);
  3212. adapter->stats.ptc1023 += IXGBE_READ_REG(hw, IXGBE_PTC1023);
  3213. adapter->stats.ptc1522 += IXGBE_READ_REG(hw, IXGBE_PTC1522);
  3214. adapter->stats.bptc += IXGBE_READ_REG(hw, IXGBE_BPTC);
  3215. /* Fill out the OS statistics structure */
  3216. adapter->net_stats.multicast = adapter->stats.mprc;
  3217. /* Rx Errors */
  3218. adapter->net_stats.rx_errors = adapter->stats.crcerrs +
  3219. adapter->stats.rlec;
  3220. adapter->net_stats.rx_dropped = 0;
  3221. adapter->net_stats.rx_length_errors = adapter->stats.rlec;
  3222. adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
  3223. adapter->net_stats.rx_missed_errors = total_mpc;
  3224. }
  3225. /**
  3226. * ixgbe_watchdog - Timer Call-back
  3227. * @data: pointer to adapter cast into an unsigned long
  3228. **/
  3229. static void ixgbe_watchdog(unsigned long data)
  3230. {
  3231. struct ixgbe_adapter *adapter = (struct ixgbe_adapter *)data;
  3232. struct ixgbe_hw *hw = &adapter->hw;
  3233. /* Do the watchdog outside of interrupt context due to the lovely
  3234. * delays that some of the newer hardware requires */
  3235. if (!test_bit(__IXGBE_DOWN, &adapter->state)) {
  3236. /* Cause software interrupt to ensure rx rings are cleaned */
  3237. if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
  3238. u32 eics =
  3239. (1 << (adapter->num_msix_vectors - NON_Q_VECTORS)) - 1;
  3240. IXGBE_WRITE_REG(hw, IXGBE_EICS, eics);
  3241. } else {
  3242. /* For legacy and MSI interrupts don't set any bits that
  3243. * are enabled for EIAM, because this operation would
  3244. * set *both* EIMS and EICS for any bit in EIAM */
  3245. IXGBE_WRITE_REG(hw, IXGBE_EICS,
  3246. (IXGBE_EICS_TCP_TIMER | IXGBE_EICS_OTHER));
  3247. }
  3248. /* Reset the timer */
  3249. mod_timer(&adapter->watchdog_timer,
  3250. round_jiffies(jiffies + 2 * HZ));
  3251. }
  3252. schedule_work(&adapter->watchdog_task);
  3253. }
  3254. /**
  3255. * ixgbe_multispeed_fiber_task - worker thread to configure multispeed fiber
  3256. * @work: pointer to work_struct containing our data
  3257. **/
  3258. static void ixgbe_multispeed_fiber_task(struct work_struct *work)
  3259. {
  3260. struct ixgbe_adapter *adapter = container_of(work,
  3261. struct ixgbe_adapter,
  3262. multispeed_fiber_task);
  3263. struct ixgbe_hw *hw = &adapter->hw;
  3264. u32 autoneg;
  3265. adapter->flags |= IXGBE_FLAG_IN_SFP_LINK_TASK;
  3266. if (hw->mac.ops.get_link_capabilities)
  3267. hw->mac.ops.get_link_capabilities(hw, &autoneg,
  3268. &hw->mac.autoneg);
  3269. if (hw->mac.ops.setup_link_speed)
  3270. hw->mac.ops.setup_link_speed(hw, autoneg, true, true);
  3271. adapter->flags |= IXGBE_FLAG_NEED_LINK_UPDATE;
  3272. adapter->flags &= ~IXGBE_FLAG_IN_SFP_LINK_TASK;
  3273. }
  3274. /**
  3275. * ixgbe_sfp_config_module_task - worker thread to configure a new SFP+ module
  3276. * @work: pointer to work_struct containing our data
  3277. **/
  3278. static void ixgbe_sfp_config_module_task(struct work_struct *work)
  3279. {
  3280. struct ixgbe_adapter *adapter = container_of(work,
  3281. struct ixgbe_adapter,
  3282. sfp_config_module_task);
  3283. struct ixgbe_hw *hw = &adapter->hw;
  3284. u32 err;
  3285. adapter->flags |= IXGBE_FLAG_IN_SFP_MOD_TASK;
  3286. err = hw->phy.ops.identify_sfp(hw);
  3287. if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
  3288. DPRINTK(PROBE, ERR, "PHY not supported on this NIC %d\n", err);
  3289. ixgbe_down(adapter);
  3290. return;
  3291. }
  3292. hw->mac.ops.setup_sfp(hw);
  3293. if (!adapter->flags & IXGBE_FLAG_IN_SFP_LINK_TASK)
  3294. /* This will also work for DA Twinax connections */
  3295. schedule_work(&adapter->multispeed_fiber_task);
  3296. adapter->flags &= ~IXGBE_FLAG_IN_SFP_MOD_TASK;
  3297. }
  3298. /**
  3299. * ixgbe_watchdog_task - worker thread to bring link up
  3300. * @work: pointer to work_struct containing our data
  3301. **/
  3302. static void ixgbe_watchdog_task(struct work_struct *work)
  3303. {
  3304. struct ixgbe_adapter *adapter = container_of(work,
  3305. struct ixgbe_adapter,
  3306. watchdog_task);
  3307. struct net_device *netdev = adapter->netdev;
  3308. struct ixgbe_hw *hw = &adapter->hw;
  3309. u32 link_speed = adapter->link_speed;
  3310. bool link_up = adapter->link_up;
  3311. adapter->flags |= IXGBE_FLAG_IN_WATCHDOG_TASK;
  3312. if (adapter->flags & IXGBE_FLAG_NEED_LINK_UPDATE) {
  3313. hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
  3314. if (link_up ||
  3315. time_after(jiffies, (adapter->link_check_timeout +
  3316. IXGBE_TRY_LINK_TIMEOUT))) {
  3317. IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMC_LSC);
  3318. adapter->flags &= ~IXGBE_FLAG_NEED_LINK_UPDATE;
  3319. }
  3320. adapter->link_up = link_up;
  3321. adapter->link_speed = link_speed;
  3322. }
  3323. if (link_up) {
  3324. if (!netif_carrier_ok(netdev)) {
  3325. bool flow_rx, flow_tx;
  3326. if (hw->mac.type == ixgbe_mac_82599EB) {
  3327. u32 mflcn = IXGBE_READ_REG(hw, IXGBE_MFLCN);
  3328. u32 fccfg = IXGBE_READ_REG(hw, IXGBE_FCCFG);
  3329. flow_rx = (mflcn & IXGBE_MFLCN_RFCE);
  3330. flow_tx = (fccfg & IXGBE_FCCFG_TFCE_802_3X);
  3331. } else {
  3332. u32 frctl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
  3333. u32 rmcs = IXGBE_READ_REG(hw, IXGBE_RMCS);
  3334. flow_rx = (frctl & IXGBE_FCTRL_RFCE);
  3335. flow_tx = (rmcs & IXGBE_RMCS_TFCE_802_3X);
  3336. }
  3337. printk(KERN_INFO "ixgbe: %s NIC Link is Up %s, "
  3338. "Flow Control: %s\n",
  3339. netdev->name,
  3340. (link_speed == IXGBE_LINK_SPEED_10GB_FULL ?
  3341. "10 Gbps" :
  3342. (link_speed == IXGBE_LINK_SPEED_1GB_FULL ?
  3343. "1 Gbps" : "unknown speed")),
  3344. ((flow_rx && flow_tx) ? "RX/TX" :
  3345. (flow_rx ? "RX" :
  3346. (flow_tx ? "TX" : "None"))));
  3347. netif_carrier_on(netdev);
  3348. } else {
  3349. /* Force detection of hung controller */
  3350. adapter->detect_tx_hung = true;
  3351. }
  3352. } else {
  3353. adapter->link_up = false;
  3354. adapter->link_speed = 0;
  3355. if (netif_carrier_ok(netdev)) {
  3356. printk(KERN_INFO "ixgbe: %s NIC Link is Down\n",
  3357. netdev->name);
  3358. netif_carrier_off(netdev);
  3359. }
  3360. }
  3361. ixgbe_update_stats(adapter);
  3362. adapter->flags &= ~IXGBE_FLAG_IN_WATCHDOG_TASK;
  3363. }
  3364. static int ixgbe_tso(struct ixgbe_adapter *adapter,
  3365. struct ixgbe_ring *tx_ring, struct sk_buff *skb,
  3366. u32 tx_flags, u8 *hdr_len)
  3367. {
  3368. struct ixgbe_adv_tx_context_desc *context_desc;
  3369. unsigned int i;
  3370. int err;
  3371. struct ixgbe_tx_buffer *tx_buffer_info;
  3372. u32 vlan_macip_lens = 0, type_tucmd_mlhl;
  3373. u32 mss_l4len_idx, l4len;
  3374. if (skb_is_gso(skb)) {
  3375. if (skb_header_cloned(skb)) {
  3376. err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
  3377. if (err)
  3378. return err;
  3379. }
  3380. l4len = tcp_hdrlen(skb);
  3381. *hdr_len += l4len;
  3382. if (skb->protocol == htons(ETH_P_IP)) {
  3383. struct iphdr *iph = ip_hdr(skb);
  3384. iph->tot_len = 0;
  3385. iph->check = 0;
  3386. tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
  3387. iph->daddr, 0,
  3388. IPPROTO_TCP,
  3389. 0);
  3390. adapter->hw_tso_ctxt++;
  3391. } else if (skb_shinfo(skb)->gso_type == SKB_GSO_TCPV6) {
  3392. ipv6_hdr(skb)->payload_len = 0;
  3393. tcp_hdr(skb)->check =
  3394. ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
  3395. &ipv6_hdr(skb)->daddr,
  3396. 0, IPPROTO_TCP, 0);
  3397. adapter->hw_tso6_ctxt++;
  3398. }
  3399. i = tx_ring->next_to_use;
  3400. tx_buffer_info = &tx_ring->tx_buffer_info[i];
  3401. context_desc = IXGBE_TX_CTXTDESC_ADV(*tx_ring, i);
  3402. /* VLAN MACLEN IPLEN */
  3403. if (tx_flags & IXGBE_TX_FLAGS_VLAN)
  3404. vlan_macip_lens |=
  3405. (tx_flags & IXGBE_TX_FLAGS_VLAN_MASK);
  3406. vlan_macip_lens |= ((skb_network_offset(skb)) <<
  3407. IXGBE_ADVTXD_MACLEN_SHIFT);
  3408. *hdr_len += skb_network_offset(skb);
  3409. vlan_macip_lens |=
  3410. (skb_transport_header(skb) - skb_network_header(skb));
  3411. *hdr_len +=
  3412. (skb_transport_header(skb) - skb_network_header(skb));
  3413. context_desc->vlan_macip_lens = cpu_to_le32(vlan_macip_lens);
  3414. context_desc->seqnum_seed = 0;
  3415. /* ADV DTYP TUCMD MKRLOC/ISCSIHEDLEN */
  3416. type_tucmd_mlhl = (IXGBE_TXD_CMD_DEXT |
  3417. IXGBE_ADVTXD_DTYP_CTXT);
  3418. if (skb->protocol == htons(ETH_P_IP))
  3419. type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_IPV4;
  3420. type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_L4T_TCP;
  3421. context_desc->type_tucmd_mlhl = cpu_to_le32(type_tucmd_mlhl);
  3422. /* MSS L4LEN IDX */
  3423. mss_l4len_idx =
  3424. (skb_shinfo(skb)->gso_size << IXGBE_ADVTXD_MSS_SHIFT);
  3425. mss_l4len_idx |= (l4len << IXGBE_ADVTXD_L4LEN_SHIFT);
  3426. /* use index 1 for TSO */
  3427. mss_l4len_idx |= (1 << IXGBE_ADVTXD_IDX_SHIFT);
  3428. context_desc->mss_l4len_idx = cpu_to_le32(mss_l4len_idx);
  3429. tx_buffer_info->time_stamp = jiffies;
  3430. tx_buffer_info->next_to_watch = i;
  3431. i++;
  3432. if (i == tx_ring->count)
  3433. i = 0;
  3434. tx_ring->next_to_use = i;
  3435. return true;
  3436. }
  3437. return false;
  3438. }
  3439. static bool ixgbe_tx_csum(struct ixgbe_adapter *adapter,
  3440. struct ixgbe_ring *tx_ring,
  3441. struct sk_buff *skb, u32 tx_flags)
  3442. {
  3443. struct ixgbe_adv_tx_context_desc *context_desc;
  3444. unsigned int i;
  3445. struct ixgbe_tx_buffer *tx_buffer_info;
  3446. u32 vlan_macip_lens = 0, type_tucmd_mlhl = 0;
  3447. if (skb->ip_summed == CHECKSUM_PARTIAL ||
  3448. (tx_flags & IXGBE_TX_FLAGS_VLAN)) {
  3449. i = tx_ring->next_to_use;
  3450. tx_buffer_info = &tx_ring->tx_buffer_info[i];
  3451. context_desc = IXGBE_TX_CTXTDESC_ADV(*tx_ring, i);
  3452. if (tx_flags & IXGBE_TX_FLAGS_VLAN)
  3453. vlan_macip_lens |=
  3454. (tx_flags & IXGBE_TX_FLAGS_VLAN_MASK);
  3455. vlan_macip_lens |= (skb_network_offset(skb) <<
  3456. IXGBE_ADVTXD_MACLEN_SHIFT);
  3457. if (skb->ip_summed == CHECKSUM_PARTIAL)
  3458. vlan_macip_lens |= (skb_transport_header(skb) -
  3459. skb_network_header(skb));
  3460. context_desc->vlan_macip_lens = cpu_to_le32(vlan_macip_lens);
  3461. context_desc->seqnum_seed = 0;
  3462. type_tucmd_mlhl |= (IXGBE_TXD_CMD_DEXT |
  3463. IXGBE_ADVTXD_DTYP_CTXT);
  3464. if (skb->ip_summed == CHECKSUM_PARTIAL) {
  3465. switch (skb->protocol) {
  3466. case cpu_to_be16(ETH_P_IP):
  3467. type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_IPV4;
  3468. if (ip_hdr(skb)->protocol == IPPROTO_TCP)
  3469. type_tucmd_mlhl |=
  3470. IXGBE_ADVTXD_TUCMD_L4T_TCP;
  3471. break;
  3472. case cpu_to_be16(ETH_P_IPV6):
  3473. /* XXX what about other V6 headers?? */
  3474. if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
  3475. type_tucmd_mlhl |=
  3476. IXGBE_ADVTXD_TUCMD_L4T_TCP;
  3477. break;
  3478. default:
  3479. if (unlikely(net_ratelimit())) {
  3480. DPRINTK(PROBE, WARNING,
  3481. "partial checksum but proto=%x!\n",
  3482. skb->protocol);
  3483. }
  3484. break;
  3485. }
  3486. }
  3487. context_desc->type_tucmd_mlhl = cpu_to_le32(type_tucmd_mlhl);
  3488. /* use index zero for tx checksum offload */
  3489. context_desc->mss_l4len_idx = 0;
  3490. tx_buffer_info->time_stamp = jiffies;
  3491. tx_buffer_info->next_to_watch = i;
  3492. adapter->hw_csum_tx_good++;
  3493. i++;
  3494. if (i == tx_ring->count)
  3495. i = 0;
  3496. tx_ring->next_to_use = i;
  3497. return true;
  3498. }
  3499. return false;
  3500. }
  3501. static int ixgbe_tx_map(struct ixgbe_adapter *adapter,
  3502. struct ixgbe_ring *tx_ring,
  3503. struct sk_buff *skb, unsigned int first)
  3504. {
  3505. struct ixgbe_tx_buffer *tx_buffer_info;
  3506. unsigned int len = skb->len;
  3507. unsigned int offset = 0, size, count = 0, i;
  3508. unsigned int nr_frags = skb_shinfo(skb)->nr_frags;
  3509. unsigned int f;
  3510. len -= skb->data_len;
  3511. i = tx_ring->next_to_use;
  3512. while (len) {
  3513. tx_buffer_info = &tx_ring->tx_buffer_info[i];
  3514. size = min(len, (uint)IXGBE_MAX_DATA_PER_TXD);
  3515. tx_buffer_info->length = size;
  3516. tx_buffer_info->dma = pci_map_single(adapter->pdev,
  3517. skb->data + offset,
  3518. size, PCI_DMA_TODEVICE);
  3519. tx_buffer_info->time_stamp = jiffies;
  3520. tx_buffer_info->next_to_watch = i;
  3521. len -= size;
  3522. offset += size;
  3523. count++;
  3524. i++;
  3525. if (i == tx_ring->count)
  3526. i = 0;
  3527. }
  3528. for (f = 0; f < nr_frags; f++) {
  3529. struct skb_frag_struct *frag;
  3530. frag = &skb_shinfo(skb)->frags[f];
  3531. len = frag->size;
  3532. offset = frag->page_offset;
  3533. while (len) {
  3534. tx_buffer_info = &tx_ring->tx_buffer_info[i];
  3535. size = min(len, (uint)IXGBE_MAX_DATA_PER_TXD);
  3536. tx_buffer_info->length = size;
  3537. tx_buffer_info->dma = pci_map_page(adapter->pdev,
  3538. frag->page,
  3539. offset,
  3540. size,
  3541. PCI_DMA_TODEVICE);
  3542. tx_buffer_info->time_stamp = jiffies;
  3543. tx_buffer_info->next_to_watch = i;
  3544. len -= size;
  3545. offset += size;
  3546. count++;
  3547. i++;
  3548. if (i == tx_ring->count)
  3549. i = 0;
  3550. }
  3551. }
  3552. if (i == 0)
  3553. i = tx_ring->count - 1;
  3554. else
  3555. i = i - 1;
  3556. tx_ring->tx_buffer_info[i].skb = skb;
  3557. tx_ring->tx_buffer_info[first].next_to_watch = i;
  3558. return count;
  3559. }
  3560. static void ixgbe_tx_queue(struct ixgbe_adapter *adapter,
  3561. struct ixgbe_ring *tx_ring,
  3562. int tx_flags, int count, u32 paylen, u8 hdr_len)
  3563. {
  3564. union ixgbe_adv_tx_desc *tx_desc = NULL;
  3565. struct ixgbe_tx_buffer *tx_buffer_info;
  3566. u32 olinfo_status = 0, cmd_type_len = 0;
  3567. unsigned int i;
  3568. u32 txd_cmd = IXGBE_TXD_CMD_EOP | IXGBE_TXD_CMD_RS | IXGBE_TXD_CMD_IFCS;
  3569. cmd_type_len |= IXGBE_ADVTXD_DTYP_DATA;
  3570. cmd_type_len |= IXGBE_ADVTXD_DCMD_IFCS | IXGBE_ADVTXD_DCMD_DEXT;
  3571. if (tx_flags & IXGBE_TX_FLAGS_VLAN)
  3572. cmd_type_len |= IXGBE_ADVTXD_DCMD_VLE;
  3573. if (tx_flags & IXGBE_TX_FLAGS_TSO) {
  3574. cmd_type_len |= IXGBE_ADVTXD_DCMD_TSE;
  3575. olinfo_status |= IXGBE_TXD_POPTS_TXSM <<
  3576. IXGBE_ADVTXD_POPTS_SHIFT;
  3577. /* use index 1 context for tso */
  3578. olinfo_status |= (1 << IXGBE_ADVTXD_IDX_SHIFT);
  3579. if (tx_flags & IXGBE_TX_FLAGS_IPV4)
  3580. olinfo_status |= IXGBE_TXD_POPTS_IXSM <<
  3581. IXGBE_ADVTXD_POPTS_SHIFT;
  3582. } else if (tx_flags & IXGBE_TX_FLAGS_CSUM)
  3583. olinfo_status |= IXGBE_TXD_POPTS_TXSM <<
  3584. IXGBE_ADVTXD_POPTS_SHIFT;
  3585. olinfo_status |= ((paylen - hdr_len) << IXGBE_ADVTXD_PAYLEN_SHIFT);
  3586. i = tx_ring->next_to_use;
  3587. while (count--) {
  3588. tx_buffer_info = &tx_ring->tx_buffer_info[i];
  3589. tx_desc = IXGBE_TX_DESC_ADV(*tx_ring, i);
  3590. tx_desc->read.buffer_addr = cpu_to_le64(tx_buffer_info->dma);
  3591. tx_desc->read.cmd_type_len =
  3592. cpu_to_le32(cmd_type_len | tx_buffer_info->length);
  3593. tx_desc->read.olinfo_status = cpu_to_le32(olinfo_status);
  3594. i++;
  3595. if (i == tx_ring->count)
  3596. i = 0;
  3597. }
  3598. tx_desc->read.cmd_type_len |= cpu_to_le32(txd_cmd);
  3599. /*
  3600. * Force memory writes to complete before letting h/w
  3601. * know there are new descriptors to fetch. (Only
  3602. * applicable for weak-ordered memory model archs,
  3603. * such as IA-64).
  3604. */
  3605. wmb();
  3606. tx_ring->next_to_use = i;
  3607. writel(i, adapter->hw.hw_addr + tx_ring->tail);
  3608. }
  3609. static int __ixgbe_maybe_stop_tx(struct net_device *netdev,
  3610. struct ixgbe_ring *tx_ring, int size)
  3611. {
  3612. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  3613. netif_stop_subqueue(netdev, tx_ring->queue_index);
  3614. /* Herbert's original patch had:
  3615. * smp_mb__after_netif_stop_queue();
  3616. * but since that doesn't exist yet, just open code it. */
  3617. smp_mb();
  3618. /* We need to check again in a case another CPU has just
  3619. * made room available. */
  3620. if (likely(IXGBE_DESC_UNUSED(tx_ring) < size))
  3621. return -EBUSY;
  3622. /* A reprieve! - use start_queue because it doesn't call schedule */
  3623. netif_start_subqueue(netdev, tx_ring->queue_index);
  3624. ++adapter->restart_queue;
  3625. return 0;
  3626. }
  3627. static int ixgbe_maybe_stop_tx(struct net_device *netdev,
  3628. struct ixgbe_ring *tx_ring, int size)
  3629. {
  3630. if (likely(IXGBE_DESC_UNUSED(tx_ring) >= size))
  3631. return 0;
  3632. return __ixgbe_maybe_stop_tx(netdev, tx_ring, size);
  3633. }
  3634. static int ixgbe_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
  3635. {
  3636. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  3637. struct ixgbe_ring *tx_ring;
  3638. unsigned int first;
  3639. unsigned int tx_flags = 0;
  3640. u8 hdr_len = 0;
  3641. int r_idx = 0, tso;
  3642. int count = 0;
  3643. unsigned int f;
  3644. r_idx = (adapter->num_tx_queues - 1) & skb->queue_mapping;
  3645. tx_ring = &adapter->tx_ring[r_idx];
  3646. if (adapter->vlgrp && vlan_tx_tag_present(skb)) {
  3647. tx_flags |= vlan_tx_tag_get(skb);
  3648. if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
  3649. tx_flags &= ~IXGBE_TX_FLAGS_VLAN_PRIO_MASK;
  3650. tx_flags |= (skb->queue_mapping << 13);
  3651. }
  3652. tx_flags <<= IXGBE_TX_FLAGS_VLAN_SHIFT;
  3653. tx_flags |= IXGBE_TX_FLAGS_VLAN;
  3654. } else if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
  3655. tx_flags |= (skb->queue_mapping << 13);
  3656. tx_flags <<= IXGBE_TX_FLAGS_VLAN_SHIFT;
  3657. tx_flags |= IXGBE_TX_FLAGS_VLAN;
  3658. }
  3659. /* three things can cause us to need a context descriptor */
  3660. if (skb_is_gso(skb) ||
  3661. (skb->ip_summed == CHECKSUM_PARTIAL) ||
  3662. (tx_flags & IXGBE_TX_FLAGS_VLAN))
  3663. count++;
  3664. count += TXD_USE_COUNT(skb_headlen(skb));
  3665. for (f = 0; f < skb_shinfo(skb)->nr_frags; f++)
  3666. count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size);
  3667. if (ixgbe_maybe_stop_tx(netdev, tx_ring, count)) {
  3668. adapter->tx_busy++;
  3669. return NETDEV_TX_BUSY;
  3670. }
  3671. if (skb->protocol == htons(ETH_P_IP))
  3672. tx_flags |= IXGBE_TX_FLAGS_IPV4;
  3673. first = tx_ring->next_to_use;
  3674. tso = ixgbe_tso(adapter, tx_ring, skb, tx_flags, &hdr_len);
  3675. if (tso < 0) {
  3676. dev_kfree_skb_any(skb);
  3677. return NETDEV_TX_OK;
  3678. }
  3679. if (tso)
  3680. tx_flags |= IXGBE_TX_FLAGS_TSO;
  3681. else if (ixgbe_tx_csum(adapter, tx_ring, skb, tx_flags) &&
  3682. (skb->ip_summed == CHECKSUM_PARTIAL))
  3683. tx_flags |= IXGBE_TX_FLAGS_CSUM;
  3684. ixgbe_tx_queue(adapter, tx_ring, tx_flags,
  3685. ixgbe_tx_map(adapter, tx_ring, skb, first),
  3686. skb->len, hdr_len);
  3687. netdev->trans_start = jiffies;
  3688. ixgbe_maybe_stop_tx(netdev, tx_ring, DESC_NEEDED);
  3689. return NETDEV_TX_OK;
  3690. }
  3691. /**
  3692. * ixgbe_get_stats - Get System Network Statistics
  3693. * @netdev: network interface device structure
  3694. *
  3695. * Returns the address of the device statistics structure.
  3696. * The statistics are actually updated from the timer callback.
  3697. **/
  3698. static struct net_device_stats *ixgbe_get_stats(struct net_device *netdev)
  3699. {
  3700. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  3701. /* only return the current stats */
  3702. return &adapter->net_stats;
  3703. }
  3704. /**
  3705. * ixgbe_set_mac - Change the Ethernet Address of the NIC
  3706. * @netdev: network interface device structure
  3707. * @p: pointer to an address structure
  3708. *
  3709. * Returns 0 on success, negative on failure
  3710. **/
  3711. static int ixgbe_set_mac(struct net_device *netdev, void *p)
  3712. {
  3713. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  3714. struct ixgbe_hw *hw = &adapter->hw;
  3715. struct sockaddr *addr = p;
  3716. if (!is_valid_ether_addr(addr->sa_data))
  3717. return -EADDRNOTAVAIL;
  3718. memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
  3719. memcpy(hw->mac.addr, addr->sa_data, netdev->addr_len);
  3720. hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
  3721. return 0;
  3722. }
  3723. #ifdef CONFIG_NET_POLL_CONTROLLER
  3724. /*
  3725. * Polling 'interrupt' - used by things like netconsole to send skbs
  3726. * without having to re-enable interrupts. It's not called while
  3727. * the interrupt routine is executing.
  3728. */
  3729. static void ixgbe_netpoll(struct net_device *netdev)
  3730. {
  3731. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  3732. disable_irq(adapter->pdev->irq);
  3733. adapter->flags |= IXGBE_FLAG_IN_NETPOLL;
  3734. ixgbe_intr(adapter->pdev->irq, netdev);
  3735. adapter->flags &= ~IXGBE_FLAG_IN_NETPOLL;
  3736. enable_irq(adapter->pdev->irq);
  3737. }
  3738. #endif
  3739. static const struct net_device_ops ixgbe_netdev_ops = {
  3740. .ndo_open = ixgbe_open,
  3741. .ndo_stop = ixgbe_close,
  3742. .ndo_start_xmit = ixgbe_xmit_frame,
  3743. .ndo_get_stats = ixgbe_get_stats,
  3744. .ndo_set_multicast_list = ixgbe_set_rx_mode,
  3745. .ndo_validate_addr = eth_validate_addr,
  3746. .ndo_set_mac_address = ixgbe_set_mac,
  3747. .ndo_change_mtu = ixgbe_change_mtu,
  3748. .ndo_tx_timeout = ixgbe_tx_timeout,
  3749. .ndo_vlan_rx_register = ixgbe_vlan_rx_register,
  3750. .ndo_vlan_rx_add_vid = ixgbe_vlan_rx_add_vid,
  3751. .ndo_vlan_rx_kill_vid = ixgbe_vlan_rx_kill_vid,
  3752. #ifdef CONFIG_NET_POLL_CONTROLLER
  3753. .ndo_poll_controller = ixgbe_netpoll,
  3754. #endif
  3755. };
  3756. /**
  3757. * ixgbe_probe - Device Initialization Routine
  3758. * @pdev: PCI device information struct
  3759. * @ent: entry in ixgbe_pci_tbl
  3760. *
  3761. * Returns 0 on success, negative on failure
  3762. *
  3763. * ixgbe_probe initializes an adapter identified by a pci_dev structure.
  3764. * The OS initialization, configuring of the adapter private structure,
  3765. * and a hardware reset occur.
  3766. **/
  3767. static int __devinit ixgbe_probe(struct pci_dev *pdev,
  3768. const struct pci_device_id *ent)
  3769. {
  3770. struct net_device *netdev;
  3771. struct ixgbe_adapter *adapter = NULL;
  3772. struct ixgbe_hw *hw;
  3773. const struct ixgbe_info *ii = ixgbe_info_tbl[ent->driver_data];
  3774. static int cards_found;
  3775. int i, err, pci_using_dac;
  3776. u16 pm_value = 0;
  3777. u32 part_num, eec;
  3778. err = pci_enable_device(pdev);
  3779. if (err)
  3780. return err;
  3781. if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK) &&
  3782. !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
  3783. pci_using_dac = 1;
  3784. } else {
  3785. err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
  3786. if (err) {
  3787. err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
  3788. if (err) {
  3789. dev_err(&pdev->dev, "No usable DMA "
  3790. "configuration, aborting\n");
  3791. goto err_dma;
  3792. }
  3793. }
  3794. pci_using_dac = 0;
  3795. }
  3796. err = pci_request_regions(pdev, ixgbe_driver_name);
  3797. if (err) {
  3798. dev_err(&pdev->dev, "pci_request_regions failed 0x%x\n", err);
  3799. goto err_pci_reg;
  3800. }
  3801. err = pci_enable_pcie_error_reporting(pdev);
  3802. if (err) {
  3803. dev_err(&pdev->dev, "pci_enable_pcie_error_reporting failed "
  3804. "0x%x\n", err);
  3805. /* non-fatal, continue */
  3806. }
  3807. pci_set_master(pdev);
  3808. pci_save_state(pdev);
  3809. netdev = alloc_etherdev_mq(sizeof(struct ixgbe_adapter), MAX_TX_QUEUES);
  3810. if (!netdev) {
  3811. err = -ENOMEM;
  3812. goto err_alloc_etherdev;
  3813. }
  3814. SET_NETDEV_DEV(netdev, &pdev->dev);
  3815. pci_set_drvdata(pdev, netdev);
  3816. adapter = netdev_priv(netdev);
  3817. adapter->netdev = netdev;
  3818. adapter->pdev = pdev;
  3819. hw = &adapter->hw;
  3820. hw->back = adapter;
  3821. adapter->msg_enable = (1 << DEFAULT_DEBUG_LEVEL_SHIFT) - 1;
  3822. hw->hw_addr = ioremap(pci_resource_start(pdev, 0),
  3823. pci_resource_len(pdev, 0));
  3824. if (!hw->hw_addr) {
  3825. err = -EIO;
  3826. goto err_ioremap;
  3827. }
  3828. for (i = 1; i <= 5; i++) {
  3829. if (pci_resource_len(pdev, i) == 0)
  3830. continue;
  3831. }
  3832. netdev->netdev_ops = &ixgbe_netdev_ops;
  3833. ixgbe_set_ethtool_ops(netdev);
  3834. netdev->watchdog_timeo = 5 * HZ;
  3835. strcpy(netdev->name, pci_name(pdev));
  3836. adapter->bd_number = cards_found;
  3837. /* Setup hw api */
  3838. memcpy(&hw->mac.ops, ii->mac_ops, sizeof(hw->mac.ops));
  3839. hw->mac.type = ii->mac;
  3840. /* EEPROM */
  3841. memcpy(&hw->eeprom.ops, ii->eeprom_ops, sizeof(hw->eeprom.ops));
  3842. eec = IXGBE_READ_REG(hw, IXGBE_EEC);
  3843. /* If EEPROM is valid (bit 8 = 1), use default otherwise use bit bang */
  3844. if (!(eec & (1 << 8)))
  3845. hw->eeprom.ops.read = &ixgbe_read_eeprom_bit_bang_generic;
  3846. /* PHY */
  3847. memcpy(&hw->phy.ops, ii->phy_ops, sizeof(hw->phy.ops));
  3848. hw->phy.sfp_type = ixgbe_sfp_type_unknown;
  3849. /* set up this timer and work struct before calling get_invariants
  3850. * which might start the timer
  3851. */
  3852. init_timer(&adapter->sfp_timer);
  3853. adapter->sfp_timer.function = &ixgbe_sfp_timer;
  3854. adapter->sfp_timer.data = (unsigned long) adapter;
  3855. INIT_WORK(&adapter->sfp_task, ixgbe_sfp_task);
  3856. /* multispeed fiber has its own tasklet, called from GPI SDP1 context */
  3857. INIT_WORK(&adapter->multispeed_fiber_task, ixgbe_multispeed_fiber_task);
  3858. /* a new SFP+ module arrival, called from GPI SDP2 context */
  3859. INIT_WORK(&adapter->sfp_config_module_task,
  3860. ixgbe_sfp_config_module_task);
  3861. err = ii->get_invariants(hw);
  3862. if (err == IXGBE_ERR_SFP_NOT_PRESENT) {
  3863. /* start a kernel thread to watch for a module to arrive */
  3864. set_bit(__IXGBE_SFP_MODULE_NOT_FOUND, &adapter->state);
  3865. mod_timer(&adapter->sfp_timer,
  3866. round_jiffies(jiffies + (2 * HZ)));
  3867. err = 0;
  3868. } else if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
  3869. DPRINTK(PROBE, ERR, "failed to load because an "
  3870. "unsupported SFP+ module type was detected.\n");
  3871. goto err_hw_init;
  3872. } else if (err) {
  3873. goto err_hw_init;
  3874. }
  3875. /* setup the private structure */
  3876. err = ixgbe_sw_init(adapter);
  3877. if (err)
  3878. goto err_sw_init;
  3879. /* reset_hw fills in the perm_addr as well */
  3880. err = hw->mac.ops.reset_hw(hw);
  3881. if (err) {
  3882. dev_err(&adapter->pdev->dev, "HW Init failed: %d\n", err);
  3883. goto err_sw_init;
  3884. }
  3885. netdev->features = NETIF_F_SG |
  3886. NETIF_F_IP_CSUM |
  3887. NETIF_F_HW_VLAN_TX |
  3888. NETIF_F_HW_VLAN_RX |
  3889. NETIF_F_HW_VLAN_FILTER;
  3890. netdev->features |= NETIF_F_IPV6_CSUM;
  3891. netdev->features |= NETIF_F_TSO;
  3892. netdev->features |= NETIF_F_TSO6;
  3893. netdev->features |= NETIF_F_GRO;
  3894. netdev->vlan_features |= NETIF_F_TSO;
  3895. netdev->vlan_features |= NETIF_F_TSO6;
  3896. netdev->vlan_features |= NETIF_F_IP_CSUM;
  3897. netdev->vlan_features |= NETIF_F_SG;
  3898. if (adapter->flags & IXGBE_FLAG_DCB_ENABLED)
  3899. adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
  3900. #ifdef CONFIG_IXGBE_DCB
  3901. netdev->dcbnl_ops = &dcbnl_ops;
  3902. #endif
  3903. if (pci_using_dac)
  3904. netdev->features |= NETIF_F_HIGHDMA;
  3905. /* make sure the EEPROM is good */
  3906. if (hw->eeprom.ops.validate_checksum(hw, NULL) < 0) {
  3907. dev_err(&pdev->dev, "The EEPROM Checksum Is Not Valid\n");
  3908. err = -EIO;
  3909. goto err_eeprom;
  3910. }
  3911. memcpy(netdev->dev_addr, hw->mac.perm_addr, netdev->addr_len);
  3912. memcpy(netdev->perm_addr, hw->mac.perm_addr, netdev->addr_len);
  3913. if (ixgbe_validate_mac_addr(netdev->perm_addr)) {
  3914. dev_err(&pdev->dev, "invalid MAC address\n");
  3915. err = -EIO;
  3916. goto err_eeprom;
  3917. }
  3918. init_timer(&adapter->watchdog_timer);
  3919. adapter->watchdog_timer.function = &ixgbe_watchdog;
  3920. adapter->watchdog_timer.data = (unsigned long)adapter;
  3921. INIT_WORK(&adapter->reset_task, ixgbe_reset_task);
  3922. INIT_WORK(&adapter->watchdog_task, ixgbe_watchdog_task);
  3923. err = ixgbe_init_interrupt_scheme(adapter);
  3924. if (err)
  3925. goto err_sw_init;
  3926. switch (pdev->device) {
  3927. case IXGBE_DEV_ID_82599_KX4:
  3928. #define IXGBE_PCIE_PMCSR 0x44
  3929. adapter->wol = IXGBE_WUFC_MAG;
  3930. pci_read_config_word(pdev, IXGBE_PCIE_PMCSR, &pm_value);
  3931. pci_write_config_word(pdev, IXGBE_PCIE_PMCSR,
  3932. (pm_value | (1 << 8)));
  3933. break;
  3934. default:
  3935. adapter->wol = 0;
  3936. break;
  3937. }
  3938. device_init_wakeup(&adapter->pdev->dev, true);
  3939. device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
  3940. /* print bus type/speed/width info */
  3941. dev_info(&pdev->dev, "(PCI Express:%s:%s) %pM\n",
  3942. ((hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0Gb/s":
  3943. (hw->bus.speed == ixgbe_bus_speed_2500) ? "2.5Gb/s":"Unknown"),
  3944. ((hw->bus.width == ixgbe_bus_width_pcie_x8) ? "Width x8" :
  3945. (hw->bus.width == ixgbe_bus_width_pcie_x4) ? "Width x4" :
  3946. (hw->bus.width == ixgbe_bus_width_pcie_x1) ? "Width x1" :
  3947. "Unknown"),
  3948. netdev->dev_addr);
  3949. ixgbe_read_pba_num_generic(hw, &part_num);
  3950. if (ixgbe_is_sfp(hw) && hw->phy.sfp_type != ixgbe_sfp_type_not_present)
  3951. dev_info(&pdev->dev, "MAC: %d, PHY: %d, SFP+: %d, PBA No: %06x-%03x\n",
  3952. hw->mac.type, hw->phy.type, hw->phy.sfp_type,
  3953. (part_num >> 8), (part_num & 0xff));
  3954. else
  3955. dev_info(&pdev->dev, "MAC: %d, PHY: %d, PBA No: %06x-%03x\n",
  3956. hw->mac.type, hw->phy.type,
  3957. (part_num >> 8), (part_num & 0xff));
  3958. if (hw->bus.width <= ixgbe_bus_width_pcie_x4) {
  3959. dev_warn(&pdev->dev, "PCI-Express bandwidth available for "
  3960. "this card is not sufficient for optimal "
  3961. "performance.\n");
  3962. dev_warn(&pdev->dev, "For optimal performance a x8 "
  3963. "PCI-Express slot is required.\n");
  3964. }
  3965. /* save off EEPROM version number */
  3966. hw->eeprom.ops.read(hw, 0x29, &adapter->eeprom_version);
  3967. /* reset the hardware with the new settings */
  3968. hw->mac.ops.start_hw(hw);
  3969. netif_carrier_off(netdev);
  3970. strcpy(netdev->name, "eth%d");
  3971. err = register_netdev(netdev);
  3972. if (err)
  3973. goto err_register;
  3974. #ifdef CONFIG_IXGBE_DCA
  3975. if (dca_add_requester(&pdev->dev) == 0) {
  3976. adapter->flags |= IXGBE_FLAG_DCA_ENABLED;
  3977. /* always use CB2 mode, difference is masked
  3978. * in the CB driver */
  3979. IXGBE_WRITE_REG(hw, IXGBE_DCA_CTRL, 2);
  3980. ixgbe_setup_dca(adapter);
  3981. }
  3982. #endif
  3983. dev_info(&pdev->dev, "Intel(R) 10 Gigabit Network Connection\n");
  3984. cards_found++;
  3985. return 0;
  3986. err_register:
  3987. ixgbe_release_hw_control(adapter);
  3988. err_hw_init:
  3989. err_sw_init:
  3990. ixgbe_reset_interrupt_capability(adapter);
  3991. err_eeprom:
  3992. clear_bit(__IXGBE_SFP_MODULE_NOT_FOUND, &adapter->state);
  3993. del_timer_sync(&adapter->sfp_timer);
  3994. cancel_work_sync(&adapter->sfp_task);
  3995. cancel_work_sync(&adapter->multispeed_fiber_task);
  3996. cancel_work_sync(&adapter->sfp_config_module_task);
  3997. iounmap(hw->hw_addr);
  3998. err_ioremap:
  3999. free_netdev(netdev);
  4000. err_alloc_etherdev:
  4001. pci_release_regions(pdev);
  4002. err_pci_reg:
  4003. err_dma:
  4004. pci_disable_device(pdev);
  4005. return err;
  4006. }
  4007. /**
  4008. * ixgbe_remove - Device Removal Routine
  4009. * @pdev: PCI device information struct
  4010. *
  4011. * ixgbe_remove is called by the PCI subsystem to alert the driver
  4012. * that it should release a PCI device. The could be caused by a
  4013. * Hot-Plug event, or because the driver is going to be removed from
  4014. * memory.
  4015. **/
  4016. static void __devexit ixgbe_remove(struct pci_dev *pdev)
  4017. {
  4018. struct net_device *netdev = pci_get_drvdata(pdev);
  4019. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  4020. int err;
  4021. set_bit(__IXGBE_DOWN, &adapter->state);
  4022. /* clear the module not found bit to make sure the worker won't
  4023. * reschedule
  4024. */
  4025. clear_bit(__IXGBE_SFP_MODULE_NOT_FOUND, &adapter->state);
  4026. del_timer_sync(&adapter->watchdog_timer);
  4027. del_timer_sync(&adapter->sfp_timer);
  4028. cancel_work_sync(&adapter->watchdog_task);
  4029. cancel_work_sync(&adapter->sfp_task);
  4030. cancel_work_sync(&adapter->multispeed_fiber_task);
  4031. cancel_work_sync(&adapter->sfp_config_module_task);
  4032. flush_scheduled_work();
  4033. #ifdef CONFIG_IXGBE_DCA
  4034. if (adapter->flags & IXGBE_FLAG_DCA_ENABLED) {
  4035. adapter->flags &= ~IXGBE_FLAG_DCA_ENABLED;
  4036. dca_remove_requester(&pdev->dev);
  4037. IXGBE_WRITE_REG(&adapter->hw, IXGBE_DCA_CTRL, 1);
  4038. }
  4039. #endif
  4040. if (netdev->reg_state == NETREG_REGISTERED)
  4041. unregister_netdev(netdev);
  4042. ixgbe_reset_interrupt_capability(adapter);
  4043. ixgbe_release_hw_control(adapter);
  4044. iounmap(adapter->hw.hw_addr);
  4045. pci_release_regions(pdev);
  4046. DPRINTK(PROBE, INFO, "complete\n");
  4047. kfree(adapter->tx_ring);
  4048. kfree(adapter->rx_ring);
  4049. free_netdev(netdev);
  4050. err = pci_disable_pcie_error_reporting(pdev);
  4051. if (err)
  4052. dev_err(&pdev->dev,
  4053. "pci_disable_pcie_error_reporting failed 0x%x\n", err);
  4054. pci_disable_device(pdev);
  4055. }
  4056. /**
  4057. * ixgbe_io_error_detected - called when PCI error is detected
  4058. * @pdev: Pointer to PCI device
  4059. * @state: The current pci connection state
  4060. *
  4061. * This function is called after a PCI bus error affecting
  4062. * this device has been detected.
  4063. */
  4064. static pci_ers_result_t ixgbe_io_error_detected(struct pci_dev *pdev,
  4065. pci_channel_state_t state)
  4066. {
  4067. struct net_device *netdev = pci_get_drvdata(pdev);
  4068. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  4069. netif_device_detach(netdev);
  4070. if (netif_running(netdev))
  4071. ixgbe_down(adapter);
  4072. pci_disable_device(pdev);
  4073. /* Request a slot reset. */
  4074. return PCI_ERS_RESULT_NEED_RESET;
  4075. }
  4076. /**
  4077. * ixgbe_io_slot_reset - called after the pci bus has been reset.
  4078. * @pdev: Pointer to PCI device
  4079. *
  4080. * Restart the card from scratch, as if from a cold-boot.
  4081. */
  4082. static pci_ers_result_t ixgbe_io_slot_reset(struct pci_dev *pdev)
  4083. {
  4084. struct net_device *netdev = pci_get_drvdata(pdev);
  4085. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  4086. pci_ers_result_t result;
  4087. int err;
  4088. if (pci_enable_device(pdev)) {
  4089. DPRINTK(PROBE, ERR,
  4090. "Cannot re-enable PCI device after reset.\n");
  4091. result = PCI_ERS_RESULT_DISCONNECT;
  4092. } else {
  4093. pci_set_master(pdev);
  4094. pci_restore_state(pdev);
  4095. pci_enable_wake(pdev, PCI_D3hot, 0);
  4096. pci_enable_wake(pdev, PCI_D3cold, 0);
  4097. ixgbe_reset(adapter);
  4098. result = PCI_ERS_RESULT_RECOVERED;
  4099. }
  4100. err = pci_cleanup_aer_uncorrect_error_status(pdev);
  4101. if (err) {
  4102. dev_err(&pdev->dev,
  4103. "pci_cleanup_aer_uncorrect_error_status failed 0x%0x\n", err);
  4104. /* non-fatal, continue */
  4105. }
  4106. return result;
  4107. }
  4108. /**
  4109. * ixgbe_io_resume - called when traffic can start flowing again.
  4110. * @pdev: Pointer to PCI device
  4111. *
  4112. * This callback is called when the error recovery driver tells us that
  4113. * its OK to resume normal operation.
  4114. */
  4115. static void ixgbe_io_resume(struct pci_dev *pdev)
  4116. {
  4117. struct net_device *netdev = pci_get_drvdata(pdev);
  4118. struct ixgbe_adapter *adapter = netdev_priv(netdev);
  4119. if (netif_running(netdev)) {
  4120. if (ixgbe_up(adapter)) {
  4121. DPRINTK(PROBE, INFO, "ixgbe_up failed after reset\n");
  4122. return;
  4123. }
  4124. }
  4125. netif_device_attach(netdev);
  4126. }
  4127. static struct pci_error_handlers ixgbe_err_handler = {
  4128. .error_detected = ixgbe_io_error_detected,
  4129. .slot_reset = ixgbe_io_slot_reset,
  4130. .resume = ixgbe_io_resume,
  4131. };
  4132. static struct pci_driver ixgbe_driver = {
  4133. .name = ixgbe_driver_name,
  4134. .id_table = ixgbe_pci_tbl,
  4135. .probe = ixgbe_probe,
  4136. .remove = __devexit_p(ixgbe_remove),
  4137. #ifdef CONFIG_PM
  4138. .suspend = ixgbe_suspend,
  4139. .resume = ixgbe_resume,
  4140. #endif
  4141. .shutdown = ixgbe_shutdown,
  4142. .err_handler = &ixgbe_err_handler
  4143. };
  4144. /**
  4145. * ixgbe_init_module - Driver Registration Routine
  4146. *
  4147. * ixgbe_init_module is the first routine called when the driver is
  4148. * loaded. All it does is register with the PCI subsystem.
  4149. **/
  4150. static int __init ixgbe_init_module(void)
  4151. {
  4152. int ret;
  4153. printk(KERN_INFO "%s: %s - version %s\n", ixgbe_driver_name,
  4154. ixgbe_driver_string, ixgbe_driver_version);
  4155. printk(KERN_INFO "%s: %s\n", ixgbe_driver_name, ixgbe_copyright);
  4156. #ifdef CONFIG_IXGBE_DCA
  4157. dca_register_notify(&dca_notifier);
  4158. #endif
  4159. ret = pci_register_driver(&ixgbe_driver);
  4160. return ret;
  4161. }
  4162. module_init(ixgbe_init_module);
  4163. /**
  4164. * ixgbe_exit_module - Driver Exit Cleanup Routine
  4165. *
  4166. * ixgbe_exit_module is called just before the driver is removed
  4167. * from memory.
  4168. **/
  4169. static void __exit ixgbe_exit_module(void)
  4170. {
  4171. #ifdef CONFIG_IXGBE_DCA
  4172. dca_unregister_notify(&dca_notifier);
  4173. #endif
  4174. pci_unregister_driver(&ixgbe_driver);
  4175. }
  4176. #ifdef CONFIG_IXGBE_DCA
  4177. static int ixgbe_notify_dca(struct notifier_block *nb, unsigned long event,
  4178. void *p)
  4179. {
  4180. int ret_val;
  4181. ret_val = driver_for_each_device(&ixgbe_driver.driver, NULL, &event,
  4182. __ixgbe_notify_dca);
  4183. return ret_val ? NOTIFY_BAD : NOTIFY_DONE;
  4184. }
  4185. #endif /* CONFIG_IXGBE_DCA */
  4186. module_exit(ixgbe_exit_module);
  4187. /* ixgbe_main.c */