libata-eh.c 96 KB

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