libata-eh.c 108 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147
  1. /*
  2. * libata-eh.c - libata error handling
  3. *
  4. * Maintained by: Tejun Heo <tj@kernel.org>
  5. * Please ALWAYS copy linux-ide@vger.kernel.org
  6. * on emails.
  7. *
  8. * Copyright 2006 Tejun Heo <htejun@gmail.com>
  9. *
  10. *
  11. * This program is free software; you can redistribute it and/or
  12. * modify it under the terms of the GNU General Public License as
  13. * published by the Free Software Foundation; either version 2, or
  14. * (at your option) any later version.
  15. *
  16. * This program is distributed in the hope that it will be useful,
  17. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19. * General Public License for more details.
  20. *
  21. * You should have received a copy of the GNU General Public License
  22. * along with this program; see the file COPYING. If not, write to
  23. * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
  24. * USA.
  25. *
  26. *
  27. * libata documentation is available via 'make {ps|pdf}docs',
  28. * as Documentation/DocBook/libata.*
  29. *
  30. * Hardware documentation available from http://www.t13.org/ and
  31. * http://www.sata-io.org/
  32. *
  33. */
  34. #include <linux/kernel.h>
  35. #include <linux/blkdev.h>
  36. #include <linux/export.h>
  37. #include <linux/pci.h>
  38. #include <scsi/scsi.h>
  39. #include <scsi/scsi_host.h>
  40. #include <scsi/scsi_eh.h>
  41. #include <scsi/scsi_device.h>
  42. #include <scsi/scsi_cmnd.h>
  43. #include <scsi/scsi_dbg.h>
  44. #include "../scsi/scsi_transport_api.h"
  45. #include <linux/libata.h>
  46. #include "libata.h"
  47. enum {
  48. /* speed down verdicts */
  49. ATA_EH_SPDN_NCQ_OFF = (1 << 0),
  50. ATA_EH_SPDN_SPEED_DOWN = (1 << 1),
  51. ATA_EH_SPDN_FALLBACK_TO_PIO = (1 << 2),
  52. ATA_EH_SPDN_KEEP_ERRORS = (1 << 3),
  53. /* error flags */
  54. ATA_EFLAG_IS_IO = (1 << 0),
  55. ATA_EFLAG_DUBIOUS_XFER = (1 << 1),
  56. ATA_EFLAG_OLD_ER = (1 << 31),
  57. /* error categories */
  58. ATA_ECAT_NONE = 0,
  59. ATA_ECAT_ATA_BUS = 1,
  60. ATA_ECAT_TOUT_HSM = 2,
  61. ATA_ECAT_UNK_DEV = 3,
  62. ATA_ECAT_DUBIOUS_NONE = 4,
  63. ATA_ECAT_DUBIOUS_ATA_BUS = 5,
  64. ATA_ECAT_DUBIOUS_TOUT_HSM = 6,
  65. ATA_ECAT_DUBIOUS_UNK_DEV = 7,
  66. ATA_ECAT_NR = 8,
  67. ATA_EH_CMD_DFL_TIMEOUT = 5000,
  68. /* always put at least this amount of time between resets */
  69. ATA_EH_RESET_COOL_DOWN = 5000,
  70. /* Waiting in ->prereset can never be reliable. It's
  71. * sometimes nice to wait there but it can't be depended upon;
  72. * otherwise, we wouldn't be resetting. Just give it enough
  73. * time for most drives to spin up.
  74. */
  75. ATA_EH_PRERESET_TIMEOUT = 10000,
  76. ATA_EH_FASTDRAIN_INTERVAL = 3000,
  77. ATA_EH_UA_TRIES = 5,
  78. /* probe speed down parameters, see ata_eh_schedule_probe() */
  79. ATA_EH_PROBE_TRIAL_INTERVAL = 60000, /* 1 min */
  80. ATA_EH_PROBE_TRIALS = 2,
  81. };
  82. /* The following table determines how we sequence resets. Each entry
  83. * represents timeout for that try. The first try can be soft or
  84. * hardreset. All others are hardreset if available. In most cases
  85. * the first reset w/ 10sec timeout should succeed. Following entries
  86. * are mostly for error handling, hotplug and retarded devices.
  87. */
  88. static const unsigned long ata_eh_reset_timeouts[] = {
  89. 10000, /* most drives spin up by 10sec */
  90. 10000, /* > 99% working drives spin up before 20sec */
  91. 35000, /* give > 30 secs of idleness for retarded devices */
  92. 5000, /* and sweet one last chance */
  93. ULONG_MAX, /* > 1 min has elapsed, give up */
  94. };
  95. static const unsigned long ata_eh_identify_timeouts[] = {
  96. 5000, /* covers > 99% of successes and not too boring on failures */
  97. 10000, /* combined time till here is enough even for media access */
  98. 30000, /* for true idiots */
  99. ULONG_MAX,
  100. };
  101. static const unsigned long ata_eh_flush_timeouts[] = {
  102. 15000, /* be generous with flush */
  103. 15000, /* ditto */
  104. 30000, /* and even more generous */
  105. ULONG_MAX,
  106. };
  107. static const unsigned long ata_eh_other_timeouts[] = {
  108. 5000, /* same rationale as identify timeout */
  109. 10000, /* ditto */
  110. /* but no merciful 30sec for other commands, it just isn't worth it */
  111. ULONG_MAX,
  112. };
  113. struct ata_eh_cmd_timeout_ent {
  114. const u8 *commands;
  115. const unsigned long *timeouts;
  116. };
  117. /* The following table determines timeouts to use for EH internal
  118. * commands. Each table entry is a command class and matches the
  119. * commands the entry applies to and the timeout table to use.
  120. *
  121. * On the retry after a command timed out, the next timeout value from
  122. * the table is used. If the table doesn't contain further entries,
  123. * the last value is used.
  124. *
  125. * ehc->cmd_timeout_idx keeps track of which timeout to use per
  126. * command class, so if SET_FEATURES times out on the first try, the
  127. * next try will use the second timeout value only for that class.
  128. */
  129. #define CMDS(cmds...) (const u8 []){ cmds, 0 }
  130. static const struct ata_eh_cmd_timeout_ent
  131. ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
  132. { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
  133. .timeouts = ata_eh_identify_timeouts, },
  134. { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
  135. .timeouts = ata_eh_other_timeouts, },
  136. { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
  137. .timeouts = ata_eh_other_timeouts, },
  138. { .commands = CMDS(ATA_CMD_SET_FEATURES),
  139. .timeouts = ata_eh_other_timeouts, },
  140. { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
  141. .timeouts = ata_eh_other_timeouts, },
  142. { .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT),
  143. .timeouts = ata_eh_flush_timeouts },
  144. };
  145. #undef CMDS
  146. static void __ata_port_freeze(struct ata_port *ap);
  147. #ifdef CONFIG_PM
  148. static void ata_eh_handle_port_suspend(struct ata_port *ap);
  149. static void ata_eh_handle_port_resume(struct ata_port *ap);
  150. #else /* CONFIG_PM */
  151. static void ata_eh_handle_port_suspend(struct ata_port *ap)
  152. { }
  153. static void ata_eh_handle_port_resume(struct ata_port *ap)
  154. { }
  155. #endif /* CONFIG_PM */
  156. static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
  157. va_list args)
  158. {
  159. ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
  160. ATA_EH_DESC_LEN - ehi->desc_len,
  161. fmt, args);
  162. }
  163. /**
  164. * __ata_ehi_push_desc - push error description without adding separator
  165. * @ehi: target EHI
  166. * @fmt: printf format string
  167. *
  168. * Format string according to @fmt and append it to @ehi->desc.
  169. *
  170. * LOCKING:
  171. * spin_lock_irqsave(host lock)
  172. */
  173. void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
  174. {
  175. va_list args;
  176. va_start(args, fmt);
  177. __ata_ehi_pushv_desc(ehi, fmt, args);
  178. va_end(args);
  179. }
  180. /**
  181. * ata_ehi_push_desc - push error description with separator
  182. * @ehi: target EHI
  183. * @fmt: printf format string
  184. *
  185. * Format string according to @fmt and append it to @ehi->desc.
  186. * If @ehi->desc is not empty, ", " is added in-between.
  187. *
  188. * LOCKING:
  189. * spin_lock_irqsave(host lock)
  190. */
  191. void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
  192. {
  193. va_list args;
  194. if (ehi->desc_len)
  195. __ata_ehi_push_desc(ehi, ", ");
  196. va_start(args, fmt);
  197. __ata_ehi_pushv_desc(ehi, fmt, args);
  198. va_end(args);
  199. }
  200. /**
  201. * ata_ehi_clear_desc - clean error description
  202. * @ehi: target EHI
  203. *
  204. * Clear @ehi->desc.
  205. *
  206. * LOCKING:
  207. * spin_lock_irqsave(host lock)
  208. */
  209. void ata_ehi_clear_desc(struct ata_eh_info *ehi)
  210. {
  211. ehi->desc[0] = '\0';
  212. ehi->desc_len = 0;
  213. }
  214. /**
  215. * ata_port_desc - append port description
  216. * @ap: target ATA port
  217. * @fmt: printf format string
  218. *
  219. * Format string according to @fmt and append it to port
  220. * description. If port description is not empty, " " is added
  221. * in-between. This function is to be used while initializing
  222. * ata_host. The description is printed on host registration.
  223. *
  224. * LOCKING:
  225. * None.
  226. */
  227. void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
  228. {
  229. va_list args;
  230. WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
  231. if (ap->link.eh_info.desc_len)
  232. __ata_ehi_push_desc(&ap->link.eh_info, " ");
  233. va_start(args, fmt);
  234. __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
  235. va_end(args);
  236. }
  237. #ifdef CONFIG_PCI
  238. /**
  239. * ata_port_pbar_desc - append PCI BAR description
  240. * @ap: target ATA port
  241. * @bar: target PCI BAR
  242. * @offset: offset into PCI BAR
  243. * @name: name of the area
  244. *
  245. * If @offset is negative, this function formats a string which
  246. * contains the name, address, size and type of the BAR and
  247. * appends it to the port description. If @offset is zero or
  248. * positive, only name and offsetted address is appended.
  249. *
  250. * LOCKING:
  251. * None.
  252. */
  253. void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
  254. const char *name)
  255. {
  256. struct pci_dev *pdev = to_pci_dev(ap->host->dev);
  257. char *type = "";
  258. unsigned long long start, len;
  259. if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
  260. type = "m";
  261. else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
  262. type = "i";
  263. start = (unsigned long long)pci_resource_start(pdev, bar);
  264. len = (unsigned long long)pci_resource_len(pdev, bar);
  265. if (offset < 0)
  266. ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
  267. else
  268. ata_port_desc(ap, "%s 0x%llx", name,
  269. start + (unsigned long long)offset);
  270. }
  271. #endif /* CONFIG_PCI */
  272. static int ata_lookup_timeout_table(u8 cmd)
  273. {
  274. int i;
  275. for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
  276. const u8 *cur;
  277. for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
  278. if (*cur == cmd)
  279. return i;
  280. }
  281. return -1;
  282. }
  283. /**
  284. * ata_internal_cmd_timeout - determine timeout for an internal command
  285. * @dev: target device
  286. * @cmd: internal command to be issued
  287. *
  288. * Determine timeout for internal command @cmd for @dev.
  289. *
  290. * LOCKING:
  291. * EH context.
  292. *
  293. * RETURNS:
  294. * Determined timeout.
  295. */
  296. unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
  297. {
  298. struct ata_eh_context *ehc = &dev->link->eh_context;
  299. int ent = ata_lookup_timeout_table(cmd);
  300. int idx;
  301. if (ent < 0)
  302. return ATA_EH_CMD_DFL_TIMEOUT;
  303. idx = ehc->cmd_timeout_idx[dev->devno][ent];
  304. return ata_eh_cmd_timeout_table[ent].timeouts[idx];
  305. }
  306. /**
  307. * ata_internal_cmd_timed_out - notification for internal command timeout
  308. * @dev: target device
  309. * @cmd: internal command which timed out
  310. *
  311. * Notify EH that internal command @cmd for @dev timed out. This
  312. * function should be called only for commands whose timeouts are
  313. * determined using ata_internal_cmd_timeout().
  314. *
  315. * LOCKING:
  316. * EH context.
  317. */
  318. void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
  319. {
  320. struct ata_eh_context *ehc = &dev->link->eh_context;
  321. int ent = ata_lookup_timeout_table(cmd);
  322. int idx;
  323. if (ent < 0)
  324. return;
  325. idx = ehc->cmd_timeout_idx[dev->devno][ent];
  326. if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
  327. ehc->cmd_timeout_idx[dev->devno][ent]++;
  328. }
  329. static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
  330. unsigned int err_mask)
  331. {
  332. struct ata_ering_entry *ent;
  333. WARN_ON(!err_mask);
  334. ering->cursor++;
  335. ering->cursor %= ATA_ERING_SIZE;
  336. ent = &ering->ring[ering->cursor];
  337. ent->eflags = eflags;
  338. ent->err_mask = err_mask;
  339. ent->timestamp = get_jiffies_64();
  340. }
  341. static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
  342. {
  343. struct ata_ering_entry *ent = &ering->ring[ering->cursor];
  344. if (ent->err_mask)
  345. return ent;
  346. return NULL;
  347. }
  348. int ata_ering_map(struct ata_ering *ering,
  349. int (*map_fn)(struct ata_ering_entry *, void *),
  350. void *arg)
  351. {
  352. int idx, rc = 0;
  353. struct ata_ering_entry *ent;
  354. idx = ering->cursor;
  355. do {
  356. ent = &ering->ring[idx];
  357. if (!ent->err_mask)
  358. break;
  359. rc = map_fn(ent, arg);
  360. if (rc)
  361. break;
  362. idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
  363. } while (idx != ering->cursor);
  364. return rc;
  365. }
  366. static int ata_ering_clear_cb(struct ata_ering_entry *ent, void *void_arg)
  367. {
  368. ent->eflags |= ATA_EFLAG_OLD_ER;
  369. return 0;
  370. }
  371. static void ata_ering_clear(struct ata_ering *ering)
  372. {
  373. ata_ering_map(ering, ata_ering_clear_cb, NULL);
  374. }
  375. static unsigned int ata_eh_dev_action(struct ata_device *dev)
  376. {
  377. struct ata_eh_context *ehc = &dev->link->eh_context;
  378. return ehc->i.action | ehc->i.dev_action[dev->devno];
  379. }
  380. static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
  381. struct ata_eh_info *ehi, unsigned int action)
  382. {
  383. struct ata_device *tdev;
  384. if (!dev) {
  385. ehi->action &= ~action;
  386. ata_for_each_dev(tdev, link, ALL)
  387. ehi->dev_action[tdev->devno] &= ~action;
  388. } else {
  389. /* doesn't make sense for port-wide EH actions */
  390. WARN_ON(!(action & ATA_EH_PERDEV_MASK));
  391. /* break ehi->action into ehi->dev_action */
  392. if (ehi->action & action) {
  393. ata_for_each_dev(tdev, link, ALL)
  394. ehi->dev_action[tdev->devno] |=
  395. ehi->action & action;
  396. ehi->action &= ~action;
  397. }
  398. /* turn off the specified per-dev action */
  399. ehi->dev_action[dev->devno] &= ~action;
  400. }
  401. }
  402. /**
  403. * ata_eh_acquire - acquire EH ownership
  404. * @ap: ATA port to acquire EH ownership for
  405. *
  406. * Acquire EH ownership for @ap. This is the basic exclusion
  407. * mechanism for ports sharing a host. Only one port hanging off
  408. * the same host can claim the ownership of EH.
  409. *
  410. * LOCKING:
  411. * EH context.
  412. */
  413. void ata_eh_acquire(struct ata_port *ap)
  414. {
  415. mutex_lock(&ap->host->eh_mutex);
  416. WARN_ON_ONCE(ap->host->eh_owner);
  417. ap->host->eh_owner = current;
  418. }
  419. /**
  420. * ata_eh_release - release EH ownership
  421. * @ap: ATA port to release EH ownership for
  422. *
  423. * Release EH ownership for @ap if the caller. The caller must
  424. * have acquired EH ownership using ata_eh_acquire() previously.
  425. *
  426. * LOCKING:
  427. * EH context.
  428. */
  429. void ata_eh_release(struct ata_port *ap)
  430. {
  431. WARN_ON_ONCE(ap->host->eh_owner != current);
  432. ap->host->eh_owner = NULL;
  433. mutex_unlock(&ap->host->eh_mutex);
  434. }
  435. /**
  436. * ata_scsi_timed_out - SCSI layer time out callback
  437. * @cmd: timed out SCSI command
  438. *
  439. * Handles SCSI layer timeout. We race with normal completion of
  440. * the qc for @cmd. If the qc is already gone, we lose and let
  441. * the scsi command finish (EH_HANDLED). Otherwise, the qc has
  442. * timed out and EH should be invoked. Prevent ata_qc_complete()
  443. * from finishing it by setting EH_SCHEDULED and return
  444. * EH_NOT_HANDLED.
  445. *
  446. * TODO: kill this function once old EH is gone.
  447. *
  448. * LOCKING:
  449. * Called from timer context
  450. *
  451. * RETURNS:
  452. * EH_HANDLED or EH_NOT_HANDLED
  453. */
  454. enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
  455. {
  456. struct Scsi_Host *host = cmd->device->host;
  457. struct ata_port *ap = ata_shost_to_port(host);
  458. unsigned long flags;
  459. struct ata_queued_cmd *qc;
  460. enum blk_eh_timer_return ret;
  461. DPRINTK("ENTER\n");
  462. if (ap->ops->error_handler) {
  463. ret = BLK_EH_NOT_HANDLED;
  464. goto out;
  465. }
  466. ret = BLK_EH_HANDLED;
  467. spin_lock_irqsave(ap->lock, flags);
  468. qc = ata_qc_from_tag(ap, ap->link.active_tag);
  469. if (qc) {
  470. WARN_ON(qc->scsicmd != cmd);
  471. qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
  472. qc->err_mask |= AC_ERR_TIMEOUT;
  473. ret = BLK_EH_NOT_HANDLED;
  474. }
  475. spin_unlock_irqrestore(ap->lock, flags);
  476. out:
  477. DPRINTK("EXIT, ret=%d\n", ret);
  478. return ret;
  479. }
  480. static void ata_eh_unload(struct ata_port *ap)
  481. {
  482. struct ata_link *link;
  483. struct ata_device *dev;
  484. unsigned long flags;
  485. /* Restore SControl IPM and SPD for the next driver and
  486. * disable attached devices.
  487. */
  488. ata_for_each_link(link, ap, PMP_FIRST) {
  489. sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
  490. ata_for_each_dev(dev, link, ALL)
  491. ata_dev_disable(dev);
  492. }
  493. /* freeze and set UNLOADED */
  494. spin_lock_irqsave(ap->lock, flags);
  495. ata_port_freeze(ap); /* won't be thawed */
  496. ap->pflags &= ~ATA_PFLAG_EH_PENDING; /* clear pending from freeze */
  497. ap->pflags |= ATA_PFLAG_UNLOADED;
  498. spin_unlock_irqrestore(ap->lock, flags);
  499. }
  500. /**
  501. * ata_scsi_error - SCSI layer error handler callback
  502. * @host: SCSI host on which error occurred
  503. *
  504. * Handles SCSI-layer-thrown error events.
  505. *
  506. * LOCKING:
  507. * Inherited from SCSI layer (none, can sleep)
  508. *
  509. * RETURNS:
  510. * Zero.
  511. */
  512. void ata_scsi_error(struct Scsi_Host *host)
  513. {
  514. struct ata_port *ap = ata_shost_to_port(host);
  515. unsigned long flags;
  516. LIST_HEAD(eh_work_q);
  517. DPRINTK("ENTER\n");
  518. spin_lock_irqsave(host->host_lock, flags);
  519. list_splice_init(&host->eh_cmd_q, &eh_work_q);
  520. spin_unlock_irqrestore(host->host_lock, flags);
  521. ata_scsi_cmd_error_handler(host, ap, &eh_work_q);
  522. /* If we timed raced normal completion and there is nothing to
  523. recover nr_timedout == 0 why exactly are we doing error recovery ? */
  524. ata_scsi_port_error_handler(host, ap);
  525. /* finish or retry handled scmd's and clean up */
  526. WARN_ON(host->host_failed || !list_empty(&eh_work_q));
  527. DPRINTK("EXIT\n");
  528. }
  529. /**
  530. * ata_scsi_cmd_error_handler - error callback for a list of commands
  531. * @host: scsi host containing the port
  532. * @ap: ATA port within the host
  533. * @eh_work_q: list of commands to process
  534. *
  535. * process the given list of commands and return those finished to the
  536. * ap->eh_done_q. This function is the first part of the libata error
  537. * handler which processes a given list of failed commands.
  538. */
  539. void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap,
  540. struct list_head *eh_work_q)
  541. {
  542. int i;
  543. unsigned long flags;
  544. /* make sure sff pio task is not running */
  545. ata_sff_flush_pio_task(ap);
  546. /* synchronize with host lock and sort out timeouts */
  547. /* For new EH, all qcs are finished in one of three ways -
  548. * normal completion, error completion, and SCSI timeout.
  549. * Both completions can race against SCSI timeout. When normal
  550. * completion wins, the qc never reaches EH. When error
  551. * completion wins, the qc has ATA_QCFLAG_FAILED set.
  552. *
  553. * When SCSI timeout wins, things are a bit more complex.
  554. * Normal or error completion can occur after the timeout but
  555. * before this point. In such cases, both types of
  556. * completions are honored. A scmd is determined to have
  557. * timed out iff its associated qc is active and not failed.
  558. */
  559. if (ap->ops->error_handler) {
  560. struct scsi_cmnd *scmd, *tmp;
  561. int nr_timedout = 0;
  562. spin_lock_irqsave(ap->lock, flags);
  563. /* This must occur under the ap->lock as we don't want
  564. a polled recovery to race the real interrupt handler
  565. The lost_interrupt handler checks for any completed but
  566. non-notified command and completes much like an IRQ handler.
  567. We then fall into the error recovery code which will treat
  568. this as if normal completion won the race */
  569. if (ap->ops->lost_interrupt)
  570. ap->ops->lost_interrupt(ap);
  571. list_for_each_entry_safe(scmd, tmp, eh_work_q, eh_entry) {
  572. struct ata_queued_cmd *qc;
  573. for (i = 0; i < ATA_MAX_QUEUE; i++) {
  574. qc = __ata_qc_from_tag(ap, i);
  575. if (qc->flags & ATA_QCFLAG_ACTIVE &&
  576. qc->scsicmd == scmd)
  577. break;
  578. }
  579. if (i < ATA_MAX_QUEUE) {
  580. /* the scmd has an associated qc */
  581. if (!(qc->flags & ATA_QCFLAG_FAILED)) {
  582. /* which hasn't failed yet, timeout */
  583. qc->err_mask |= AC_ERR_TIMEOUT;
  584. qc->flags |= ATA_QCFLAG_FAILED;
  585. nr_timedout++;
  586. }
  587. } else {
  588. /* Normal completion occurred after
  589. * SCSI timeout but before this point.
  590. * Successfully complete it.
  591. */
  592. scmd->retries = scmd->allowed;
  593. scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
  594. }
  595. }
  596. /* If we have timed out qcs. They belong to EH from
  597. * this point but the state of the controller is
  598. * unknown. Freeze the port to make sure the IRQ
  599. * handler doesn't diddle with those qcs. This must
  600. * be done atomically w.r.t. setting QCFLAG_FAILED.
  601. */
  602. if (nr_timedout)
  603. __ata_port_freeze(ap);
  604. spin_unlock_irqrestore(ap->lock, flags);
  605. /* initialize eh_tries */
  606. ap->eh_tries = ATA_EH_MAX_TRIES;
  607. } else
  608. spin_unlock_wait(ap->lock);
  609. }
  610. EXPORT_SYMBOL(ata_scsi_cmd_error_handler);
  611. /**
  612. * ata_scsi_port_error_handler - recover the port after the commands
  613. * @host: SCSI host containing the port
  614. * @ap: the ATA port
  615. *
  616. * Handle the recovery of the port @ap after all the commands
  617. * have been recovered.
  618. */
  619. void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap)
  620. {
  621. unsigned long flags;
  622. /* invoke error handler */
  623. if (ap->ops->error_handler) {
  624. struct ata_link *link;
  625. /* acquire EH ownership */
  626. ata_eh_acquire(ap);
  627. repeat:
  628. /* kill fast drain timer */
  629. del_timer_sync(&ap->fastdrain_timer);
  630. /* process port resume request */
  631. ata_eh_handle_port_resume(ap);
  632. /* fetch & clear EH info */
  633. spin_lock_irqsave(ap->lock, flags);
  634. ata_for_each_link(link, ap, HOST_FIRST) {
  635. struct ata_eh_context *ehc = &link->eh_context;
  636. struct ata_device *dev;
  637. memset(&link->eh_context, 0, sizeof(link->eh_context));
  638. link->eh_context.i = link->eh_info;
  639. memset(&link->eh_info, 0, sizeof(link->eh_info));
  640. ata_for_each_dev(dev, link, ENABLED) {
  641. int devno = dev->devno;
  642. ehc->saved_xfer_mode[devno] = dev->xfer_mode;
  643. if (ata_ncq_enabled(dev))
  644. ehc->saved_ncq_enabled |= 1 << devno;
  645. }
  646. }
  647. ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
  648. ap->pflags &= ~ATA_PFLAG_EH_PENDING;
  649. ap->excl_link = NULL; /* don't maintain exclusion over EH */
  650. spin_unlock_irqrestore(ap->lock, flags);
  651. /* invoke EH, skip if unloading or suspended */
  652. if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
  653. ap->ops->error_handler(ap);
  654. else {
  655. /* if unloading, commence suicide */
  656. if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
  657. !(ap->pflags & ATA_PFLAG_UNLOADED))
  658. ata_eh_unload(ap);
  659. ata_eh_finish(ap);
  660. }
  661. /* process port suspend request */
  662. ata_eh_handle_port_suspend(ap);
  663. /* Exception might have happened after ->error_handler
  664. * recovered the port but before this point. Repeat
  665. * EH in such case.
  666. */
  667. spin_lock_irqsave(ap->lock, flags);
  668. if (ap->pflags & ATA_PFLAG_EH_PENDING) {
  669. if (--ap->eh_tries) {
  670. spin_unlock_irqrestore(ap->lock, flags);
  671. goto repeat;
  672. }
  673. ata_port_err(ap,
  674. "EH pending after %d tries, giving up\n",
  675. ATA_EH_MAX_TRIES);
  676. ap->pflags &= ~ATA_PFLAG_EH_PENDING;
  677. }
  678. /* this run is complete, make sure EH info is clear */
  679. ata_for_each_link(link, ap, HOST_FIRST)
  680. memset(&link->eh_info, 0, sizeof(link->eh_info));
  681. /* end eh (clear host_eh_scheduled) while holding
  682. * ap->lock such that if exception occurs after this
  683. * point but before EH completion, SCSI midlayer will
  684. * re-initiate EH.
  685. */
  686. ap->ops->end_eh(ap);
  687. spin_unlock_irqrestore(ap->lock, flags);
  688. ata_eh_release(ap);
  689. } else {
  690. WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
  691. ap->ops->eng_timeout(ap);
  692. }
  693. scsi_eh_flush_done_q(&ap->eh_done_q);
  694. /* clean up */
  695. spin_lock_irqsave(ap->lock, flags);
  696. if (ap->pflags & ATA_PFLAG_LOADING)
  697. ap->pflags &= ~ATA_PFLAG_LOADING;
  698. else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
  699. schedule_delayed_work(&ap->hotplug_task, 0);
  700. if (ap->pflags & ATA_PFLAG_RECOVERED)
  701. ata_port_info(ap, "EH complete\n");
  702. ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
  703. /* tell wait_eh that we're done */
  704. ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
  705. wake_up_all(&ap->eh_wait_q);
  706. spin_unlock_irqrestore(ap->lock, flags);
  707. }
  708. EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler);
  709. /**
  710. * ata_port_wait_eh - Wait for the currently pending EH to complete
  711. * @ap: Port to wait EH for
  712. *
  713. * Wait until the currently pending EH is complete.
  714. *
  715. * LOCKING:
  716. * Kernel thread context (may sleep).
  717. */
  718. void ata_port_wait_eh(struct ata_port *ap)
  719. {
  720. unsigned long flags;
  721. DEFINE_WAIT(wait);
  722. retry:
  723. spin_lock_irqsave(ap->lock, flags);
  724. while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
  725. prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
  726. spin_unlock_irqrestore(ap->lock, flags);
  727. schedule();
  728. spin_lock_irqsave(ap->lock, flags);
  729. }
  730. finish_wait(&ap->eh_wait_q, &wait);
  731. spin_unlock_irqrestore(ap->lock, flags);
  732. /* make sure SCSI EH is complete */
  733. if (scsi_host_in_recovery(ap->scsi_host)) {
  734. ata_msleep(ap, 10);
  735. goto retry;
  736. }
  737. }
  738. EXPORT_SYMBOL_GPL(ata_port_wait_eh);
  739. static int ata_eh_nr_in_flight(struct ata_port *ap)
  740. {
  741. unsigned int tag;
  742. int nr = 0;
  743. /* count only non-internal commands */
  744. for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
  745. if (ata_qc_from_tag(ap, tag))
  746. nr++;
  747. return nr;
  748. }
  749. void ata_eh_fastdrain_timerfn(unsigned long arg)
  750. {
  751. struct ata_port *ap = (void *)arg;
  752. unsigned long flags;
  753. int cnt;
  754. spin_lock_irqsave(ap->lock, flags);
  755. cnt = ata_eh_nr_in_flight(ap);
  756. /* are we done? */
  757. if (!cnt)
  758. goto out_unlock;
  759. if (cnt == ap->fastdrain_cnt) {
  760. unsigned int tag;
  761. /* No progress during the last interval, tag all
  762. * in-flight qcs as timed out and freeze the port.
  763. */
  764. for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
  765. struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
  766. if (qc)
  767. qc->err_mask |= AC_ERR_TIMEOUT;
  768. }
  769. ata_port_freeze(ap);
  770. } else {
  771. /* some qcs have finished, give it another chance */
  772. ap->fastdrain_cnt = cnt;
  773. ap->fastdrain_timer.expires =
  774. ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
  775. add_timer(&ap->fastdrain_timer);
  776. }
  777. out_unlock:
  778. spin_unlock_irqrestore(ap->lock, flags);
  779. }
  780. /**
  781. * ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
  782. * @ap: target ATA port
  783. * @fastdrain: activate fast drain
  784. *
  785. * Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
  786. * is non-zero and EH wasn't pending before. Fast drain ensures
  787. * that EH kicks in in timely manner.
  788. *
  789. * LOCKING:
  790. * spin_lock_irqsave(host lock)
  791. */
  792. static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
  793. {
  794. int cnt;
  795. /* already scheduled? */
  796. if (ap->pflags & ATA_PFLAG_EH_PENDING)
  797. return;
  798. ap->pflags |= ATA_PFLAG_EH_PENDING;
  799. if (!fastdrain)
  800. return;
  801. /* do we have in-flight qcs? */
  802. cnt = ata_eh_nr_in_flight(ap);
  803. if (!cnt)
  804. return;
  805. /* activate fast drain */
  806. ap->fastdrain_cnt = cnt;
  807. ap->fastdrain_timer.expires =
  808. ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
  809. add_timer(&ap->fastdrain_timer);
  810. }
  811. /**
  812. * ata_qc_schedule_eh - schedule qc for error handling
  813. * @qc: command to schedule error handling for
  814. *
  815. * Schedule error handling for @qc. EH will kick in as soon as
  816. * other commands are drained.
  817. *
  818. * LOCKING:
  819. * spin_lock_irqsave(host lock)
  820. */
  821. void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
  822. {
  823. struct ata_port *ap = qc->ap;
  824. struct request_queue *q = qc->scsicmd->device->request_queue;
  825. unsigned long flags;
  826. WARN_ON(!ap->ops->error_handler);
  827. qc->flags |= ATA_QCFLAG_FAILED;
  828. ata_eh_set_pending(ap, 1);
  829. /* The following will fail if timeout has already expired.
  830. * ata_scsi_error() takes care of such scmds on EH entry.
  831. * Note that ATA_QCFLAG_FAILED is unconditionally set after
  832. * this function completes.
  833. */
  834. spin_lock_irqsave(q->queue_lock, flags);
  835. blk_abort_request(qc->scsicmd->request);
  836. spin_unlock_irqrestore(q->queue_lock, flags);
  837. }
  838. /**
  839. * ata_std_sched_eh - non-libsas ata_ports issue eh with this common routine
  840. * @ap: ATA port to schedule EH for
  841. *
  842. * LOCKING: inherited from ata_port_schedule_eh
  843. * spin_lock_irqsave(host lock)
  844. */
  845. void ata_std_sched_eh(struct ata_port *ap)
  846. {
  847. WARN_ON(!ap->ops->error_handler);
  848. if (ap->pflags & ATA_PFLAG_INITIALIZING)
  849. return;
  850. ata_eh_set_pending(ap, 1);
  851. scsi_schedule_eh(ap->scsi_host);
  852. DPRINTK("port EH scheduled\n");
  853. }
  854. EXPORT_SYMBOL_GPL(ata_std_sched_eh);
  855. /**
  856. * ata_std_end_eh - non-libsas ata_ports complete eh with this common routine
  857. * @ap: ATA port to end EH for
  858. *
  859. * In the libata object model there is a 1:1 mapping of ata_port to
  860. * shost, so host fields can be directly manipulated under ap->lock, in
  861. * the libsas case we need to hold a lock at the ha->level to coordinate
  862. * these events.
  863. *
  864. * LOCKING:
  865. * spin_lock_irqsave(host lock)
  866. */
  867. void ata_std_end_eh(struct ata_port *ap)
  868. {
  869. struct Scsi_Host *host = ap->scsi_host;
  870. host->host_eh_scheduled = 0;
  871. }
  872. EXPORT_SYMBOL(ata_std_end_eh);
  873. /**
  874. * ata_port_schedule_eh - schedule error handling without a qc
  875. * @ap: ATA port to schedule EH for
  876. *
  877. * Schedule error handling for @ap. EH will kick in as soon as
  878. * all commands are drained.
  879. *
  880. * LOCKING:
  881. * spin_lock_irqsave(host lock)
  882. */
  883. void ata_port_schedule_eh(struct ata_port *ap)
  884. {
  885. /* see: ata_std_sched_eh, unless you know better */
  886. ap->ops->sched_eh(ap);
  887. }
  888. static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
  889. {
  890. int tag, nr_aborted = 0;
  891. WARN_ON(!ap->ops->error_handler);
  892. /* we're gonna abort all commands, no need for fast drain */
  893. ata_eh_set_pending(ap, 0);
  894. for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
  895. struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
  896. if (qc && (!link || qc->dev->link == link)) {
  897. qc->flags |= ATA_QCFLAG_FAILED;
  898. ata_qc_complete(qc);
  899. nr_aborted++;
  900. }
  901. }
  902. if (!nr_aborted)
  903. ata_port_schedule_eh(ap);
  904. return nr_aborted;
  905. }
  906. /**
  907. * ata_link_abort - abort all qc's on the link
  908. * @link: ATA link to abort qc's for
  909. *
  910. * Abort all active qc's active on @link and schedule EH.
  911. *
  912. * LOCKING:
  913. * spin_lock_irqsave(host lock)
  914. *
  915. * RETURNS:
  916. * Number of aborted qc's.
  917. */
  918. int ata_link_abort(struct ata_link *link)
  919. {
  920. return ata_do_link_abort(link->ap, link);
  921. }
  922. /**
  923. * ata_port_abort - abort all qc's on the port
  924. * @ap: ATA port to abort qc's for
  925. *
  926. * Abort all active qc's of @ap and schedule EH.
  927. *
  928. * LOCKING:
  929. * spin_lock_irqsave(host_set lock)
  930. *
  931. * RETURNS:
  932. * Number of aborted qc's.
  933. */
  934. int ata_port_abort(struct ata_port *ap)
  935. {
  936. return ata_do_link_abort(ap, NULL);
  937. }
  938. /**
  939. * __ata_port_freeze - freeze port
  940. * @ap: ATA port to freeze
  941. *
  942. * This function is called when HSM violation or some other
  943. * condition disrupts normal operation of the port. Frozen port
  944. * is not allowed to perform any operation until the port is
  945. * thawed, which usually follows a successful reset.
  946. *
  947. * ap->ops->freeze() callback can be used for freezing the port
  948. * hardware-wise (e.g. mask interrupt and stop DMA engine). If a
  949. * port cannot be frozen hardware-wise, the interrupt handler
  950. * must ack and clear interrupts unconditionally while the port
  951. * is frozen.
  952. *
  953. * LOCKING:
  954. * spin_lock_irqsave(host lock)
  955. */
  956. static void __ata_port_freeze(struct ata_port *ap)
  957. {
  958. WARN_ON(!ap->ops->error_handler);
  959. if (ap->ops->freeze)
  960. ap->ops->freeze(ap);
  961. ap->pflags |= ATA_PFLAG_FROZEN;
  962. DPRINTK("ata%u port frozen\n", ap->print_id);
  963. }
  964. /**
  965. * ata_port_freeze - abort & freeze port
  966. * @ap: ATA port to freeze
  967. *
  968. * Abort and freeze @ap. The freeze operation must be called
  969. * first, because some hardware requires special operations
  970. * before the taskfile registers are accessible.
  971. *
  972. * LOCKING:
  973. * spin_lock_irqsave(host lock)
  974. *
  975. * RETURNS:
  976. * Number of aborted commands.
  977. */
  978. int ata_port_freeze(struct ata_port *ap)
  979. {
  980. int nr_aborted;
  981. WARN_ON(!ap->ops->error_handler);
  982. __ata_port_freeze(ap);
  983. nr_aborted = ata_port_abort(ap);
  984. return nr_aborted;
  985. }
  986. /**
  987. * sata_async_notification - SATA async notification handler
  988. * @ap: ATA port where async notification is received
  989. *
  990. * Handler to be called when async notification via SDB FIS is
  991. * received. This function schedules EH if necessary.
  992. *
  993. * LOCKING:
  994. * spin_lock_irqsave(host lock)
  995. *
  996. * RETURNS:
  997. * 1 if EH is scheduled, 0 otherwise.
  998. */
  999. int sata_async_notification(struct ata_port *ap)
  1000. {
  1001. u32 sntf;
  1002. int rc;
  1003. if (!(ap->flags & ATA_FLAG_AN))
  1004. return 0;
  1005. rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
  1006. if (rc == 0)
  1007. sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
  1008. if (!sata_pmp_attached(ap) || rc) {
  1009. /* PMP is not attached or SNTF is not available */
  1010. if (!sata_pmp_attached(ap)) {
  1011. /* PMP is not attached. Check whether ATAPI
  1012. * AN is configured. If so, notify media
  1013. * change.
  1014. */
  1015. struct ata_device *dev = ap->link.device;
  1016. if ((dev->class == ATA_DEV_ATAPI) &&
  1017. (dev->flags & ATA_DFLAG_AN))
  1018. ata_scsi_media_change_notify(dev);
  1019. return 0;
  1020. } else {
  1021. /* PMP is attached but SNTF is not available.
  1022. * ATAPI async media change notification is
  1023. * not used. The PMP must be reporting PHY
  1024. * status change, schedule EH.
  1025. */
  1026. ata_port_schedule_eh(ap);
  1027. return 1;
  1028. }
  1029. } else {
  1030. /* PMP is attached and SNTF is available */
  1031. struct ata_link *link;
  1032. /* check and notify ATAPI AN */
  1033. ata_for_each_link(link, ap, EDGE) {
  1034. if (!(sntf & (1 << link->pmp)))
  1035. continue;
  1036. if ((link->device->class == ATA_DEV_ATAPI) &&
  1037. (link->device->flags & ATA_DFLAG_AN))
  1038. ata_scsi_media_change_notify(link->device);
  1039. }
  1040. /* If PMP is reporting that PHY status of some
  1041. * downstream ports has changed, schedule EH.
  1042. */
  1043. if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
  1044. ata_port_schedule_eh(ap);
  1045. return 1;
  1046. }
  1047. return 0;
  1048. }
  1049. }
  1050. /**
  1051. * ata_eh_freeze_port - EH helper to freeze port
  1052. * @ap: ATA port to freeze
  1053. *
  1054. * Freeze @ap.
  1055. *
  1056. * LOCKING:
  1057. * None.
  1058. */
  1059. void ata_eh_freeze_port(struct ata_port *ap)
  1060. {
  1061. unsigned long flags;
  1062. if (!ap->ops->error_handler)
  1063. return;
  1064. spin_lock_irqsave(ap->lock, flags);
  1065. __ata_port_freeze(ap);
  1066. spin_unlock_irqrestore(ap->lock, flags);
  1067. }
  1068. /**
  1069. * ata_port_thaw_port - EH helper to thaw port
  1070. * @ap: ATA port to thaw
  1071. *
  1072. * Thaw frozen port @ap.
  1073. *
  1074. * LOCKING:
  1075. * None.
  1076. */
  1077. void ata_eh_thaw_port(struct ata_port *ap)
  1078. {
  1079. unsigned long flags;
  1080. if (!ap->ops->error_handler)
  1081. return;
  1082. spin_lock_irqsave(ap->lock, flags);
  1083. ap->pflags &= ~ATA_PFLAG_FROZEN;
  1084. if (ap->ops->thaw)
  1085. ap->ops->thaw(ap);
  1086. spin_unlock_irqrestore(ap->lock, flags);
  1087. DPRINTK("ata%u port thawed\n", ap->print_id);
  1088. }
  1089. static void ata_eh_scsidone(struct scsi_cmnd *scmd)
  1090. {
  1091. /* nada */
  1092. }
  1093. static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
  1094. {
  1095. struct ata_port *ap = qc->ap;
  1096. struct scsi_cmnd *scmd = qc->scsicmd;
  1097. unsigned long flags;
  1098. spin_lock_irqsave(ap->lock, flags);
  1099. qc->scsidone = ata_eh_scsidone;
  1100. __ata_qc_complete(qc);
  1101. WARN_ON(ata_tag_valid(qc->tag));
  1102. spin_unlock_irqrestore(ap->lock, flags);
  1103. scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
  1104. }
  1105. /**
  1106. * ata_eh_qc_complete - Complete an active ATA command from EH
  1107. * @qc: Command to complete
  1108. *
  1109. * Indicate to the mid and upper layers that an ATA command has
  1110. * completed. To be used from EH.
  1111. */
  1112. void ata_eh_qc_complete(struct ata_queued_cmd *qc)
  1113. {
  1114. struct scsi_cmnd *scmd = qc->scsicmd;
  1115. scmd->retries = scmd->allowed;
  1116. __ata_eh_qc_complete(qc);
  1117. }
  1118. /**
  1119. * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
  1120. * @qc: Command to retry
  1121. *
  1122. * Indicate to the mid and upper layers that an ATA command
  1123. * should be retried. To be used from EH.
  1124. *
  1125. * SCSI midlayer limits the number of retries to scmd->allowed.
  1126. * scmd->allowed is incremented for commands which get retried
  1127. * due to unrelated failures (qc->err_mask is zero).
  1128. */
  1129. void ata_eh_qc_retry(struct ata_queued_cmd *qc)
  1130. {
  1131. struct scsi_cmnd *scmd = qc->scsicmd;
  1132. if (!qc->err_mask)
  1133. scmd->allowed++;
  1134. __ata_eh_qc_complete(qc);
  1135. }
  1136. /**
  1137. * ata_dev_disable - disable ATA device
  1138. * @dev: ATA device to disable
  1139. *
  1140. * Disable @dev.
  1141. *
  1142. * Locking:
  1143. * EH context.
  1144. */
  1145. void ata_dev_disable(struct ata_device *dev)
  1146. {
  1147. if (!ata_dev_enabled(dev))
  1148. return;
  1149. if (ata_msg_drv(dev->link->ap))
  1150. ata_dev_warn(dev, "disabled\n");
  1151. ata_acpi_on_disable(dev);
  1152. ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
  1153. dev->class++;
  1154. /* From now till the next successful probe, ering is used to
  1155. * track probe failures. Clear accumulated device error info.
  1156. */
  1157. ata_ering_clear(&dev->ering);
  1158. }
  1159. /**
  1160. * ata_eh_detach_dev - detach ATA device
  1161. * @dev: ATA device to detach
  1162. *
  1163. * Detach @dev.
  1164. *
  1165. * LOCKING:
  1166. * None.
  1167. */
  1168. void ata_eh_detach_dev(struct ata_device *dev)
  1169. {
  1170. struct ata_link *link = dev->link;
  1171. struct ata_port *ap = link->ap;
  1172. struct ata_eh_context *ehc = &link->eh_context;
  1173. unsigned long flags;
  1174. ata_dev_disable(dev);
  1175. spin_lock_irqsave(ap->lock, flags);
  1176. dev->flags &= ~ATA_DFLAG_DETACH;
  1177. if (ata_scsi_offline_dev(dev)) {
  1178. dev->flags |= ATA_DFLAG_DETACHED;
  1179. ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
  1180. }
  1181. /* clear per-dev EH info */
  1182. ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
  1183. ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
  1184. ehc->saved_xfer_mode[dev->devno] = 0;
  1185. ehc->saved_ncq_enabled &= ~(1 << dev->devno);
  1186. spin_unlock_irqrestore(ap->lock, flags);
  1187. }
  1188. /**
  1189. * ata_eh_about_to_do - about to perform eh_action
  1190. * @link: target ATA link
  1191. * @dev: target ATA dev for per-dev action (can be NULL)
  1192. * @action: action about to be performed
  1193. *
  1194. * Called just before performing EH actions to clear related bits
  1195. * in @link->eh_info such that eh actions are not unnecessarily
  1196. * repeated.
  1197. *
  1198. * LOCKING:
  1199. * None.
  1200. */
  1201. void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
  1202. unsigned int action)
  1203. {
  1204. struct ata_port *ap = link->ap;
  1205. struct ata_eh_info *ehi = &link->eh_info;
  1206. struct ata_eh_context *ehc = &link->eh_context;
  1207. unsigned long flags;
  1208. spin_lock_irqsave(ap->lock, flags);
  1209. ata_eh_clear_action(link, dev, ehi, action);
  1210. /* About to take EH action, set RECOVERED. Ignore actions on
  1211. * slave links as master will do them again.
  1212. */
  1213. if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
  1214. ap->pflags |= ATA_PFLAG_RECOVERED;
  1215. spin_unlock_irqrestore(ap->lock, flags);
  1216. }
  1217. /**
  1218. * ata_eh_done - EH action complete
  1219. * @ap: target ATA port
  1220. * @dev: target ATA dev for per-dev action (can be NULL)
  1221. * @action: action just completed
  1222. *
  1223. * Called right after performing EH actions to clear related bits
  1224. * in @link->eh_context.
  1225. *
  1226. * LOCKING:
  1227. * None.
  1228. */
  1229. void ata_eh_done(struct ata_link *link, struct ata_device *dev,
  1230. unsigned int action)
  1231. {
  1232. struct ata_eh_context *ehc = &link->eh_context;
  1233. ata_eh_clear_action(link, dev, &ehc->i, action);
  1234. }
  1235. /**
  1236. * ata_err_string - convert err_mask to descriptive string
  1237. * @err_mask: error mask to convert to string
  1238. *
  1239. * Convert @err_mask to descriptive string. Errors are
  1240. * prioritized according to severity and only the most severe
  1241. * error is reported.
  1242. *
  1243. * LOCKING:
  1244. * None.
  1245. *
  1246. * RETURNS:
  1247. * Descriptive string for @err_mask
  1248. */
  1249. static const char *ata_err_string(unsigned int err_mask)
  1250. {
  1251. if (err_mask & AC_ERR_HOST_BUS)
  1252. return "host bus error";
  1253. if (err_mask & AC_ERR_ATA_BUS)
  1254. return "ATA bus error";
  1255. if (err_mask & AC_ERR_TIMEOUT)
  1256. return "timeout";
  1257. if (err_mask & AC_ERR_HSM)
  1258. return "HSM violation";
  1259. if (err_mask & AC_ERR_SYSTEM)
  1260. return "internal error";
  1261. if (err_mask & AC_ERR_MEDIA)
  1262. return "media error";
  1263. if (err_mask & AC_ERR_INVALID)
  1264. return "invalid argument";
  1265. if (err_mask & AC_ERR_DEV)
  1266. return "device error";
  1267. return "unknown error";
  1268. }
  1269. /**
  1270. * ata_read_log_page - read a specific log page
  1271. * @dev: target device
  1272. * @log: log to read
  1273. * @page: page to read
  1274. * @buf: buffer to store read page
  1275. * @sectors: number of sectors to read
  1276. *
  1277. * Read log page using READ_LOG_EXT command.
  1278. *
  1279. * LOCKING:
  1280. * Kernel thread context (may sleep).
  1281. *
  1282. * RETURNS:
  1283. * 0 on success, AC_ERR_* mask otherwise.
  1284. */
  1285. unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
  1286. u8 page, void *buf, unsigned int sectors)
  1287. {
  1288. struct ata_taskfile tf;
  1289. unsigned int err_mask;
  1290. DPRINTK("read log page - log 0x%x, page 0x%x\n", log, page);
  1291. ata_tf_init(dev, &tf);
  1292. tf.command = ATA_CMD_READ_LOG_EXT;
  1293. tf.lbal = log;
  1294. tf.lbam = page;
  1295. tf.nsect = sectors;
  1296. tf.hob_nsect = sectors >> 8;
  1297. tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
  1298. tf.protocol = ATA_PROT_PIO;
  1299. err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
  1300. buf, sectors * ATA_SECT_SIZE, 0);
  1301. DPRINTK("EXIT, err_mask=%x\n", err_mask);
  1302. return err_mask;
  1303. }
  1304. /**
  1305. * ata_eh_read_log_10h - Read log page 10h for NCQ error details
  1306. * @dev: Device to read log page 10h from
  1307. * @tag: Resulting tag of the failed command
  1308. * @tf: Resulting taskfile registers of the failed command
  1309. *
  1310. * Read log page 10h to obtain NCQ error details and clear error
  1311. * condition.
  1312. *
  1313. * LOCKING:
  1314. * Kernel thread context (may sleep).
  1315. *
  1316. * RETURNS:
  1317. * 0 on success, -errno otherwise.
  1318. */
  1319. static int ata_eh_read_log_10h(struct ata_device *dev,
  1320. int *tag, struct ata_taskfile *tf)
  1321. {
  1322. u8 *buf = dev->link->ap->sector_buf;
  1323. unsigned int err_mask;
  1324. u8 csum;
  1325. int i;
  1326. err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, 0, buf, 1);
  1327. if (err_mask)
  1328. return -EIO;
  1329. csum = 0;
  1330. for (i = 0; i < ATA_SECT_SIZE; i++)
  1331. csum += buf[i];
  1332. if (csum)
  1333. ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n",
  1334. csum);
  1335. if (buf[0] & 0x80)
  1336. return -ENOENT;
  1337. *tag = buf[0] & 0x1f;
  1338. tf->command = buf[2];
  1339. tf->feature = buf[3];
  1340. tf->lbal = buf[4];
  1341. tf->lbam = buf[5];
  1342. tf->lbah = buf[6];
  1343. tf->device = buf[7];
  1344. tf->hob_lbal = buf[8];
  1345. tf->hob_lbam = buf[9];
  1346. tf->hob_lbah = buf[10];
  1347. tf->nsect = buf[12];
  1348. tf->hob_nsect = buf[13];
  1349. return 0;
  1350. }
  1351. /**
  1352. * atapi_eh_tur - perform ATAPI TEST_UNIT_READY
  1353. * @dev: target ATAPI device
  1354. * @r_sense_key: out parameter for sense_key
  1355. *
  1356. * Perform ATAPI TEST_UNIT_READY.
  1357. *
  1358. * LOCKING:
  1359. * EH context (may sleep).
  1360. *
  1361. * RETURNS:
  1362. * 0 on success, AC_ERR_* mask on failure.
  1363. */
  1364. unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
  1365. {
  1366. u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
  1367. struct ata_taskfile tf;
  1368. unsigned int err_mask;
  1369. ata_tf_init(dev, &tf);
  1370. tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
  1371. tf.command = ATA_CMD_PACKET;
  1372. tf.protocol = ATAPI_PROT_NODATA;
  1373. err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
  1374. if (err_mask == AC_ERR_DEV)
  1375. *r_sense_key = tf.feature >> 4;
  1376. return err_mask;
  1377. }
  1378. /**
  1379. * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
  1380. * @dev: device to perform REQUEST_SENSE to
  1381. * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
  1382. * @dfl_sense_key: default sense key to use
  1383. *
  1384. * Perform ATAPI REQUEST_SENSE after the device reported CHECK
  1385. * SENSE. This function is EH helper.
  1386. *
  1387. * LOCKING:
  1388. * Kernel thread context (may sleep).
  1389. *
  1390. * RETURNS:
  1391. * 0 on success, AC_ERR_* mask on failure
  1392. */
  1393. unsigned int atapi_eh_request_sense(struct ata_device *dev,
  1394. u8 *sense_buf, u8 dfl_sense_key)
  1395. {
  1396. u8 cdb[ATAPI_CDB_LEN] =
  1397. { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
  1398. struct ata_port *ap = dev->link->ap;
  1399. struct ata_taskfile tf;
  1400. DPRINTK("ATAPI request sense\n");
  1401. /* FIXME: is this needed? */
  1402. memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
  1403. /* initialize sense_buf with the error register,
  1404. * for the case where they are -not- overwritten
  1405. */
  1406. sense_buf[0] = 0x70;
  1407. sense_buf[2] = dfl_sense_key;
  1408. /* some devices time out if garbage left in tf */
  1409. ata_tf_init(dev, &tf);
  1410. tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
  1411. tf.command = ATA_CMD_PACKET;
  1412. /* is it pointless to prefer PIO for "safety reasons"? */
  1413. if (ap->flags & ATA_FLAG_PIO_DMA) {
  1414. tf.protocol = ATAPI_PROT_DMA;
  1415. tf.feature |= ATAPI_PKT_DMA;
  1416. } else {
  1417. tf.protocol = ATAPI_PROT_PIO;
  1418. tf.lbam = SCSI_SENSE_BUFFERSIZE;
  1419. tf.lbah = 0;
  1420. }
  1421. return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
  1422. sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
  1423. }
  1424. /**
  1425. * ata_eh_analyze_serror - analyze SError for a failed port
  1426. * @link: ATA link to analyze SError for
  1427. *
  1428. * Analyze SError if available and further determine cause of
  1429. * failure.
  1430. *
  1431. * LOCKING:
  1432. * None.
  1433. */
  1434. static void ata_eh_analyze_serror(struct ata_link *link)
  1435. {
  1436. struct ata_eh_context *ehc = &link->eh_context;
  1437. u32 serror = ehc->i.serror;
  1438. unsigned int err_mask = 0, action = 0;
  1439. u32 hotplug_mask;
  1440. if (serror & (SERR_PERSISTENT | SERR_DATA)) {
  1441. err_mask |= AC_ERR_ATA_BUS;
  1442. action |= ATA_EH_RESET;
  1443. }
  1444. if (serror & SERR_PROTOCOL) {
  1445. err_mask |= AC_ERR_HSM;
  1446. action |= ATA_EH_RESET;
  1447. }
  1448. if (serror & SERR_INTERNAL) {
  1449. err_mask |= AC_ERR_SYSTEM;
  1450. action |= ATA_EH_RESET;
  1451. }
  1452. /* Determine whether a hotplug event has occurred. Both
  1453. * SError.N/X are considered hotplug events for enabled or
  1454. * host links. For disabled PMP links, only N bit is
  1455. * considered as X bit is left at 1 for link plugging.
  1456. */
  1457. if (link->lpm_policy > ATA_LPM_MAX_POWER)
  1458. hotplug_mask = 0; /* hotplug doesn't work w/ LPM */
  1459. else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
  1460. hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
  1461. else
  1462. hotplug_mask = SERR_PHYRDY_CHG;
  1463. if (serror & hotplug_mask)
  1464. ata_ehi_hotplugged(&ehc->i);
  1465. ehc->i.err_mask |= err_mask;
  1466. ehc->i.action |= action;
  1467. }
  1468. /**
  1469. * ata_eh_analyze_ncq_error - analyze NCQ error
  1470. * @link: ATA link to analyze NCQ error for
  1471. *
  1472. * Read log page 10h, determine the offending qc and acquire
  1473. * error status TF. For NCQ device errors, all LLDDs have to do
  1474. * is setting AC_ERR_DEV in ehi->err_mask. This function takes
  1475. * care of the rest.
  1476. *
  1477. * LOCKING:
  1478. * Kernel thread context (may sleep).
  1479. */
  1480. void ata_eh_analyze_ncq_error(struct ata_link *link)
  1481. {
  1482. struct ata_port *ap = link->ap;
  1483. struct ata_eh_context *ehc = &link->eh_context;
  1484. struct ata_device *dev = link->device;
  1485. struct ata_queued_cmd *qc;
  1486. struct ata_taskfile tf;
  1487. int tag, rc;
  1488. /* if frozen, we can't do much */
  1489. if (ap->pflags & ATA_PFLAG_FROZEN)
  1490. return;
  1491. /* is it NCQ device error? */
  1492. if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
  1493. return;
  1494. /* has LLDD analyzed already? */
  1495. for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
  1496. qc = __ata_qc_from_tag(ap, tag);
  1497. if (!(qc->flags & ATA_QCFLAG_FAILED))
  1498. continue;
  1499. if (qc->err_mask)
  1500. return;
  1501. }
  1502. /* okay, this error is ours */
  1503. memset(&tf, 0, sizeof(tf));
  1504. rc = ata_eh_read_log_10h(dev, &tag, &tf);
  1505. if (rc) {
  1506. ata_link_err(link, "failed to read log page 10h (errno=%d)\n",
  1507. rc);
  1508. return;
  1509. }
  1510. if (!(link->sactive & (1 << tag))) {
  1511. ata_link_err(link, "log page 10h reported inactive tag %d\n",
  1512. tag);
  1513. return;
  1514. }
  1515. /* we've got the perpetrator, condemn it */
  1516. qc = __ata_qc_from_tag(ap, tag);
  1517. memcpy(&qc->result_tf, &tf, sizeof(tf));
  1518. qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
  1519. qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
  1520. ehc->i.err_mask &= ~AC_ERR_DEV;
  1521. }
  1522. /**
  1523. * ata_eh_analyze_tf - analyze taskfile of a failed qc
  1524. * @qc: qc to analyze
  1525. * @tf: Taskfile registers to analyze
  1526. *
  1527. * Analyze taskfile of @qc and further determine cause of
  1528. * failure. This function also requests ATAPI sense data if
  1529. * available.
  1530. *
  1531. * LOCKING:
  1532. * Kernel thread context (may sleep).
  1533. *
  1534. * RETURNS:
  1535. * Determined recovery action
  1536. */
  1537. static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
  1538. const struct ata_taskfile *tf)
  1539. {
  1540. unsigned int tmp, action = 0;
  1541. u8 stat = tf->command, err = tf->feature;
  1542. if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
  1543. qc->err_mask |= AC_ERR_HSM;
  1544. return ATA_EH_RESET;
  1545. }
  1546. if (stat & (ATA_ERR | ATA_DF))
  1547. qc->err_mask |= AC_ERR_DEV;
  1548. else
  1549. return 0;
  1550. switch (qc->dev->class) {
  1551. case ATA_DEV_ATA:
  1552. if (err & ATA_ICRC)
  1553. qc->err_mask |= AC_ERR_ATA_BUS;
  1554. if (err & ATA_UNC)
  1555. qc->err_mask |= AC_ERR_MEDIA;
  1556. if (err & ATA_IDNF)
  1557. qc->err_mask |= AC_ERR_INVALID;
  1558. break;
  1559. case ATA_DEV_ATAPI:
  1560. if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
  1561. tmp = atapi_eh_request_sense(qc->dev,
  1562. qc->scsicmd->sense_buffer,
  1563. qc->result_tf.feature >> 4);
  1564. if (!tmp) {
  1565. /* ATA_QCFLAG_SENSE_VALID is used to
  1566. * tell atapi_qc_complete() that sense
  1567. * data is already valid.
  1568. *
  1569. * TODO: interpret sense data and set
  1570. * appropriate err_mask.
  1571. */
  1572. qc->flags |= ATA_QCFLAG_SENSE_VALID;
  1573. } else
  1574. qc->err_mask |= tmp;
  1575. }
  1576. }
  1577. if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
  1578. action |= ATA_EH_RESET;
  1579. return action;
  1580. }
  1581. static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
  1582. int *xfer_ok)
  1583. {
  1584. int base = 0;
  1585. if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
  1586. *xfer_ok = 1;
  1587. if (!*xfer_ok)
  1588. base = ATA_ECAT_DUBIOUS_NONE;
  1589. if (err_mask & AC_ERR_ATA_BUS)
  1590. return base + ATA_ECAT_ATA_BUS;
  1591. if (err_mask & AC_ERR_TIMEOUT)
  1592. return base + ATA_ECAT_TOUT_HSM;
  1593. if (eflags & ATA_EFLAG_IS_IO) {
  1594. if (err_mask & AC_ERR_HSM)
  1595. return base + ATA_ECAT_TOUT_HSM;
  1596. if ((err_mask &
  1597. (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
  1598. return base + ATA_ECAT_UNK_DEV;
  1599. }
  1600. return 0;
  1601. }
  1602. struct speed_down_verdict_arg {
  1603. u64 since;
  1604. int xfer_ok;
  1605. int nr_errors[ATA_ECAT_NR];
  1606. };
  1607. static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
  1608. {
  1609. struct speed_down_verdict_arg *arg = void_arg;
  1610. int cat;
  1611. if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since))
  1612. return -1;
  1613. cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
  1614. &arg->xfer_ok);
  1615. arg->nr_errors[cat]++;
  1616. return 0;
  1617. }
  1618. /**
  1619. * ata_eh_speed_down_verdict - Determine speed down verdict
  1620. * @dev: Device of interest
  1621. *
  1622. * This function examines error ring of @dev and determines
  1623. * whether NCQ needs to be turned off, transfer speed should be
  1624. * stepped down, or falling back to PIO is necessary.
  1625. *
  1626. * ECAT_ATA_BUS : ATA_BUS error for any command
  1627. *
  1628. * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for
  1629. * IO commands
  1630. *
  1631. * ECAT_UNK_DEV : Unknown DEV error for IO commands
  1632. *
  1633. * ECAT_DUBIOUS_* : Identical to above three but occurred while
  1634. * data transfer hasn't been verified.
  1635. *
  1636. * Verdicts are
  1637. *
  1638. * NCQ_OFF : Turn off NCQ.
  1639. *
  1640. * SPEED_DOWN : Speed down transfer speed but don't fall back
  1641. * to PIO.
  1642. *
  1643. * FALLBACK_TO_PIO : Fall back to PIO.
  1644. *
  1645. * Even if multiple verdicts are returned, only one action is
  1646. * taken per error. An action triggered by non-DUBIOUS errors
  1647. * clears ering, while one triggered by DUBIOUS_* errors doesn't.
  1648. * This is to expedite speed down decisions right after device is
  1649. * initially configured.
  1650. *
  1651. * The followings are speed down rules. #1 and #2 deal with
  1652. * DUBIOUS errors.
  1653. *
  1654. * 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
  1655. * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
  1656. *
  1657. * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
  1658. * occurred during last 5 mins, NCQ_OFF.
  1659. *
  1660. * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
  1661. * occurred during last 5 mins, FALLBACK_TO_PIO
  1662. *
  1663. * 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
  1664. * during last 10 mins, NCQ_OFF.
  1665. *
  1666. * 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
  1667. * UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
  1668. *
  1669. * LOCKING:
  1670. * Inherited from caller.
  1671. *
  1672. * RETURNS:
  1673. * OR of ATA_EH_SPDN_* flags.
  1674. */
  1675. static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
  1676. {
  1677. const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
  1678. u64 j64 = get_jiffies_64();
  1679. struct speed_down_verdict_arg arg;
  1680. unsigned int verdict = 0;
  1681. /* scan past 5 mins of error history */
  1682. memset(&arg, 0, sizeof(arg));
  1683. arg.since = j64 - min(j64, j5mins);
  1684. ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
  1685. if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
  1686. arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
  1687. verdict |= ATA_EH_SPDN_SPEED_DOWN |
  1688. ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
  1689. if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
  1690. arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
  1691. verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
  1692. if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
  1693. arg.nr_errors[ATA_ECAT_TOUT_HSM] +
  1694. arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
  1695. verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
  1696. /* scan past 10 mins of error history */
  1697. memset(&arg, 0, sizeof(arg));
  1698. arg.since = j64 - min(j64, j10mins);
  1699. ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
  1700. if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
  1701. arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
  1702. verdict |= ATA_EH_SPDN_NCQ_OFF;
  1703. if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
  1704. arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
  1705. arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
  1706. verdict |= ATA_EH_SPDN_SPEED_DOWN;
  1707. return verdict;
  1708. }
  1709. /**
  1710. * ata_eh_speed_down - record error and speed down if necessary
  1711. * @dev: Failed device
  1712. * @eflags: mask of ATA_EFLAG_* flags
  1713. * @err_mask: err_mask of the error
  1714. *
  1715. * Record error and examine error history to determine whether
  1716. * adjusting transmission speed is necessary. It also sets
  1717. * transmission limits appropriately if such adjustment is
  1718. * necessary.
  1719. *
  1720. * LOCKING:
  1721. * Kernel thread context (may sleep).
  1722. *
  1723. * RETURNS:
  1724. * Determined recovery action.
  1725. */
  1726. static unsigned int ata_eh_speed_down(struct ata_device *dev,
  1727. unsigned int eflags, unsigned int err_mask)
  1728. {
  1729. struct ata_link *link = ata_dev_phys_link(dev);
  1730. int xfer_ok = 0;
  1731. unsigned int verdict;
  1732. unsigned int action = 0;
  1733. /* don't bother if Cat-0 error */
  1734. if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
  1735. return 0;
  1736. /* record error and determine whether speed down is necessary */
  1737. ata_ering_record(&dev->ering, eflags, err_mask);
  1738. verdict = ata_eh_speed_down_verdict(dev);
  1739. /* turn off NCQ? */
  1740. if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
  1741. (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
  1742. ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
  1743. dev->flags |= ATA_DFLAG_NCQ_OFF;
  1744. ata_dev_warn(dev, "NCQ disabled due to excessive errors\n");
  1745. goto done;
  1746. }
  1747. /* speed down? */
  1748. if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
  1749. /* speed down SATA link speed if possible */
  1750. if (sata_down_spd_limit(link, 0) == 0) {
  1751. action |= ATA_EH_RESET;
  1752. goto done;
  1753. }
  1754. /* lower transfer mode */
  1755. if (dev->spdn_cnt < 2) {
  1756. static const int dma_dnxfer_sel[] =
  1757. { ATA_DNXFER_DMA, ATA_DNXFER_40C };
  1758. static const int pio_dnxfer_sel[] =
  1759. { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
  1760. int sel;
  1761. if (dev->xfer_shift != ATA_SHIFT_PIO)
  1762. sel = dma_dnxfer_sel[dev->spdn_cnt];
  1763. else
  1764. sel = pio_dnxfer_sel[dev->spdn_cnt];
  1765. dev->spdn_cnt++;
  1766. if (ata_down_xfermask_limit(dev, sel) == 0) {
  1767. action |= ATA_EH_RESET;
  1768. goto done;
  1769. }
  1770. }
  1771. }
  1772. /* Fall back to PIO? Slowing down to PIO is meaningless for
  1773. * SATA ATA devices. Consider it only for PATA and SATAPI.
  1774. */
  1775. if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
  1776. (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
  1777. (dev->xfer_shift != ATA_SHIFT_PIO)) {
  1778. if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
  1779. dev->spdn_cnt = 0;
  1780. action |= ATA_EH_RESET;
  1781. goto done;
  1782. }
  1783. }
  1784. return 0;
  1785. done:
  1786. /* device has been slowed down, blow error history */
  1787. if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
  1788. ata_ering_clear(&dev->ering);
  1789. return action;
  1790. }
  1791. /**
  1792. * ata_eh_worth_retry - analyze error and decide whether to retry
  1793. * @qc: qc to possibly retry
  1794. *
  1795. * Look at the cause of the error and decide if a retry
  1796. * might be useful or not. We don't want to retry media errors
  1797. * because the drive itself has probably already taken 10-30 seconds
  1798. * doing its own internal retries before reporting the failure.
  1799. */
  1800. static inline int ata_eh_worth_retry(struct ata_queued_cmd *qc)
  1801. {
  1802. if (qc->err_mask & AC_ERR_MEDIA)
  1803. return 0; /* don't retry media errors */
  1804. if (qc->flags & ATA_QCFLAG_IO)
  1805. return 1; /* otherwise retry anything from fs stack */
  1806. if (qc->err_mask & AC_ERR_INVALID)
  1807. return 0; /* don't retry these */
  1808. return qc->err_mask != AC_ERR_DEV; /* retry if not dev error */
  1809. }
  1810. /**
  1811. * ata_eh_link_autopsy - analyze error and determine recovery action
  1812. * @link: host link to perform autopsy on
  1813. *
  1814. * Analyze why @link failed and determine which recovery actions
  1815. * are needed. This function also sets more detailed AC_ERR_*
  1816. * values and fills sense data for ATAPI CHECK SENSE.
  1817. *
  1818. * LOCKING:
  1819. * Kernel thread context (may sleep).
  1820. */
  1821. static void ata_eh_link_autopsy(struct ata_link *link)
  1822. {
  1823. struct ata_port *ap = link->ap;
  1824. struct ata_eh_context *ehc = &link->eh_context;
  1825. struct ata_device *dev;
  1826. unsigned int all_err_mask = 0, eflags = 0;
  1827. int tag;
  1828. u32 serror;
  1829. int rc;
  1830. DPRINTK("ENTER\n");
  1831. if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
  1832. return;
  1833. /* obtain and analyze SError */
  1834. rc = sata_scr_read(link, SCR_ERROR, &serror);
  1835. if (rc == 0) {
  1836. ehc->i.serror |= serror;
  1837. ata_eh_analyze_serror(link);
  1838. } else if (rc != -EOPNOTSUPP) {
  1839. /* SError read failed, force reset and probing */
  1840. ehc->i.probe_mask |= ATA_ALL_DEVICES;
  1841. ehc->i.action |= ATA_EH_RESET;
  1842. ehc->i.err_mask |= AC_ERR_OTHER;
  1843. }
  1844. /* analyze NCQ failure */
  1845. ata_eh_analyze_ncq_error(link);
  1846. /* any real error trumps AC_ERR_OTHER */
  1847. if (ehc->i.err_mask & ~AC_ERR_OTHER)
  1848. ehc->i.err_mask &= ~AC_ERR_OTHER;
  1849. all_err_mask |= ehc->i.err_mask;
  1850. for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
  1851. struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
  1852. if (!(qc->flags & ATA_QCFLAG_FAILED) ||
  1853. ata_dev_phys_link(qc->dev) != link)
  1854. continue;
  1855. /* inherit upper level err_mask */
  1856. qc->err_mask |= ehc->i.err_mask;
  1857. /* analyze TF */
  1858. ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
  1859. /* DEV errors are probably spurious in case of ATA_BUS error */
  1860. if (qc->err_mask & AC_ERR_ATA_BUS)
  1861. qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
  1862. AC_ERR_INVALID);
  1863. /* any real error trumps unknown error */
  1864. if (qc->err_mask & ~AC_ERR_OTHER)
  1865. qc->err_mask &= ~AC_ERR_OTHER;
  1866. /* SENSE_VALID trumps dev/unknown error and revalidation */
  1867. if (qc->flags & ATA_QCFLAG_SENSE_VALID)
  1868. qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
  1869. /* determine whether the command is worth retrying */
  1870. if (ata_eh_worth_retry(qc))
  1871. qc->flags |= ATA_QCFLAG_RETRY;
  1872. /* accumulate error info */
  1873. ehc->i.dev = qc->dev;
  1874. all_err_mask |= qc->err_mask;
  1875. if (qc->flags & ATA_QCFLAG_IO)
  1876. eflags |= ATA_EFLAG_IS_IO;
  1877. }
  1878. /* enforce default EH actions */
  1879. if (ap->pflags & ATA_PFLAG_FROZEN ||
  1880. all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
  1881. ehc->i.action |= ATA_EH_RESET;
  1882. else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
  1883. (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
  1884. ehc->i.action |= ATA_EH_REVALIDATE;
  1885. /* If we have offending qcs and the associated failed device,
  1886. * perform per-dev EH action only on the offending device.
  1887. */
  1888. if (ehc->i.dev) {
  1889. ehc->i.dev_action[ehc->i.dev->devno] |=
  1890. ehc->i.action & ATA_EH_PERDEV_MASK;
  1891. ehc->i.action &= ~ATA_EH_PERDEV_MASK;
  1892. }
  1893. /* propagate timeout to host link */
  1894. if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
  1895. ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
  1896. /* record error and consider speeding down */
  1897. dev = ehc->i.dev;
  1898. if (!dev && ((ata_link_max_devices(link) == 1 &&
  1899. ata_dev_enabled(link->device))))
  1900. dev = link->device;
  1901. if (dev) {
  1902. if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
  1903. eflags |= ATA_EFLAG_DUBIOUS_XFER;
  1904. ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
  1905. }
  1906. DPRINTK("EXIT\n");
  1907. }
  1908. /**
  1909. * ata_eh_autopsy - analyze error and determine recovery action
  1910. * @ap: host port to perform autopsy on
  1911. *
  1912. * Analyze all links of @ap and determine why they failed and
  1913. * which recovery actions are needed.
  1914. *
  1915. * LOCKING:
  1916. * Kernel thread context (may sleep).
  1917. */
  1918. void ata_eh_autopsy(struct ata_port *ap)
  1919. {
  1920. struct ata_link *link;
  1921. ata_for_each_link(link, ap, EDGE)
  1922. ata_eh_link_autopsy(link);
  1923. /* Handle the frigging slave link. Autopsy is done similarly
  1924. * but actions and flags are transferred over to the master
  1925. * link and handled from there.
  1926. */
  1927. if (ap->slave_link) {
  1928. struct ata_eh_context *mehc = &ap->link.eh_context;
  1929. struct ata_eh_context *sehc = &ap->slave_link->eh_context;
  1930. /* transfer control flags from master to slave */
  1931. sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK;
  1932. /* perform autopsy on the slave link */
  1933. ata_eh_link_autopsy(ap->slave_link);
  1934. /* transfer actions from slave to master and clear slave */
  1935. ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
  1936. mehc->i.action |= sehc->i.action;
  1937. mehc->i.dev_action[1] |= sehc->i.dev_action[1];
  1938. mehc->i.flags |= sehc->i.flags;
  1939. ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
  1940. }
  1941. /* Autopsy of fanout ports can affect host link autopsy.
  1942. * Perform host link autopsy last.
  1943. */
  1944. if (sata_pmp_attached(ap))
  1945. ata_eh_link_autopsy(&ap->link);
  1946. }
  1947. /**
  1948. * ata_get_cmd_descript - get description for ATA command
  1949. * @command: ATA command code to get description for
  1950. *
  1951. * Return a textual description of the given command, or NULL if the
  1952. * command is not known.
  1953. *
  1954. * LOCKING:
  1955. * None
  1956. */
  1957. const char *ata_get_cmd_descript(u8 command)
  1958. {
  1959. #ifdef CONFIG_ATA_VERBOSE_ERROR
  1960. static const struct
  1961. {
  1962. u8 command;
  1963. const char *text;
  1964. } cmd_descr[] = {
  1965. { ATA_CMD_DEV_RESET, "DEVICE RESET" },
  1966. { ATA_CMD_CHK_POWER, "CHECK POWER MODE" },
  1967. { ATA_CMD_STANDBY, "STANDBY" },
  1968. { ATA_CMD_IDLE, "IDLE" },
  1969. { ATA_CMD_EDD, "EXECUTE DEVICE DIAGNOSTIC" },
  1970. { ATA_CMD_DOWNLOAD_MICRO, "DOWNLOAD MICROCODE" },
  1971. { ATA_CMD_DOWNLOAD_MICRO_DMA, "DOWNLOAD MICROCODE DMA" },
  1972. { ATA_CMD_NOP, "NOP" },
  1973. { ATA_CMD_FLUSH, "FLUSH CACHE" },
  1974. { ATA_CMD_FLUSH_EXT, "FLUSH CACHE EXT" },
  1975. { ATA_CMD_ID_ATA, "IDENTIFY DEVICE" },
  1976. { ATA_CMD_ID_ATAPI, "IDENTIFY PACKET DEVICE" },
  1977. { ATA_CMD_SERVICE, "SERVICE" },
  1978. { ATA_CMD_READ, "READ DMA" },
  1979. { ATA_CMD_READ_EXT, "READ DMA EXT" },
  1980. { ATA_CMD_READ_QUEUED, "READ DMA QUEUED" },
  1981. { ATA_CMD_READ_STREAM_EXT, "READ STREAM EXT" },
  1982. { ATA_CMD_READ_STREAM_DMA_EXT, "READ STREAM DMA EXT" },
  1983. { ATA_CMD_WRITE, "WRITE DMA" },
  1984. { ATA_CMD_WRITE_EXT, "WRITE DMA EXT" },
  1985. { ATA_CMD_WRITE_QUEUED, "WRITE DMA QUEUED EXT" },
  1986. { ATA_CMD_WRITE_STREAM_EXT, "WRITE STREAM EXT" },
  1987. { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" },
  1988. { ATA_CMD_WRITE_FUA_EXT, "WRITE DMA FUA EXT" },
  1989. { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" },
  1990. { ATA_CMD_FPDMA_READ, "READ FPDMA QUEUED" },
  1991. { ATA_CMD_FPDMA_WRITE, "WRITE FPDMA QUEUED" },
  1992. { ATA_CMD_FPDMA_SEND, "SEND FPDMA QUEUED" },
  1993. { ATA_CMD_FPDMA_RECV, "RECEIVE FPDMA QUEUED" },
  1994. { ATA_CMD_PIO_READ, "READ SECTOR(S)" },
  1995. { ATA_CMD_PIO_READ_EXT, "READ SECTOR(S) EXT" },
  1996. { ATA_CMD_PIO_WRITE, "WRITE SECTOR(S)" },
  1997. { ATA_CMD_PIO_WRITE_EXT, "WRITE SECTOR(S) EXT" },
  1998. { ATA_CMD_READ_MULTI, "READ MULTIPLE" },
  1999. { ATA_CMD_READ_MULTI_EXT, "READ MULTIPLE EXT" },
  2000. { ATA_CMD_WRITE_MULTI, "WRITE MULTIPLE" },
  2001. { ATA_CMD_WRITE_MULTI_EXT, "WRITE MULTIPLE EXT" },
  2002. { ATA_CMD_WRITE_MULTI_FUA_EXT, "WRITE MULTIPLE FUA EXT" },
  2003. { ATA_CMD_SET_FEATURES, "SET FEATURES" },
  2004. { ATA_CMD_SET_MULTI, "SET MULTIPLE MODE" },
  2005. { ATA_CMD_VERIFY, "READ VERIFY SECTOR(S)" },
  2006. { ATA_CMD_VERIFY_EXT, "READ VERIFY SECTOR(S) EXT" },
  2007. { ATA_CMD_WRITE_UNCORR_EXT, "WRITE UNCORRECTABLE EXT" },
  2008. { ATA_CMD_STANDBYNOW1, "STANDBY IMMEDIATE" },
  2009. { ATA_CMD_IDLEIMMEDIATE, "IDLE IMMEDIATE" },
  2010. { ATA_CMD_SLEEP, "SLEEP" },
  2011. { ATA_CMD_INIT_DEV_PARAMS, "INITIALIZE DEVICE PARAMETERS" },
  2012. { ATA_CMD_READ_NATIVE_MAX, "READ NATIVE MAX ADDRESS" },
  2013. { ATA_CMD_READ_NATIVE_MAX_EXT, "READ NATIVE MAX ADDRESS EXT" },
  2014. { ATA_CMD_SET_MAX, "SET MAX ADDRESS" },
  2015. { ATA_CMD_SET_MAX_EXT, "SET MAX ADDRESS EXT" },
  2016. { ATA_CMD_READ_LOG_EXT, "READ LOG EXT" },
  2017. { ATA_CMD_WRITE_LOG_EXT, "WRITE LOG EXT" },
  2018. { ATA_CMD_READ_LOG_DMA_EXT, "READ LOG DMA EXT" },
  2019. { ATA_CMD_WRITE_LOG_DMA_EXT, "WRITE LOG DMA EXT" },
  2020. { ATA_CMD_TRUSTED_NONDATA, "TRUSTED NON-DATA" },
  2021. { ATA_CMD_TRUSTED_RCV, "TRUSTED RECEIVE" },
  2022. { ATA_CMD_TRUSTED_RCV_DMA, "TRUSTED RECEIVE DMA" },
  2023. { ATA_CMD_TRUSTED_SND, "TRUSTED SEND" },
  2024. { ATA_CMD_TRUSTED_SND_DMA, "TRUSTED SEND DMA" },
  2025. { ATA_CMD_PMP_READ, "READ BUFFER" },
  2026. { ATA_CMD_PMP_READ_DMA, "READ BUFFER DMA" },
  2027. { ATA_CMD_PMP_WRITE, "WRITE BUFFER" },
  2028. { ATA_CMD_PMP_WRITE_DMA, "WRITE BUFFER DMA" },
  2029. { ATA_CMD_CONF_OVERLAY, "DEVICE CONFIGURATION OVERLAY" },
  2030. { ATA_CMD_SEC_SET_PASS, "SECURITY SET PASSWORD" },
  2031. { ATA_CMD_SEC_UNLOCK, "SECURITY UNLOCK" },
  2032. { ATA_CMD_SEC_ERASE_PREP, "SECURITY ERASE PREPARE" },
  2033. { ATA_CMD_SEC_ERASE_UNIT, "SECURITY ERASE UNIT" },
  2034. { ATA_CMD_SEC_FREEZE_LOCK, "SECURITY FREEZE LOCK" },
  2035. { ATA_CMD_SEC_DISABLE_PASS, "SECURITY DISABLE PASSWORD" },
  2036. { ATA_CMD_CONFIG_STREAM, "CONFIGURE STREAM" },
  2037. { ATA_CMD_SMART, "SMART" },
  2038. { ATA_CMD_MEDIA_LOCK, "DOOR LOCK" },
  2039. { ATA_CMD_MEDIA_UNLOCK, "DOOR UNLOCK" },
  2040. { ATA_CMD_DSM, "DATA SET MANAGEMENT" },
  2041. { ATA_CMD_CHK_MED_CRD_TYP, "CHECK MEDIA CARD TYPE" },
  2042. { ATA_CMD_CFA_REQ_EXT_ERR, "CFA REQUEST EXTENDED ERROR" },
  2043. { ATA_CMD_CFA_WRITE_NE, "CFA WRITE SECTORS WITHOUT ERASE" },
  2044. { ATA_CMD_CFA_TRANS_SECT, "CFA TRANSLATE SECTOR" },
  2045. { ATA_CMD_CFA_ERASE, "CFA ERASE SECTORS" },
  2046. { ATA_CMD_CFA_WRITE_MULT_NE, "CFA WRITE MULTIPLE WITHOUT ERASE" },
  2047. { ATA_CMD_REQ_SENSE_DATA, "REQUEST SENSE DATA EXT" },
  2048. { ATA_CMD_SANITIZE_DEVICE, "SANITIZE DEVICE" },
  2049. { ATA_CMD_READ_LONG, "READ LONG (with retries)" },
  2050. { ATA_CMD_READ_LONG_ONCE, "READ LONG (without retries)" },
  2051. { ATA_CMD_WRITE_LONG, "WRITE LONG (with retries)" },
  2052. { ATA_CMD_WRITE_LONG_ONCE, "WRITE LONG (without retries)" },
  2053. { ATA_CMD_RESTORE, "RECALIBRATE" },
  2054. { 0, NULL } /* terminate list */
  2055. };
  2056. unsigned int i;
  2057. for (i = 0; cmd_descr[i].text; i++)
  2058. if (cmd_descr[i].command == command)
  2059. return cmd_descr[i].text;
  2060. #endif
  2061. return NULL;
  2062. }
  2063. /**
  2064. * ata_eh_link_report - report error handling to user
  2065. * @link: ATA link EH is going on
  2066. *
  2067. * Report EH to user.
  2068. *
  2069. * LOCKING:
  2070. * None.
  2071. */
  2072. static void ata_eh_link_report(struct ata_link *link)
  2073. {
  2074. struct ata_port *ap = link->ap;
  2075. struct ata_eh_context *ehc = &link->eh_context;
  2076. const char *frozen, *desc;
  2077. char tries_buf[6];
  2078. int tag, nr_failed = 0;
  2079. if (ehc->i.flags & ATA_EHI_QUIET)
  2080. return;
  2081. desc = NULL;
  2082. if (ehc->i.desc[0] != '\0')
  2083. desc = ehc->i.desc;
  2084. for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
  2085. struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
  2086. if (!(qc->flags & ATA_QCFLAG_FAILED) ||
  2087. ata_dev_phys_link(qc->dev) != link ||
  2088. ((qc->flags & ATA_QCFLAG_QUIET) &&
  2089. qc->err_mask == AC_ERR_DEV))
  2090. continue;
  2091. if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
  2092. continue;
  2093. nr_failed++;
  2094. }
  2095. if (!nr_failed && !ehc->i.err_mask)
  2096. return;
  2097. frozen = "";
  2098. if (ap->pflags & ATA_PFLAG_FROZEN)
  2099. frozen = " frozen";
  2100. memset(tries_buf, 0, sizeof(tries_buf));
  2101. if (ap->eh_tries < ATA_EH_MAX_TRIES)
  2102. snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
  2103. ap->eh_tries);
  2104. if (ehc->i.dev) {
  2105. ata_dev_err(ehc->i.dev, "exception Emask 0x%x "
  2106. "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
  2107. ehc->i.err_mask, link->sactive, ehc->i.serror,
  2108. ehc->i.action, frozen, tries_buf);
  2109. if (desc)
  2110. ata_dev_err(ehc->i.dev, "%s\n", desc);
  2111. } else {
  2112. ata_link_err(link, "exception Emask 0x%x "
  2113. "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
  2114. ehc->i.err_mask, link->sactive, ehc->i.serror,
  2115. ehc->i.action, frozen, tries_buf);
  2116. if (desc)
  2117. ata_link_err(link, "%s\n", desc);
  2118. }
  2119. #ifdef CONFIG_ATA_VERBOSE_ERROR
  2120. if (ehc->i.serror)
  2121. ata_link_err(link,
  2122. "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
  2123. ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
  2124. ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
  2125. ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
  2126. ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
  2127. ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
  2128. ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
  2129. ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
  2130. ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
  2131. ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
  2132. ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
  2133. ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
  2134. ehc->i.serror & SERR_CRC ? "BadCRC " : "",
  2135. ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
  2136. ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
  2137. ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
  2138. ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
  2139. ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
  2140. #endif
  2141. for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
  2142. struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
  2143. struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
  2144. const u8 *cdb = qc->cdb;
  2145. char data_buf[20] = "";
  2146. char cdb_buf[70] = "";
  2147. if (!(qc->flags & ATA_QCFLAG_FAILED) ||
  2148. ata_dev_phys_link(qc->dev) != link || !qc->err_mask)
  2149. continue;
  2150. if (qc->dma_dir != DMA_NONE) {
  2151. static const char *dma_str[] = {
  2152. [DMA_BIDIRECTIONAL] = "bidi",
  2153. [DMA_TO_DEVICE] = "out",
  2154. [DMA_FROM_DEVICE] = "in",
  2155. };
  2156. static const char *prot_str[] = {
  2157. [ATA_PROT_PIO] = "pio",
  2158. [ATA_PROT_DMA] = "dma",
  2159. [ATA_PROT_NCQ] = "ncq",
  2160. [ATAPI_PROT_PIO] = "pio",
  2161. [ATAPI_PROT_DMA] = "dma",
  2162. };
  2163. snprintf(data_buf, sizeof(data_buf), " %s %u %s",
  2164. prot_str[qc->tf.protocol], qc->nbytes,
  2165. dma_str[qc->dma_dir]);
  2166. }
  2167. if (ata_is_atapi(qc->tf.protocol)) {
  2168. if (qc->scsicmd)
  2169. scsi_print_command(qc->scsicmd);
  2170. else
  2171. snprintf(cdb_buf, sizeof(cdb_buf),
  2172. "cdb %02x %02x %02x %02x %02x %02x %02x %02x "
  2173. "%02x %02x %02x %02x %02x %02x %02x %02x\n ",
  2174. cdb[0], cdb[1], cdb[2], cdb[3],
  2175. cdb[4], cdb[5], cdb[6], cdb[7],
  2176. cdb[8], cdb[9], cdb[10], cdb[11],
  2177. cdb[12], cdb[13], cdb[14], cdb[15]);
  2178. } else {
  2179. const char *descr = ata_get_cmd_descript(cmd->command);
  2180. if (descr)
  2181. ata_dev_err(qc->dev, "failed command: %s\n",
  2182. descr);
  2183. }
  2184. ata_dev_err(qc->dev,
  2185. "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
  2186. "tag %d%s\n %s"
  2187. "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
  2188. "Emask 0x%x (%s)%s\n",
  2189. cmd->command, cmd->feature, cmd->nsect,
  2190. cmd->lbal, cmd->lbam, cmd->lbah,
  2191. cmd->hob_feature, cmd->hob_nsect,
  2192. cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
  2193. cmd->device, qc->tag, data_buf, cdb_buf,
  2194. res->command, res->feature, res->nsect,
  2195. res->lbal, res->lbam, res->lbah,
  2196. res->hob_feature, res->hob_nsect,
  2197. res->hob_lbal, res->hob_lbam, res->hob_lbah,
  2198. res->device, qc->err_mask, ata_err_string(qc->err_mask),
  2199. qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
  2200. #ifdef CONFIG_ATA_VERBOSE_ERROR
  2201. if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
  2202. ATA_ERR)) {
  2203. if (res->command & ATA_BUSY)
  2204. ata_dev_err(qc->dev, "status: { Busy }\n");
  2205. else
  2206. ata_dev_err(qc->dev, "status: { %s%s%s%s}\n",
  2207. res->command & ATA_DRDY ? "DRDY " : "",
  2208. res->command & ATA_DF ? "DF " : "",
  2209. res->command & ATA_DRQ ? "DRQ " : "",
  2210. res->command & ATA_ERR ? "ERR " : "");
  2211. }
  2212. if (cmd->command != ATA_CMD_PACKET &&
  2213. (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
  2214. ATA_ABORTED)))
  2215. ata_dev_err(qc->dev, "error: { %s%s%s%s}\n",
  2216. res->feature & ATA_ICRC ? "ICRC " : "",
  2217. res->feature & ATA_UNC ? "UNC " : "",
  2218. res->feature & ATA_IDNF ? "IDNF " : "",
  2219. res->feature & ATA_ABORTED ? "ABRT " : "");
  2220. #endif
  2221. }
  2222. }
  2223. /**
  2224. * ata_eh_report - report error handling to user
  2225. * @ap: ATA port to report EH about
  2226. *
  2227. * Report EH to user.
  2228. *
  2229. * LOCKING:
  2230. * None.
  2231. */
  2232. void ata_eh_report(struct ata_port *ap)
  2233. {
  2234. struct ata_link *link;
  2235. ata_for_each_link(link, ap, HOST_FIRST)
  2236. ata_eh_link_report(link);
  2237. }
  2238. static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
  2239. unsigned int *classes, unsigned long deadline,
  2240. bool clear_classes)
  2241. {
  2242. struct ata_device *dev;
  2243. if (clear_classes)
  2244. ata_for_each_dev(dev, link, ALL)
  2245. classes[dev->devno] = ATA_DEV_UNKNOWN;
  2246. return reset(link, classes, deadline);
  2247. }
  2248. static int ata_eh_followup_srst_needed(struct ata_link *link, int rc)
  2249. {
  2250. if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
  2251. return 0;
  2252. if (rc == -EAGAIN)
  2253. return 1;
  2254. if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
  2255. return 1;
  2256. return 0;
  2257. }
  2258. int ata_eh_reset(struct ata_link *link, int classify,
  2259. ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
  2260. ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
  2261. {
  2262. struct ata_port *ap = link->ap;
  2263. struct ata_link *slave = ap->slave_link;
  2264. struct ata_eh_context *ehc = &link->eh_context;
  2265. struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL;
  2266. unsigned int *classes = ehc->classes;
  2267. unsigned int lflags = link->flags;
  2268. int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
  2269. int max_tries = 0, try = 0;
  2270. struct ata_link *failed_link;
  2271. struct ata_device *dev;
  2272. unsigned long deadline, now;
  2273. ata_reset_fn_t reset;
  2274. unsigned long flags;
  2275. u32 sstatus;
  2276. int nr_unknown, rc;
  2277. /*
  2278. * Prepare to reset
  2279. */
  2280. while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
  2281. max_tries++;
  2282. if (link->flags & ATA_LFLAG_RST_ONCE)
  2283. max_tries = 1;
  2284. if (link->flags & ATA_LFLAG_NO_HRST)
  2285. hardreset = NULL;
  2286. if (link->flags & ATA_LFLAG_NO_SRST)
  2287. softreset = NULL;
  2288. /* make sure each reset attempt is at least COOL_DOWN apart */
  2289. if (ehc->i.flags & ATA_EHI_DID_RESET) {
  2290. now = jiffies;
  2291. WARN_ON(time_after(ehc->last_reset, now));
  2292. deadline = ata_deadline(ehc->last_reset,
  2293. ATA_EH_RESET_COOL_DOWN);
  2294. if (time_before(now, deadline))
  2295. schedule_timeout_uninterruptible(deadline - now);
  2296. }
  2297. spin_lock_irqsave(ap->lock, flags);
  2298. ap->pflags |= ATA_PFLAG_RESETTING;
  2299. spin_unlock_irqrestore(ap->lock, flags);
  2300. ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
  2301. ata_for_each_dev(dev, link, ALL) {
  2302. /* If we issue an SRST then an ATA drive (not ATAPI)
  2303. * may change configuration and be in PIO0 timing. If
  2304. * we do a hard reset (or are coming from power on)
  2305. * this is true for ATA or ATAPI. Until we've set a
  2306. * suitable controller mode we should not touch the
  2307. * bus as we may be talking too fast.
  2308. */
  2309. dev->pio_mode = XFER_PIO_0;
  2310. dev->dma_mode = 0xff;
  2311. /* If the controller has a pio mode setup function
  2312. * then use it to set the chipset to rights. Don't
  2313. * touch the DMA setup as that will be dealt with when
  2314. * configuring devices.
  2315. */
  2316. if (ap->ops->set_piomode)
  2317. ap->ops->set_piomode(ap, dev);
  2318. }
  2319. /* prefer hardreset */
  2320. reset = NULL;
  2321. ehc->i.action &= ~ATA_EH_RESET;
  2322. if (hardreset) {
  2323. reset = hardreset;
  2324. ehc->i.action |= ATA_EH_HARDRESET;
  2325. } else if (softreset) {
  2326. reset = softreset;
  2327. ehc->i.action |= ATA_EH_SOFTRESET;
  2328. }
  2329. if (prereset) {
  2330. unsigned long deadline = ata_deadline(jiffies,
  2331. ATA_EH_PRERESET_TIMEOUT);
  2332. if (slave) {
  2333. sehc->i.action &= ~ATA_EH_RESET;
  2334. sehc->i.action |= ehc->i.action;
  2335. }
  2336. rc = prereset(link, deadline);
  2337. /* If present, do prereset on slave link too. Reset
  2338. * is skipped iff both master and slave links report
  2339. * -ENOENT or clear ATA_EH_RESET.
  2340. */
  2341. if (slave && (rc == 0 || rc == -ENOENT)) {
  2342. int tmp;
  2343. tmp = prereset(slave, deadline);
  2344. if (tmp != -ENOENT)
  2345. rc = tmp;
  2346. ehc->i.action |= sehc->i.action;
  2347. }
  2348. if (rc) {
  2349. if (rc == -ENOENT) {
  2350. ata_link_dbg(link, "port disabled--ignoring\n");
  2351. ehc->i.action &= ~ATA_EH_RESET;
  2352. ata_for_each_dev(dev, link, ALL)
  2353. classes[dev->devno] = ATA_DEV_NONE;
  2354. rc = 0;
  2355. } else
  2356. ata_link_err(link,
  2357. "prereset failed (errno=%d)\n",
  2358. rc);
  2359. goto out;
  2360. }
  2361. /* prereset() might have cleared ATA_EH_RESET. If so,
  2362. * bang classes, thaw and return.
  2363. */
  2364. if (reset && !(ehc->i.action & ATA_EH_RESET)) {
  2365. ata_for_each_dev(dev, link, ALL)
  2366. classes[dev->devno] = ATA_DEV_NONE;
  2367. if ((ap->pflags & ATA_PFLAG_FROZEN) &&
  2368. ata_is_host_link(link))
  2369. ata_eh_thaw_port(ap);
  2370. rc = 0;
  2371. goto out;
  2372. }
  2373. }
  2374. retry:
  2375. /*
  2376. * Perform reset
  2377. */
  2378. if (ata_is_host_link(link))
  2379. ata_eh_freeze_port(ap);
  2380. deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
  2381. if (reset) {
  2382. if (verbose)
  2383. ata_link_info(link, "%s resetting link\n",
  2384. reset == softreset ? "soft" : "hard");
  2385. /* mark that this EH session started with reset */
  2386. ehc->last_reset = jiffies;
  2387. if (reset == hardreset)
  2388. ehc->i.flags |= ATA_EHI_DID_HARDRESET;
  2389. else
  2390. ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
  2391. rc = ata_do_reset(link, reset, classes, deadline, true);
  2392. if (rc && rc != -EAGAIN) {
  2393. failed_link = link;
  2394. goto fail;
  2395. }
  2396. /* hardreset slave link if existent */
  2397. if (slave && reset == hardreset) {
  2398. int tmp;
  2399. if (verbose)
  2400. ata_link_info(slave, "hard resetting link\n");
  2401. ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
  2402. tmp = ata_do_reset(slave, reset, classes, deadline,
  2403. false);
  2404. switch (tmp) {
  2405. case -EAGAIN:
  2406. rc = -EAGAIN;
  2407. case 0:
  2408. break;
  2409. default:
  2410. failed_link = slave;
  2411. rc = tmp;
  2412. goto fail;
  2413. }
  2414. }
  2415. /* perform follow-up SRST if necessary */
  2416. if (reset == hardreset &&
  2417. ata_eh_followup_srst_needed(link, rc)) {
  2418. reset = softreset;
  2419. if (!reset) {
  2420. ata_link_err(link,
  2421. "follow-up softreset required but no softreset available\n");
  2422. failed_link = link;
  2423. rc = -EINVAL;
  2424. goto fail;
  2425. }
  2426. ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
  2427. rc = ata_do_reset(link, reset, classes, deadline, true);
  2428. if (rc) {
  2429. failed_link = link;
  2430. goto fail;
  2431. }
  2432. }
  2433. } else {
  2434. if (verbose)
  2435. ata_link_info(link,
  2436. "no reset method available, skipping reset\n");
  2437. if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
  2438. lflags |= ATA_LFLAG_ASSUME_ATA;
  2439. }
  2440. /*
  2441. * Post-reset processing
  2442. */
  2443. ata_for_each_dev(dev, link, ALL) {
  2444. /* After the reset, the device state is PIO 0 and the
  2445. * controller state is undefined. Reset also wakes up
  2446. * drives from sleeping mode.
  2447. */
  2448. dev->pio_mode = XFER_PIO_0;
  2449. dev->flags &= ~ATA_DFLAG_SLEEPING;
  2450. if (ata_phys_link_offline(ata_dev_phys_link(dev)))
  2451. continue;
  2452. /* apply class override */
  2453. if (lflags & ATA_LFLAG_ASSUME_ATA)
  2454. classes[dev->devno] = ATA_DEV_ATA;
  2455. else if (lflags & ATA_LFLAG_ASSUME_SEMB)
  2456. classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
  2457. }
  2458. /* record current link speed */
  2459. if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
  2460. link->sata_spd = (sstatus >> 4) & 0xf;
  2461. if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
  2462. slave->sata_spd = (sstatus >> 4) & 0xf;
  2463. /* thaw the port */
  2464. if (ata_is_host_link(link))
  2465. ata_eh_thaw_port(ap);
  2466. /* postreset() should clear hardware SError. Although SError
  2467. * is cleared during link resume, clearing SError here is
  2468. * necessary as some PHYs raise hotplug events after SRST.
  2469. * This introduces race condition where hotplug occurs between
  2470. * reset and here. This race is mediated by cross checking
  2471. * link onlineness and classification result later.
  2472. */
  2473. if (postreset) {
  2474. postreset(link, classes);
  2475. if (slave)
  2476. postreset(slave, classes);
  2477. }
  2478. /*
  2479. * Some controllers can't be frozen very well and may set spurious
  2480. * error conditions during reset. Clear accumulated error
  2481. * information and re-thaw the port if frozen. As reset is the
  2482. * final recovery action and we cross check link onlineness against
  2483. * device classification later, no hotplug event is lost by this.
  2484. */
  2485. spin_lock_irqsave(link->ap->lock, flags);
  2486. memset(&link->eh_info, 0, sizeof(link->eh_info));
  2487. if (slave)
  2488. memset(&slave->eh_info, 0, sizeof(link->eh_info));
  2489. ap->pflags &= ~ATA_PFLAG_EH_PENDING;
  2490. spin_unlock_irqrestore(link->ap->lock, flags);
  2491. if (ap->pflags & ATA_PFLAG_FROZEN)
  2492. ata_eh_thaw_port(ap);
  2493. /*
  2494. * Make sure onlineness and classification result correspond.
  2495. * Hotplug could have happened during reset and some
  2496. * controllers fail to wait while a drive is spinning up after
  2497. * being hotplugged causing misdetection. By cross checking
  2498. * link on/offlineness and classification result, those
  2499. * conditions can be reliably detected and retried.
  2500. */
  2501. nr_unknown = 0;
  2502. ata_for_each_dev(dev, link, ALL) {
  2503. if (ata_phys_link_online(ata_dev_phys_link(dev))) {
  2504. if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
  2505. ata_dev_dbg(dev, "link online but device misclassified\n");
  2506. classes[dev->devno] = ATA_DEV_NONE;
  2507. nr_unknown++;
  2508. }
  2509. } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
  2510. if (ata_class_enabled(classes[dev->devno]))
  2511. ata_dev_dbg(dev,
  2512. "link offline, clearing class %d to NONE\n",
  2513. classes[dev->devno]);
  2514. classes[dev->devno] = ATA_DEV_NONE;
  2515. } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
  2516. ata_dev_dbg(dev,
  2517. "link status unknown, clearing UNKNOWN to NONE\n");
  2518. classes[dev->devno] = ATA_DEV_NONE;
  2519. }
  2520. }
  2521. if (classify && nr_unknown) {
  2522. if (try < max_tries) {
  2523. ata_link_warn(link,
  2524. "link online but %d devices misclassified, retrying\n",
  2525. nr_unknown);
  2526. failed_link = link;
  2527. rc = -EAGAIN;
  2528. goto fail;
  2529. }
  2530. ata_link_warn(link,
  2531. "link online but %d devices misclassified, "
  2532. "device detection might fail\n", nr_unknown);
  2533. }
  2534. /* reset successful, schedule revalidation */
  2535. ata_eh_done(link, NULL, ATA_EH_RESET);
  2536. if (slave)
  2537. ata_eh_done(slave, NULL, ATA_EH_RESET);
  2538. ehc->last_reset = jiffies; /* update to completion time */
  2539. ehc->i.action |= ATA_EH_REVALIDATE;
  2540. link->lpm_policy = ATA_LPM_UNKNOWN; /* reset LPM state */
  2541. rc = 0;
  2542. out:
  2543. /* clear hotplug flag */
  2544. ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
  2545. if (slave)
  2546. sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
  2547. spin_lock_irqsave(ap->lock, flags);
  2548. ap->pflags &= ~ATA_PFLAG_RESETTING;
  2549. spin_unlock_irqrestore(ap->lock, flags);
  2550. return rc;
  2551. fail:
  2552. /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
  2553. if (!ata_is_host_link(link) &&
  2554. sata_scr_read(link, SCR_STATUS, &sstatus))
  2555. rc = -ERESTART;
  2556. if (try >= max_tries) {
  2557. /*
  2558. * Thaw host port even if reset failed, so that the port
  2559. * can be retried on the next phy event. This risks
  2560. * repeated EH runs but seems to be a better tradeoff than
  2561. * shutting down a port after a botched hotplug attempt.
  2562. */
  2563. if (ata_is_host_link(link))
  2564. ata_eh_thaw_port(ap);
  2565. goto out;
  2566. }
  2567. now = jiffies;
  2568. if (time_before(now, deadline)) {
  2569. unsigned long delta = deadline - now;
  2570. ata_link_warn(failed_link,
  2571. "reset failed (errno=%d), retrying in %u secs\n",
  2572. rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
  2573. ata_eh_release(ap);
  2574. while (delta)
  2575. delta = schedule_timeout_uninterruptible(delta);
  2576. ata_eh_acquire(ap);
  2577. }
  2578. /*
  2579. * While disks spinup behind PMP, some controllers fail sending SRST.
  2580. * They need to be reset - as well as the PMP - before retrying.
  2581. */
  2582. if (rc == -ERESTART) {
  2583. if (ata_is_host_link(link))
  2584. ata_eh_thaw_port(ap);
  2585. goto out;
  2586. }
  2587. if (try == max_tries - 1) {
  2588. sata_down_spd_limit(link, 0);
  2589. if (slave)
  2590. sata_down_spd_limit(slave, 0);
  2591. } else if (rc == -EPIPE)
  2592. sata_down_spd_limit(failed_link, 0);
  2593. if (hardreset)
  2594. reset = hardreset;
  2595. goto retry;
  2596. }
  2597. static inline void ata_eh_pull_park_action(struct ata_port *ap)
  2598. {
  2599. struct ata_link *link;
  2600. struct ata_device *dev;
  2601. unsigned long flags;
  2602. /*
  2603. * This function can be thought of as an extended version of
  2604. * ata_eh_about_to_do() specially crafted to accommodate the
  2605. * requirements of ATA_EH_PARK handling. Since the EH thread
  2606. * does not leave the do {} while () loop in ata_eh_recover as
  2607. * long as the timeout for a park request to *one* device on
  2608. * the port has not expired, and since we still want to pick
  2609. * up park requests to other devices on the same port or
  2610. * timeout updates for the same device, we have to pull
  2611. * ATA_EH_PARK actions from eh_info into eh_context.i
  2612. * ourselves at the beginning of each pass over the loop.
  2613. *
  2614. * Additionally, all write accesses to &ap->park_req_pending
  2615. * through reinit_completion() (see below) or complete_all()
  2616. * (see ata_scsi_park_store()) are protected by the host lock.
  2617. * As a result we have that park_req_pending.done is zero on
  2618. * exit from this function, i.e. when ATA_EH_PARK actions for
  2619. * *all* devices on port ap have been pulled into the
  2620. * respective eh_context structs. If, and only if,
  2621. * park_req_pending.done is non-zero by the time we reach
  2622. * wait_for_completion_timeout(), another ATA_EH_PARK action
  2623. * has been scheduled for at least one of the devices on port
  2624. * ap and we have to cycle over the do {} while () loop in
  2625. * ata_eh_recover() again.
  2626. */
  2627. spin_lock_irqsave(ap->lock, flags);
  2628. reinit_completion(&ap->park_req_pending);
  2629. ata_for_each_link(link, ap, EDGE) {
  2630. ata_for_each_dev(dev, link, ALL) {
  2631. struct ata_eh_info *ehi = &link->eh_info;
  2632. link->eh_context.i.dev_action[dev->devno] |=
  2633. ehi->dev_action[dev->devno] & ATA_EH_PARK;
  2634. ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
  2635. }
  2636. }
  2637. spin_unlock_irqrestore(ap->lock, flags);
  2638. }
  2639. static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
  2640. {
  2641. struct ata_eh_context *ehc = &dev->link->eh_context;
  2642. struct ata_taskfile tf;
  2643. unsigned int err_mask;
  2644. ata_tf_init(dev, &tf);
  2645. if (park) {
  2646. ehc->unloaded_mask |= 1 << dev->devno;
  2647. tf.command = ATA_CMD_IDLEIMMEDIATE;
  2648. tf.feature = 0x44;
  2649. tf.lbal = 0x4c;
  2650. tf.lbam = 0x4e;
  2651. tf.lbah = 0x55;
  2652. } else {
  2653. ehc->unloaded_mask &= ~(1 << dev->devno);
  2654. tf.command = ATA_CMD_CHK_POWER;
  2655. }
  2656. tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
  2657. tf.protocol |= ATA_PROT_NODATA;
  2658. err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
  2659. if (park && (err_mask || tf.lbal != 0xc4)) {
  2660. ata_dev_err(dev, "head unload failed!\n");
  2661. ehc->unloaded_mask &= ~(1 << dev->devno);
  2662. }
  2663. }
  2664. static int ata_eh_revalidate_and_attach(struct ata_link *link,
  2665. struct ata_device **r_failed_dev)
  2666. {
  2667. struct ata_port *ap = link->ap;
  2668. struct ata_eh_context *ehc = &link->eh_context;
  2669. struct ata_device *dev;
  2670. unsigned int new_mask = 0;
  2671. unsigned long flags;
  2672. int rc = 0;
  2673. DPRINTK("ENTER\n");
  2674. /* For PATA drive side cable detection to work, IDENTIFY must
  2675. * be done backwards such that PDIAG- is released by the slave
  2676. * device before the master device is identified.
  2677. */
  2678. ata_for_each_dev(dev, link, ALL_REVERSE) {
  2679. unsigned int action = ata_eh_dev_action(dev);
  2680. unsigned int readid_flags = 0;
  2681. if (ehc->i.flags & ATA_EHI_DID_RESET)
  2682. readid_flags |= ATA_READID_POSTRESET;
  2683. if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
  2684. WARN_ON(dev->class == ATA_DEV_PMP);
  2685. if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
  2686. rc = -EIO;
  2687. goto err;
  2688. }
  2689. ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
  2690. rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
  2691. readid_flags);
  2692. if (rc)
  2693. goto err;
  2694. ata_eh_done(link, dev, ATA_EH_REVALIDATE);
  2695. /* Configuration may have changed, reconfigure
  2696. * transfer mode.
  2697. */
  2698. ehc->i.flags |= ATA_EHI_SETMODE;
  2699. /* schedule the scsi_rescan_device() here */
  2700. schedule_work(&(ap->scsi_rescan_task));
  2701. } else if (dev->class == ATA_DEV_UNKNOWN &&
  2702. ehc->tries[dev->devno] &&
  2703. ata_class_enabled(ehc->classes[dev->devno])) {
  2704. /* Temporarily set dev->class, it will be
  2705. * permanently set once all configurations are
  2706. * complete. This is necessary because new
  2707. * device configuration is done in two
  2708. * separate loops.
  2709. */
  2710. dev->class = ehc->classes[dev->devno];
  2711. if (dev->class == ATA_DEV_PMP)
  2712. rc = sata_pmp_attach(dev);
  2713. else
  2714. rc = ata_dev_read_id(dev, &dev->class,
  2715. readid_flags, dev->id);
  2716. /* read_id might have changed class, store and reset */
  2717. ehc->classes[dev->devno] = dev->class;
  2718. dev->class = ATA_DEV_UNKNOWN;
  2719. switch (rc) {
  2720. case 0:
  2721. /* clear error info accumulated during probe */
  2722. ata_ering_clear(&dev->ering);
  2723. new_mask |= 1 << dev->devno;
  2724. break;
  2725. case -ENOENT:
  2726. /* IDENTIFY was issued to non-existent
  2727. * device. No need to reset. Just
  2728. * thaw and ignore the device.
  2729. */
  2730. ata_eh_thaw_port(ap);
  2731. break;
  2732. default:
  2733. goto err;
  2734. }
  2735. }
  2736. }
  2737. /* PDIAG- should have been released, ask cable type if post-reset */
  2738. if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
  2739. if (ap->ops->cable_detect)
  2740. ap->cbl = ap->ops->cable_detect(ap);
  2741. ata_force_cbl(ap);
  2742. }
  2743. /* Configure new devices forward such that user doesn't see
  2744. * device detection messages backwards.
  2745. */
  2746. ata_for_each_dev(dev, link, ALL) {
  2747. if (!(new_mask & (1 << dev->devno)))
  2748. continue;
  2749. dev->class = ehc->classes[dev->devno];
  2750. if (dev->class == ATA_DEV_PMP)
  2751. continue;
  2752. ehc->i.flags |= ATA_EHI_PRINTINFO;
  2753. rc = ata_dev_configure(dev);
  2754. ehc->i.flags &= ~ATA_EHI_PRINTINFO;
  2755. if (rc) {
  2756. dev->class = ATA_DEV_UNKNOWN;
  2757. goto err;
  2758. }
  2759. spin_lock_irqsave(ap->lock, flags);
  2760. ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
  2761. spin_unlock_irqrestore(ap->lock, flags);
  2762. /* new device discovered, configure xfermode */
  2763. ehc->i.flags |= ATA_EHI_SETMODE;
  2764. }
  2765. return 0;
  2766. err:
  2767. *r_failed_dev = dev;
  2768. DPRINTK("EXIT rc=%d\n", rc);
  2769. return rc;
  2770. }
  2771. /**
  2772. * ata_set_mode - Program timings and issue SET FEATURES - XFER
  2773. * @link: link on which timings will be programmed
  2774. * @r_failed_dev: out parameter for failed device
  2775. *
  2776. * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
  2777. * ata_set_mode() fails, pointer to the failing device is
  2778. * returned in @r_failed_dev.
  2779. *
  2780. * LOCKING:
  2781. * PCI/etc. bus probe sem.
  2782. *
  2783. * RETURNS:
  2784. * 0 on success, negative errno otherwise
  2785. */
  2786. int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
  2787. {
  2788. struct ata_port *ap = link->ap;
  2789. struct ata_device *dev;
  2790. int rc;
  2791. /* if data transfer is verified, clear DUBIOUS_XFER on ering top */
  2792. ata_for_each_dev(dev, link, ENABLED) {
  2793. if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
  2794. struct ata_ering_entry *ent;
  2795. ent = ata_ering_top(&dev->ering);
  2796. if (ent)
  2797. ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
  2798. }
  2799. }
  2800. /* has private set_mode? */
  2801. if (ap->ops->set_mode)
  2802. rc = ap->ops->set_mode(link, r_failed_dev);
  2803. else
  2804. rc = ata_do_set_mode(link, r_failed_dev);
  2805. /* if transfer mode has changed, set DUBIOUS_XFER on device */
  2806. ata_for_each_dev(dev, link, ENABLED) {
  2807. struct ata_eh_context *ehc = &link->eh_context;
  2808. u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
  2809. u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
  2810. if (dev->xfer_mode != saved_xfer_mode ||
  2811. ata_ncq_enabled(dev) != saved_ncq)
  2812. dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
  2813. }
  2814. return rc;
  2815. }
  2816. /**
  2817. * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset
  2818. * @dev: ATAPI device to clear UA for
  2819. *
  2820. * Resets and other operations can make an ATAPI device raise
  2821. * UNIT ATTENTION which causes the next operation to fail. This
  2822. * function clears UA.
  2823. *
  2824. * LOCKING:
  2825. * EH context (may sleep).
  2826. *
  2827. * RETURNS:
  2828. * 0 on success, -errno on failure.
  2829. */
  2830. static int atapi_eh_clear_ua(struct ata_device *dev)
  2831. {
  2832. int i;
  2833. for (i = 0; i < ATA_EH_UA_TRIES; i++) {
  2834. u8 *sense_buffer = dev->link->ap->sector_buf;
  2835. u8 sense_key = 0;
  2836. unsigned int err_mask;
  2837. err_mask = atapi_eh_tur(dev, &sense_key);
  2838. if (err_mask != 0 && err_mask != AC_ERR_DEV) {
  2839. ata_dev_warn(dev,
  2840. "TEST_UNIT_READY failed (err_mask=0x%x)\n",
  2841. err_mask);
  2842. return -EIO;
  2843. }
  2844. if (!err_mask || sense_key != UNIT_ATTENTION)
  2845. return 0;
  2846. err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
  2847. if (err_mask) {
  2848. ata_dev_warn(dev, "failed to clear "
  2849. "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
  2850. return -EIO;
  2851. }
  2852. }
  2853. ata_dev_warn(dev, "UNIT ATTENTION persists after %d tries\n",
  2854. ATA_EH_UA_TRIES);
  2855. return 0;
  2856. }
  2857. /**
  2858. * ata_eh_maybe_retry_flush - Retry FLUSH if necessary
  2859. * @dev: ATA device which may need FLUSH retry
  2860. *
  2861. * If @dev failed FLUSH, it needs to be reported upper layer
  2862. * immediately as it means that @dev failed to remap and already
  2863. * lost at least a sector and further FLUSH retrials won't make
  2864. * any difference to the lost sector. However, if FLUSH failed
  2865. * for other reasons, for example transmission error, FLUSH needs
  2866. * to be retried.
  2867. *
  2868. * This function determines whether FLUSH failure retry is
  2869. * necessary and performs it if so.
  2870. *
  2871. * RETURNS:
  2872. * 0 if EH can continue, -errno if EH needs to be repeated.
  2873. */
  2874. static int ata_eh_maybe_retry_flush(struct ata_device *dev)
  2875. {
  2876. struct ata_link *link = dev->link;
  2877. struct ata_port *ap = link->ap;
  2878. struct ata_queued_cmd *qc;
  2879. struct ata_taskfile tf;
  2880. unsigned int err_mask;
  2881. int rc = 0;
  2882. /* did flush fail for this device? */
  2883. if (!ata_tag_valid(link->active_tag))
  2884. return 0;
  2885. qc = __ata_qc_from_tag(ap, link->active_tag);
  2886. if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT &&
  2887. qc->tf.command != ATA_CMD_FLUSH))
  2888. return 0;
  2889. /* if the device failed it, it should be reported to upper layers */
  2890. if (qc->err_mask & AC_ERR_DEV)
  2891. return 0;
  2892. /* flush failed for some other reason, give it another shot */
  2893. ata_tf_init(dev, &tf);
  2894. tf.command = qc->tf.command;
  2895. tf.flags |= ATA_TFLAG_DEVICE;
  2896. tf.protocol = ATA_PROT_NODATA;
  2897. ata_dev_warn(dev, "retrying FLUSH 0x%x Emask 0x%x\n",
  2898. tf.command, qc->err_mask);
  2899. err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
  2900. if (!err_mask) {
  2901. /*
  2902. * FLUSH is complete but there's no way to
  2903. * successfully complete a failed command from EH.
  2904. * Making sure retry is allowed at least once and
  2905. * retrying it should do the trick - whatever was in
  2906. * the cache is already on the platter and this won't
  2907. * cause infinite loop.
  2908. */
  2909. qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1);
  2910. } else {
  2911. ata_dev_warn(dev, "FLUSH failed Emask 0x%x\n",
  2912. err_mask);
  2913. rc = -EIO;
  2914. /* if device failed it, report it to upper layers */
  2915. if (err_mask & AC_ERR_DEV) {
  2916. qc->err_mask |= AC_ERR_DEV;
  2917. qc->result_tf = tf;
  2918. if (!(ap->pflags & ATA_PFLAG_FROZEN))
  2919. rc = 0;
  2920. }
  2921. }
  2922. return rc;
  2923. }
  2924. /**
  2925. * ata_eh_set_lpm - configure SATA interface power management
  2926. * @link: link to configure power management
  2927. * @policy: the link power management policy
  2928. * @r_failed_dev: out parameter for failed device
  2929. *
  2930. * Enable SATA Interface power management. This will enable
  2931. * Device Interface Power Management (DIPM) for min_power
  2932. * policy, and then call driver specific callbacks for
  2933. * enabling Host Initiated Power management.
  2934. *
  2935. * LOCKING:
  2936. * EH context.
  2937. *
  2938. * RETURNS:
  2939. * 0 on success, -errno on failure.
  2940. */
  2941. static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
  2942. struct ata_device **r_failed_dev)
  2943. {
  2944. struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL;
  2945. struct ata_eh_context *ehc = &link->eh_context;
  2946. struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL;
  2947. enum ata_lpm_policy old_policy = link->lpm_policy;
  2948. bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM;
  2949. unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM;
  2950. unsigned int err_mask;
  2951. int rc;
  2952. /* if the link or host doesn't do LPM, noop */
  2953. if ((link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm))
  2954. return 0;
  2955. /*
  2956. * DIPM is enabled only for MIN_POWER as some devices
  2957. * misbehave when the host NACKs transition to SLUMBER. Order
  2958. * device and link configurations such that the host always
  2959. * allows DIPM requests.
  2960. */
  2961. ata_for_each_dev(dev, link, ENABLED) {
  2962. bool hipm = ata_id_has_hipm(dev->id);
  2963. bool dipm = ata_id_has_dipm(dev->id) && !no_dipm;
  2964. /* find the first enabled and LPM enabled devices */
  2965. if (!link_dev)
  2966. link_dev = dev;
  2967. if (!lpm_dev && (hipm || dipm))
  2968. lpm_dev = dev;
  2969. hints &= ~ATA_LPM_EMPTY;
  2970. if (!hipm)
  2971. hints &= ~ATA_LPM_HIPM;
  2972. /* disable DIPM before changing link config */
  2973. if (policy != ATA_LPM_MIN_POWER && dipm) {
  2974. err_mask = ata_dev_set_feature(dev,
  2975. SETFEATURES_SATA_DISABLE, SATA_DIPM);
  2976. if (err_mask && err_mask != AC_ERR_DEV) {
  2977. ata_dev_warn(dev,
  2978. "failed to disable DIPM, Emask 0x%x\n",
  2979. err_mask);
  2980. rc = -EIO;
  2981. goto fail;
  2982. }
  2983. }
  2984. }
  2985. if (ap) {
  2986. rc = ap->ops->set_lpm(link, policy, hints);
  2987. if (!rc && ap->slave_link)
  2988. rc = ap->ops->set_lpm(ap->slave_link, policy, hints);
  2989. } else
  2990. rc = sata_pmp_set_lpm(link, policy, hints);
  2991. /*
  2992. * Attribute link config failure to the first (LPM) enabled
  2993. * device on the link.
  2994. */
  2995. if (rc) {
  2996. if (rc == -EOPNOTSUPP) {
  2997. link->flags |= ATA_LFLAG_NO_LPM;
  2998. return 0;
  2999. }
  3000. dev = lpm_dev ? lpm_dev : link_dev;
  3001. goto fail;
  3002. }
  3003. /*
  3004. * Low level driver acked the transition. Issue DIPM command
  3005. * with the new policy set.
  3006. */
  3007. link->lpm_policy = policy;
  3008. if (ap && ap->slave_link)
  3009. ap->slave_link->lpm_policy = policy;
  3010. /* host config updated, enable DIPM if transitioning to MIN_POWER */
  3011. ata_for_each_dev(dev, link, ENABLED) {
  3012. if (policy == ATA_LPM_MIN_POWER && !no_dipm &&
  3013. ata_id_has_dipm(dev->id)) {
  3014. err_mask = ata_dev_set_feature(dev,
  3015. SETFEATURES_SATA_ENABLE, SATA_DIPM);
  3016. if (err_mask && err_mask != AC_ERR_DEV) {
  3017. ata_dev_warn(dev,
  3018. "failed to enable DIPM, Emask 0x%x\n",
  3019. err_mask);
  3020. rc = -EIO;
  3021. goto fail;
  3022. }
  3023. }
  3024. }
  3025. return 0;
  3026. fail:
  3027. /* restore the old policy */
  3028. link->lpm_policy = old_policy;
  3029. if (ap && ap->slave_link)
  3030. ap->slave_link->lpm_policy = old_policy;
  3031. /* if no device or only one more chance is left, disable LPM */
  3032. if (!dev || ehc->tries[dev->devno] <= 2) {
  3033. ata_link_warn(link, "disabling LPM on the link\n");
  3034. link->flags |= ATA_LFLAG_NO_LPM;
  3035. }
  3036. if (r_failed_dev)
  3037. *r_failed_dev = dev;
  3038. return rc;
  3039. }
  3040. int ata_link_nr_enabled(struct ata_link *link)
  3041. {
  3042. struct ata_device *dev;
  3043. int cnt = 0;
  3044. ata_for_each_dev(dev, link, ENABLED)
  3045. cnt++;
  3046. return cnt;
  3047. }
  3048. static int ata_link_nr_vacant(struct ata_link *link)
  3049. {
  3050. struct ata_device *dev;
  3051. int cnt = 0;
  3052. ata_for_each_dev(dev, link, ALL)
  3053. if (dev->class == ATA_DEV_UNKNOWN)
  3054. cnt++;
  3055. return cnt;
  3056. }
  3057. static int ata_eh_skip_recovery(struct ata_link *link)
  3058. {
  3059. struct ata_port *ap = link->ap;
  3060. struct ata_eh_context *ehc = &link->eh_context;
  3061. struct ata_device *dev;
  3062. /* skip disabled links */
  3063. if (link->flags & ATA_LFLAG_DISABLED)
  3064. return 1;
  3065. /* skip if explicitly requested */
  3066. if (ehc->i.flags & ATA_EHI_NO_RECOVERY)
  3067. return 1;
  3068. /* thaw frozen port and recover failed devices */
  3069. if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
  3070. return 0;
  3071. /* reset at least once if reset is requested */
  3072. if ((ehc->i.action & ATA_EH_RESET) &&
  3073. !(ehc->i.flags & ATA_EHI_DID_RESET))
  3074. return 0;
  3075. /* skip if class codes for all vacant slots are ATA_DEV_NONE */
  3076. ata_for_each_dev(dev, link, ALL) {
  3077. if (dev->class == ATA_DEV_UNKNOWN &&
  3078. ehc->classes[dev->devno] != ATA_DEV_NONE)
  3079. return 0;
  3080. }
  3081. return 1;
  3082. }
  3083. static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
  3084. {
  3085. u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
  3086. u64 now = get_jiffies_64();
  3087. int *trials = void_arg;
  3088. if ((ent->eflags & ATA_EFLAG_OLD_ER) ||
  3089. (ent->timestamp < now - min(now, interval)))
  3090. return -1;
  3091. (*trials)++;
  3092. return 0;
  3093. }
  3094. static int ata_eh_schedule_probe(struct ata_device *dev)
  3095. {
  3096. struct ata_eh_context *ehc = &dev->link->eh_context;
  3097. struct ata_link *link = ata_dev_phys_link(dev);
  3098. int trials = 0;
  3099. if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
  3100. (ehc->did_probe_mask & (1 << dev->devno)))
  3101. return 0;
  3102. ata_eh_detach_dev(dev);
  3103. ata_dev_init(dev);
  3104. ehc->did_probe_mask |= (1 << dev->devno);
  3105. ehc->i.action |= ATA_EH_RESET;
  3106. ehc->saved_xfer_mode[dev->devno] = 0;
  3107. ehc->saved_ncq_enabled &= ~(1 << dev->devno);
  3108. /* the link maybe in a deep sleep, wake it up */
  3109. if (link->lpm_policy > ATA_LPM_MAX_POWER) {
  3110. if (ata_is_host_link(link))
  3111. link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER,
  3112. ATA_LPM_EMPTY);
  3113. else
  3114. sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER,
  3115. ATA_LPM_EMPTY);
  3116. }
  3117. /* Record and count probe trials on the ering. The specific
  3118. * error mask used is irrelevant. Because a successful device
  3119. * detection clears the ering, this count accumulates only if
  3120. * there are consecutive failed probes.
  3121. *
  3122. * If the count is equal to or higher than ATA_EH_PROBE_TRIALS
  3123. * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is
  3124. * forced to 1.5Gbps.
  3125. *
  3126. * This is to work around cases where failed link speed
  3127. * negotiation results in device misdetection leading to
  3128. * infinite DEVXCHG or PHRDY CHG events.
  3129. */
  3130. ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
  3131. ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
  3132. if (trials > ATA_EH_PROBE_TRIALS)
  3133. sata_down_spd_limit(link, 1);
  3134. return 1;
  3135. }
  3136. static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
  3137. {
  3138. struct ata_eh_context *ehc = &dev->link->eh_context;
  3139. /* -EAGAIN from EH routine indicates retry without prejudice.
  3140. * The requester is responsible for ensuring forward progress.
  3141. */
  3142. if (err != -EAGAIN)
  3143. ehc->tries[dev->devno]--;
  3144. switch (err) {
  3145. case -ENODEV:
  3146. /* device missing or wrong IDENTIFY data, schedule probing */
  3147. ehc->i.probe_mask |= (1 << dev->devno);
  3148. case -EINVAL:
  3149. /* give it just one more chance */
  3150. ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
  3151. case -EIO:
  3152. if (ehc->tries[dev->devno] == 1) {
  3153. /* This is the last chance, better to slow
  3154. * down than lose it.
  3155. */
  3156. sata_down_spd_limit(ata_dev_phys_link(dev), 0);
  3157. if (dev->pio_mode > XFER_PIO_0)
  3158. ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
  3159. }
  3160. }
  3161. if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
  3162. /* disable device if it has used up all its chances */
  3163. ata_dev_disable(dev);
  3164. /* detach if offline */
  3165. if (ata_phys_link_offline(ata_dev_phys_link(dev)))
  3166. ata_eh_detach_dev(dev);
  3167. /* schedule probe if necessary */
  3168. if (ata_eh_schedule_probe(dev)) {
  3169. ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
  3170. memset(ehc->cmd_timeout_idx[dev->devno], 0,
  3171. sizeof(ehc->cmd_timeout_idx[dev->devno]));
  3172. }
  3173. return 1;
  3174. } else {
  3175. ehc->i.action |= ATA_EH_RESET;
  3176. return 0;
  3177. }
  3178. }
  3179. /**
  3180. * ata_eh_recover - recover host port after error
  3181. * @ap: host port to recover
  3182. * @prereset: prereset method (can be NULL)
  3183. * @softreset: softreset method (can be NULL)
  3184. * @hardreset: hardreset method (can be NULL)
  3185. * @postreset: postreset method (can be NULL)
  3186. * @r_failed_link: out parameter for failed link
  3187. *
  3188. * This is the alpha and omega, eum and yang, heart and soul of
  3189. * libata exception handling. On entry, actions required to
  3190. * recover each link and hotplug requests are recorded in the
  3191. * link's eh_context. This function executes all the operations
  3192. * with appropriate retrials and fallbacks to resurrect failed
  3193. * devices, detach goners and greet newcomers.
  3194. *
  3195. * LOCKING:
  3196. * Kernel thread context (may sleep).
  3197. *
  3198. * RETURNS:
  3199. * 0 on success, -errno on failure.
  3200. */
  3201. int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
  3202. ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
  3203. ata_postreset_fn_t postreset,
  3204. struct ata_link **r_failed_link)
  3205. {
  3206. struct ata_link *link;
  3207. struct ata_device *dev;
  3208. int rc, nr_fails;
  3209. unsigned long flags, deadline;
  3210. DPRINTK("ENTER\n");
  3211. /* prep for recovery */
  3212. ata_for_each_link(link, ap, EDGE) {
  3213. struct ata_eh_context *ehc = &link->eh_context;
  3214. /* re-enable link? */
  3215. if (ehc->i.action & ATA_EH_ENABLE_LINK) {
  3216. ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
  3217. spin_lock_irqsave(ap->lock, flags);
  3218. link->flags &= ~ATA_LFLAG_DISABLED;
  3219. spin_unlock_irqrestore(ap->lock, flags);
  3220. ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
  3221. }
  3222. ata_for_each_dev(dev, link, ALL) {
  3223. if (link->flags & ATA_LFLAG_NO_RETRY)
  3224. ehc->tries[dev->devno] = 1;
  3225. else
  3226. ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
  3227. /* collect port action mask recorded in dev actions */
  3228. ehc->i.action |= ehc->i.dev_action[dev->devno] &
  3229. ~ATA_EH_PERDEV_MASK;
  3230. ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
  3231. /* process hotplug request */
  3232. if (dev->flags & ATA_DFLAG_DETACH)
  3233. ata_eh_detach_dev(dev);
  3234. /* schedule probe if necessary */
  3235. if (!ata_dev_enabled(dev))
  3236. ata_eh_schedule_probe(dev);
  3237. }
  3238. }
  3239. retry:
  3240. rc = 0;
  3241. /* if UNLOADING, finish immediately */
  3242. if (ap->pflags & ATA_PFLAG_UNLOADING)
  3243. goto out;
  3244. /* prep for EH */
  3245. ata_for_each_link(link, ap, EDGE) {
  3246. struct ata_eh_context *ehc = &link->eh_context;
  3247. /* skip EH if possible. */
  3248. if (ata_eh_skip_recovery(link))
  3249. ehc->i.action = 0;
  3250. ata_for_each_dev(dev, link, ALL)
  3251. ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
  3252. }
  3253. /* reset */
  3254. ata_for_each_link(link, ap, EDGE) {
  3255. struct ata_eh_context *ehc = &link->eh_context;
  3256. if (!(ehc->i.action & ATA_EH_RESET))
  3257. continue;
  3258. rc = ata_eh_reset(link, ata_link_nr_vacant(link),
  3259. prereset, softreset, hardreset, postreset);
  3260. if (rc) {
  3261. ata_link_err(link, "reset failed, giving up\n");
  3262. goto out;
  3263. }
  3264. }
  3265. do {
  3266. unsigned long now;
  3267. /*
  3268. * clears ATA_EH_PARK in eh_info and resets
  3269. * ap->park_req_pending
  3270. */
  3271. ata_eh_pull_park_action(ap);
  3272. deadline = jiffies;
  3273. ata_for_each_link(link, ap, EDGE) {
  3274. ata_for_each_dev(dev, link, ALL) {
  3275. struct ata_eh_context *ehc = &link->eh_context;
  3276. unsigned long tmp;
  3277. if (dev->class != ATA_DEV_ATA)
  3278. continue;
  3279. if (!(ehc->i.dev_action[dev->devno] &
  3280. ATA_EH_PARK))
  3281. continue;
  3282. tmp = dev->unpark_deadline;
  3283. if (time_before(deadline, tmp))
  3284. deadline = tmp;
  3285. else if (time_before_eq(tmp, jiffies))
  3286. continue;
  3287. if (ehc->unloaded_mask & (1 << dev->devno))
  3288. continue;
  3289. ata_eh_park_issue_cmd(dev, 1);
  3290. }
  3291. }
  3292. now = jiffies;
  3293. if (time_before_eq(deadline, now))
  3294. break;
  3295. ata_eh_release(ap);
  3296. deadline = wait_for_completion_timeout(&ap->park_req_pending,
  3297. deadline - now);
  3298. ata_eh_acquire(ap);
  3299. } while (deadline);
  3300. ata_for_each_link(link, ap, EDGE) {
  3301. ata_for_each_dev(dev, link, ALL) {
  3302. if (!(link->eh_context.unloaded_mask &
  3303. (1 << dev->devno)))
  3304. continue;
  3305. ata_eh_park_issue_cmd(dev, 0);
  3306. ata_eh_done(link, dev, ATA_EH_PARK);
  3307. }
  3308. }
  3309. /* the rest */
  3310. nr_fails = 0;
  3311. ata_for_each_link(link, ap, PMP_FIRST) {
  3312. struct ata_eh_context *ehc = &link->eh_context;
  3313. if (sata_pmp_attached(ap) && ata_is_host_link(link))
  3314. goto config_lpm;
  3315. /* revalidate existing devices and attach new ones */
  3316. rc = ata_eh_revalidate_and_attach(link, &dev);
  3317. if (rc)
  3318. goto rest_fail;
  3319. /* if PMP got attached, return, pmp EH will take care of it */
  3320. if (link->device->class == ATA_DEV_PMP) {
  3321. ehc->i.action = 0;
  3322. return 0;
  3323. }
  3324. /* configure transfer mode if necessary */
  3325. if (ehc->i.flags & ATA_EHI_SETMODE) {
  3326. rc = ata_set_mode(link, &dev);
  3327. if (rc)
  3328. goto rest_fail;
  3329. ehc->i.flags &= ~ATA_EHI_SETMODE;
  3330. }
  3331. /* If reset has been issued, clear UA to avoid
  3332. * disrupting the current users of the device.
  3333. */
  3334. if (ehc->i.flags & ATA_EHI_DID_RESET) {
  3335. ata_for_each_dev(dev, link, ALL) {
  3336. if (dev->class != ATA_DEV_ATAPI)
  3337. continue;
  3338. rc = atapi_eh_clear_ua(dev);
  3339. if (rc)
  3340. goto rest_fail;
  3341. if (zpodd_dev_enabled(dev))
  3342. zpodd_post_poweron(dev);
  3343. }
  3344. }
  3345. /* retry flush if necessary */
  3346. ata_for_each_dev(dev, link, ALL) {
  3347. if (dev->class != ATA_DEV_ATA)
  3348. continue;
  3349. rc = ata_eh_maybe_retry_flush(dev);
  3350. if (rc)
  3351. goto rest_fail;
  3352. }
  3353. config_lpm:
  3354. /* configure link power saving */
  3355. if (link->lpm_policy != ap->target_lpm_policy) {
  3356. rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev);
  3357. if (rc)
  3358. goto rest_fail;
  3359. }
  3360. /* this link is okay now */
  3361. ehc->i.flags = 0;
  3362. continue;
  3363. rest_fail:
  3364. nr_fails++;
  3365. if (dev)
  3366. ata_eh_handle_dev_fail(dev, rc);
  3367. if (ap->pflags & ATA_PFLAG_FROZEN) {
  3368. /* PMP reset requires working host port.
  3369. * Can't retry if it's frozen.
  3370. */
  3371. if (sata_pmp_attached(ap))
  3372. goto out;
  3373. break;
  3374. }
  3375. }
  3376. if (nr_fails)
  3377. goto retry;
  3378. out:
  3379. if (rc && r_failed_link)
  3380. *r_failed_link = link;
  3381. DPRINTK("EXIT, rc=%d\n", rc);
  3382. return rc;
  3383. }
  3384. /**
  3385. * ata_eh_finish - finish up EH
  3386. * @ap: host port to finish EH for
  3387. *
  3388. * Recovery is complete. Clean up EH states and retry or finish
  3389. * failed qcs.
  3390. *
  3391. * LOCKING:
  3392. * None.
  3393. */
  3394. void ata_eh_finish(struct ata_port *ap)
  3395. {
  3396. int tag;
  3397. /* retry or finish qcs */
  3398. for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
  3399. struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
  3400. if (!(qc->flags & ATA_QCFLAG_FAILED))
  3401. continue;
  3402. if (qc->err_mask) {
  3403. /* FIXME: Once EH migration is complete,
  3404. * generate sense data in this function,
  3405. * considering both err_mask and tf.
  3406. */
  3407. if (qc->flags & ATA_QCFLAG_RETRY)
  3408. ata_eh_qc_retry(qc);
  3409. else
  3410. ata_eh_qc_complete(qc);
  3411. } else {
  3412. if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
  3413. ata_eh_qc_complete(qc);
  3414. } else {
  3415. /* feed zero TF to sense generation */
  3416. memset(&qc->result_tf, 0, sizeof(qc->result_tf));
  3417. ata_eh_qc_retry(qc);
  3418. }
  3419. }
  3420. }
  3421. /* make sure nr_active_links is zero after EH */
  3422. WARN_ON(ap->nr_active_links);
  3423. ap->nr_active_links = 0;
  3424. }
  3425. /**
  3426. * ata_do_eh - do standard error handling
  3427. * @ap: host port to handle error for
  3428. *
  3429. * @prereset: prereset method (can be NULL)
  3430. * @softreset: softreset method (can be NULL)
  3431. * @hardreset: hardreset method (can be NULL)
  3432. * @postreset: postreset method (can be NULL)
  3433. *
  3434. * Perform standard error handling sequence.
  3435. *
  3436. * LOCKING:
  3437. * Kernel thread context (may sleep).
  3438. */
  3439. void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
  3440. ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
  3441. ata_postreset_fn_t postreset)
  3442. {
  3443. struct ata_device *dev;
  3444. int rc;
  3445. ata_eh_autopsy(ap);
  3446. ata_eh_report(ap);
  3447. rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
  3448. NULL);
  3449. if (rc) {
  3450. ata_for_each_dev(dev, &ap->link, ALL)
  3451. ata_dev_disable(dev);
  3452. }
  3453. ata_eh_finish(ap);
  3454. }
  3455. /**
  3456. * ata_std_error_handler - standard error handler
  3457. * @ap: host port to handle error for
  3458. *
  3459. * Standard error handler
  3460. *
  3461. * LOCKING:
  3462. * Kernel thread context (may sleep).
  3463. */
  3464. void ata_std_error_handler(struct ata_port *ap)
  3465. {
  3466. struct ata_port_operations *ops = ap->ops;
  3467. ata_reset_fn_t hardreset = ops->hardreset;
  3468. /* ignore built-in hardreset if SCR access is not available */
  3469. if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link))
  3470. hardreset = NULL;
  3471. ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
  3472. }
  3473. #ifdef CONFIG_PM
  3474. /**
  3475. * ata_eh_handle_port_suspend - perform port suspend operation
  3476. * @ap: port to suspend
  3477. *
  3478. * Suspend @ap.
  3479. *
  3480. * LOCKING:
  3481. * Kernel thread context (may sleep).
  3482. */
  3483. static void ata_eh_handle_port_suspend(struct ata_port *ap)
  3484. {
  3485. unsigned long flags;
  3486. int rc = 0;
  3487. struct ata_device *dev;
  3488. /* are we suspending? */
  3489. spin_lock_irqsave(ap->lock, flags);
  3490. if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
  3491. ap->pm_mesg.event & PM_EVENT_RESUME) {
  3492. spin_unlock_irqrestore(ap->lock, flags);
  3493. return;
  3494. }
  3495. spin_unlock_irqrestore(ap->lock, flags);
  3496. WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
  3497. /*
  3498. * If we have a ZPODD attached, check its zero
  3499. * power ready status before the port is frozen.
  3500. * Only needed for runtime suspend.
  3501. */
  3502. if (PMSG_IS_AUTO(ap->pm_mesg)) {
  3503. ata_for_each_dev(dev, &ap->link, ENABLED) {
  3504. if (zpodd_dev_enabled(dev))
  3505. zpodd_on_suspend(dev);
  3506. }
  3507. }
  3508. /* tell ACPI we're suspending */
  3509. rc = ata_acpi_on_suspend(ap);
  3510. if (rc)
  3511. goto out;
  3512. /* suspend */
  3513. ata_eh_freeze_port(ap);
  3514. if (ap->ops->port_suspend)
  3515. rc = ap->ops->port_suspend(ap, ap->pm_mesg);
  3516. ata_acpi_set_state(ap, ap->pm_mesg);
  3517. out:
  3518. /* report result */
  3519. spin_lock_irqsave(ap->lock, flags);
  3520. ap->pflags &= ~ATA_PFLAG_PM_PENDING;
  3521. if (rc == 0)
  3522. ap->pflags |= ATA_PFLAG_SUSPENDED;
  3523. else if (ap->pflags & ATA_PFLAG_FROZEN)
  3524. ata_port_schedule_eh(ap);
  3525. if (ap->pm_result) {
  3526. *ap->pm_result = rc;
  3527. ap->pm_result = NULL;
  3528. }
  3529. spin_unlock_irqrestore(ap->lock, flags);
  3530. return;
  3531. }
  3532. /**
  3533. * ata_eh_handle_port_resume - perform port resume operation
  3534. * @ap: port to resume
  3535. *
  3536. * Resume @ap.
  3537. *
  3538. * LOCKING:
  3539. * Kernel thread context (may sleep).
  3540. */
  3541. static void ata_eh_handle_port_resume(struct ata_port *ap)
  3542. {
  3543. struct ata_link *link;
  3544. struct ata_device *dev;
  3545. unsigned long flags;
  3546. int rc = 0;
  3547. /* are we resuming? */
  3548. spin_lock_irqsave(ap->lock, flags);
  3549. if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
  3550. !(ap->pm_mesg.event & PM_EVENT_RESUME)) {
  3551. spin_unlock_irqrestore(ap->lock, flags);
  3552. return;
  3553. }
  3554. spin_unlock_irqrestore(ap->lock, flags);
  3555. WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
  3556. /*
  3557. * Error timestamps are in jiffies which doesn't run while
  3558. * suspended and PHY events during resume isn't too uncommon.
  3559. * When the two are combined, it can lead to unnecessary speed
  3560. * downs if the machine is suspended and resumed repeatedly.
  3561. * Clear error history.
  3562. */
  3563. ata_for_each_link(link, ap, HOST_FIRST)
  3564. ata_for_each_dev(dev, link, ALL)
  3565. ata_ering_clear(&dev->ering);
  3566. ata_acpi_set_state(ap, ap->pm_mesg);
  3567. if (ap->ops->port_resume)
  3568. rc = ap->ops->port_resume(ap);
  3569. /* tell ACPI that we're resuming */
  3570. ata_acpi_on_resume(ap);
  3571. /* report result */
  3572. spin_lock_irqsave(ap->lock, flags);
  3573. ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
  3574. if (ap->pm_result) {
  3575. *ap->pm_result = rc;
  3576. ap->pm_result = NULL;
  3577. }
  3578. spin_unlock_irqrestore(ap->lock, flags);
  3579. }
  3580. #endif /* CONFIG_PM */