libata-scsi.c 81 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256
  1. /*
  2. * libata-scsi.c - helper library for ATA
  3. *
  4. * Maintained by: Jeff Garzik <jgarzik@pobox.com>
  5. * Please ALWAYS copy linux-ide@vger.kernel.org
  6. * on emails.
  7. *
  8. * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
  9. * Copyright 2003-2004 Jeff Garzik
  10. *
  11. *
  12. * This program is free software; you can redistribute it and/or modify
  13. * it under the terms of the GNU General Public License as published by
  14. * the Free Software Foundation; either version 2, or (at your option)
  15. * any later version.
  16. *
  17. * This program is distributed in the hope that it will be useful,
  18. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20. * GNU General Public License for more details.
  21. *
  22. * You should have received a copy of the GNU General Public License
  23. * along with this program; see the file COPYING. If not, write to
  24. * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25. *
  26. *
  27. * libata documentation is available via 'make {ps|pdf}docs',
  28. * as Documentation/DocBook/libata.*
  29. *
  30. * Hardware documentation available from
  31. * - http://www.t10.org/
  32. * - http://www.t13.org/
  33. *
  34. */
  35. #include <linux/kernel.h>
  36. #include <linux/blkdev.h>
  37. #include <linux/spinlock.h>
  38. #include <scsi/scsi.h>
  39. #include <scsi/scsi_host.h>
  40. #include <scsi/scsi_cmnd.h>
  41. #include <scsi/scsi_eh.h>
  42. #include <scsi/scsi_device.h>
  43. #include <scsi/scsi_tcq.h>
  44. #include <scsi/scsi_transport.h>
  45. #include <linux/libata.h>
  46. #include <linux/hdreg.h>
  47. #include <asm/uaccess.h>
  48. #include "libata.h"
  49. #define SECTOR_SIZE 512
  50. typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc);
  51. static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
  52. const struct scsi_device *scsidev);
  53. static struct ata_device * ata_scsi_find_dev(struct ata_port *ap,
  54. const struct scsi_device *scsidev);
  55. static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
  56. unsigned int id, unsigned int lun);
  57. #define RW_RECOVERY_MPAGE 0x1
  58. #define RW_RECOVERY_MPAGE_LEN 12
  59. #define CACHE_MPAGE 0x8
  60. #define CACHE_MPAGE_LEN 20
  61. #define CONTROL_MPAGE 0xa
  62. #define CONTROL_MPAGE_LEN 12
  63. #define ALL_MPAGES 0x3f
  64. #define ALL_SUB_MPAGES 0xff
  65. static const u8 def_rw_recovery_mpage[] = {
  66. RW_RECOVERY_MPAGE,
  67. RW_RECOVERY_MPAGE_LEN - 2,
  68. (1 << 7) | /* AWRE, sat-r06 say it shall be 0 */
  69. (1 << 6), /* ARRE (auto read reallocation) */
  70. 0, /* read retry count */
  71. 0, 0, 0, 0,
  72. 0, /* write retry count */
  73. 0, 0, 0
  74. };
  75. static const u8 def_cache_mpage[CACHE_MPAGE_LEN] = {
  76. CACHE_MPAGE,
  77. CACHE_MPAGE_LEN - 2,
  78. 0, /* contains WCE, needs to be 0 for logic */
  79. 0, 0, 0, 0, 0, 0, 0, 0, 0,
  80. 0, /* contains DRA, needs to be 0 for logic */
  81. 0, 0, 0, 0, 0, 0, 0
  82. };
  83. static const u8 def_control_mpage[CONTROL_MPAGE_LEN] = {
  84. CONTROL_MPAGE,
  85. CONTROL_MPAGE_LEN - 2,
  86. 2, /* DSENSE=0, GLTSD=1 */
  87. 0, /* [QAM+QERR may be 1, see 05-359r1] */
  88. 0, 0, 0, 0, 0xff, 0xff,
  89. 0, 30 /* extended self test time, see 05-359r1 */
  90. };
  91. /*
  92. * libata transport template. libata doesn't do real transport stuff.
  93. * It just needs the eh_timed_out hook.
  94. */
  95. struct scsi_transport_template ata_scsi_transport_template = {
  96. .eh_strategy_handler = ata_scsi_error,
  97. .eh_timed_out = ata_scsi_timed_out,
  98. .user_scan = ata_scsi_user_scan,
  99. };
  100. static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
  101. void (*done)(struct scsi_cmnd *))
  102. {
  103. ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x24, 0x0);
  104. /* "Invalid field in cbd" */
  105. done(cmd);
  106. }
  107. /**
  108. * ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
  109. * @sdev: SCSI device for which BIOS geometry is to be determined
  110. * @bdev: block device associated with @sdev
  111. * @capacity: capacity of SCSI device
  112. * @geom: location to which geometry will be output
  113. *
  114. * Generic bios head/sector/cylinder calculator
  115. * used by sd. Most BIOSes nowadays expect a XXX/255/16 (CHS)
  116. * mapping. Some situations may arise where the disk is not
  117. * bootable if this is not used.
  118. *
  119. * LOCKING:
  120. * Defined by the SCSI layer. We don't really care.
  121. *
  122. * RETURNS:
  123. * Zero.
  124. */
  125. int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
  126. sector_t capacity, int geom[])
  127. {
  128. geom[0] = 255;
  129. geom[1] = 63;
  130. sector_div(capacity, 255*63);
  131. geom[2] = capacity;
  132. return 0;
  133. }
  134. /**
  135. * ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
  136. * @scsidev: Device to which we are issuing command
  137. * @arg: User provided data for issuing command
  138. *
  139. * LOCKING:
  140. * Defined by the SCSI layer. We don't really care.
  141. *
  142. * RETURNS:
  143. * Zero on success, negative errno on error.
  144. */
  145. int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
  146. {
  147. int rc = 0;
  148. u8 scsi_cmd[MAX_COMMAND_SIZE];
  149. u8 args[4], *argbuf = NULL, *sensebuf = NULL;
  150. int argsize = 0;
  151. enum dma_data_direction data_dir;
  152. int cmd_result;
  153. if (arg == NULL)
  154. return -EINVAL;
  155. if (copy_from_user(args, arg, sizeof(args)))
  156. return -EFAULT;
  157. sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
  158. if (!sensebuf)
  159. return -ENOMEM;
  160. memset(scsi_cmd, 0, sizeof(scsi_cmd));
  161. if (args[3]) {
  162. argsize = SECTOR_SIZE * args[3];
  163. argbuf = kmalloc(argsize, GFP_KERNEL);
  164. if (argbuf == NULL) {
  165. rc = -ENOMEM;
  166. goto error;
  167. }
  168. scsi_cmd[1] = (4 << 1); /* PIO Data-in */
  169. scsi_cmd[2] = 0x0e; /* no off.line or cc, read from dev,
  170. block count in sector count field */
  171. data_dir = DMA_FROM_DEVICE;
  172. } else {
  173. scsi_cmd[1] = (3 << 1); /* Non-data */
  174. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */
  175. data_dir = DMA_NONE;
  176. }
  177. scsi_cmd[0] = ATA_16;
  178. scsi_cmd[4] = args[2];
  179. if (args[0] == WIN_SMART) { /* hack -- ide driver does this too... */
  180. scsi_cmd[6] = args[3];
  181. scsi_cmd[8] = args[1];
  182. scsi_cmd[10] = 0x4f;
  183. scsi_cmd[12] = 0xc2;
  184. } else {
  185. scsi_cmd[6] = args[1];
  186. }
  187. scsi_cmd[14] = args[0];
  188. /* Good values for timeout and retries? Values below
  189. from scsi_ioctl_send_command() for default case... */
  190. cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
  191. sensebuf, (10*HZ), 5, 0);
  192. if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
  193. u8 *desc = sensebuf + 8;
  194. cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
  195. /* If we set cc then ATA pass-through will cause a
  196. * check condition even if no error. Filter that. */
  197. if (cmd_result & SAM_STAT_CHECK_CONDITION) {
  198. struct scsi_sense_hdr sshdr;
  199. scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
  200. &sshdr);
  201. if (sshdr.sense_key==0 &&
  202. sshdr.asc==0 && sshdr.ascq==0)
  203. cmd_result &= ~SAM_STAT_CHECK_CONDITION;
  204. }
  205. /* Send userspace a few ATA registers (same as drivers/ide) */
  206. if (sensebuf[0] == 0x72 && /* format is "descriptor" */
  207. desc[0] == 0x09 ) { /* code is "ATA Descriptor" */
  208. args[0] = desc[13]; /* status */
  209. args[1] = desc[3]; /* error */
  210. args[2] = desc[5]; /* sector count (0:7) */
  211. if (copy_to_user(arg, args, sizeof(args)))
  212. rc = -EFAULT;
  213. }
  214. }
  215. if (cmd_result) {
  216. rc = -EIO;
  217. goto error;
  218. }
  219. if ((argbuf)
  220. && copy_to_user(arg + sizeof(args), argbuf, argsize))
  221. rc = -EFAULT;
  222. error:
  223. kfree(sensebuf);
  224. kfree(argbuf);
  225. return rc;
  226. }
  227. /**
  228. * ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
  229. * @scsidev: Device to which we are issuing command
  230. * @arg: User provided data for issuing command
  231. *
  232. * LOCKING:
  233. * Defined by the SCSI layer. We don't really care.
  234. *
  235. * RETURNS:
  236. * Zero on success, negative errno on error.
  237. */
  238. int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
  239. {
  240. int rc = 0;
  241. u8 scsi_cmd[MAX_COMMAND_SIZE];
  242. u8 args[7];
  243. struct scsi_sense_hdr sshdr;
  244. if (arg == NULL)
  245. return -EINVAL;
  246. if (copy_from_user(args, arg, sizeof(args)))
  247. return -EFAULT;
  248. memset(scsi_cmd, 0, sizeof(scsi_cmd));
  249. scsi_cmd[0] = ATA_16;
  250. scsi_cmd[1] = (3 << 1); /* Non-data */
  251. /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
  252. scsi_cmd[4] = args[1];
  253. scsi_cmd[6] = args[2];
  254. scsi_cmd[8] = args[3];
  255. scsi_cmd[10] = args[4];
  256. scsi_cmd[12] = args[5];
  257. scsi_cmd[14] = args[0];
  258. /* Good values for timeout and retries? Values below
  259. from scsi_ioctl_send_command() for default case... */
  260. if (scsi_execute_req(scsidev, scsi_cmd, DMA_NONE, NULL, 0, &sshdr,
  261. (10*HZ), 5))
  262. rc = -EIO;
  263. /* Need code to retrieve data from check condition? */
  264. return rc;
  265. }
  266. int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
  267. {
  268. int val = -EINVAL, rc = -EINVAL;
  269. switch (cmd) {
  270. case ATA_IOC_GET_IO32:
  271. val = 0;
  272. if (copy_to_user(arg, &val, 1))
  273. return -EFAULT;
  274. return 0;
  275. case ATA_IOC_SET_IO32:
  276. val = (unsigned long) arg;
  277. if (val != 0)
  278. return -EINVAL;
  279. return 0;
  280. case HDIO_DRIVE_CMD:
  281. if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
  282. return -EACCES;
  283. return ata_cmd_ioctl(scsidev, arg);
  284. case HDIO_DRIVE_TASK:
  285. if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
  286. return -EACCES;
  287. return ata_task_ioctl(scsidev, arg);
  288. default:
  289. rc = -ENOTTY;
  290. break;
  291. }
  292. return rc;
  293. }
  294. /**
  295. * ata_scsi_qc_new - acquire new ata_queued_cmd reference
  296. * @dev: ATA device to which the new command is attached
  297. * @cmd: SCSI command that originated this ATA command
  298. * @done: SCSI command completion function
  299. *
  300. * Obtain a reference to an unused ata_queued_cmd structure,
  301. * which is the basic libata structure representing a single
  302. * ATA command sent to the hardware.
  303. *
  304. * If a command was available, fill in the SCSI-specific
  305. * portions of the structure with information on the
  306. * current command.
  307. *
  308. * LOCKING:
  309. * spin_lock_irqsave(host lock)
  310. *
  311. * RETURNS:
  312. * Command allocated, or %NULL if none available.
  313. */
  314. struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
  315. struct scsi_cmnd *cmd,
  316. void (*done)(struct scsi_cmnd *))
  317. {
  318. struct ata_queued_cmd *qc;
  319. qc = ata_qc_new_init(dev);
  320. if (qc) {
  321. qc->scsicmd = cmd;
  322. qc->scsidone = done;
  323. if (cmd->use_sg) {
  324. qc->__sg = (struct scatterlist *) cmd->request_buffer;
  325. qc->n_elem = cmd->use_sg;
  326. } else {
  327. qc->__sg = &qc->sgent;
  328. qc->n_elem = 1;
  329. }
  330. } else {
  331. cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
  332. done(cmd);
  333. }
  334. return qc;
  335. }
  336. /**
  337. * ata_dump_status - user friendly display of error info
  338. * @id: id of the port in question
  339. * @tf: ptr to filled out taskfile
  340. *
  341. * Decode and dump the ATA error/status registers for the user so
  342. * that they have some idea what really happened at the non
  343. * make-believe layer.
  344. *
  345. * LOCKING:
  346. * inherited from caller
  347. */
  348. void ata_dump_status(unsigned id, struct ata_taskfile *tf)
  349. {
  350. u8 stat = tf->command, err = tf->feature;
  351. printk(KERN_WARNING "ata%u: status=0x%02x { ", id, stat);
  352. if (stat & ATA_BUSY) {
  353. printk("Busy }\n"); /* Data is not valid in this case */
  354. } else {
  355. if (stat & 0x40) printk("DriveReady ");
  356. if (stat & 0x20) printk("DeviceFault ");
  357. if (stat & 0x10) printk("SeekComplete ");
  358. if (stat & 0x08) printk("DataRequest ");
  359. if (stat & 0x04) printk("CorrectedError ");
  360. if (stat & 0x02) printk("Index ");
  361. if (stat & 0x01) printk("Error ");
  362. printk("}\n");
  363. if (err) {
  364. printk(KERN_WARNING "ata%u: error=0x%02x { ", id, err);
  365. if (err & 0x04) printk("DriveStatusError ");
  366. if (err & 0x80) {
  367. if (err & 0x04) printk("BadCRC ");
  368. else printk("Sector ");
  369. }
  370. if (err & 0x40) printk("UncorrectableError ");
  371. if (err & 0x10) printk("SectorIdNotFound ");
  372. if (err & 0x02) printk("TrackZeroNotFound ");
  373. if (err & 0x01) printk("AddrMarkNotFound ");
  374. printk("}\n");
  375. }
  376. }
  377. }
  378. /**
  379. * ata_scsi_device_suspend - suspend ATA device associated with sdev
  380. * @sdev: the SCSI device to suspend
  381. * @mesg: target power management message
  382. *
  383. * Request suspend EH action on the ATA device associated with
  384. * @sdev and wait for the operation to complete.
  385. *
  386. * LOCKING:
  387. * Kernel thread context (may sleep).
  388. *
  389. * RETURNS:
  390. * 0 on success, -errno otherwise.
  391. */
  392. int ata_scsi_device_suspend(struct scsi_device *sdev, pm_message_t mesg)
  393. {
  394. struct ata_port *ap = ata_shost_to_port(sdev->host);
  395. struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
  396. unsigned long flags;
  397. unsigned int action;
  398. int rc = 0;
  399. if (!dev)
  400. goto out;
  401. spin_lock_irqsave(ap->lock, flags);
  402. /* wait for the previous resume to complete */
  403. while (dev->flags & ATA_DFLAG_SUSPENDED) {
  404. spin_unlock_irqrestore(ap->lock, flags);
  405. ata_port_wait_eh(ap);
  406. spin_lock_irqsave(ap->lock, flags);
  407. }
  408. /* if @sdev is already detached, nothing to do */
  409. if (sdev->sdev_state == SDEV_OFFLINE ||
  410. sdev->sdev_state == SDEV_CANCEL || sdev->sdev_state == SDEV_DEL)
  411. goto out_unlock;
  412. /* request suspend */
  413. action = ATA_EH_SUSPEND;
  414. if (mesg.event != PM_EVENT_SUSPEND)
  415. action |= ATA_EH_PM_FREEZE;
  416. ap->eh_info.dev_action[dev->devno] |= action;
  417. ap->eh_info.flags |= ATA_EHI_QUIET;
  418. ata_port_schedule_eh(ap);
  419. spin_unlock_irqrestore(ap->lock, flags);
  420. /* wait for EH to do the job */
  421. ata_port_wait_eh(ap);
  422. spin_lock_irqsave(ap->lock, flags);
  423. /* If @sdev is still attached but the associated ATA device
  424. * isn't suspended, the operation failed.
  425. */
  426. if (sdev->sdev_state != SDEV_OFFLINE &&
  427. sdev->sdev_state != SDEV_CANCEL && sdev->sdev_state != SDEV_DEL &&
  428. !(dev->flags & ATA_DFLAG_SUSPENDED))
  429. rc = -EIO;
  430. out_unlock:
  431. spin_unlock_irqrestore(ap->lock, flags);
  432. out:
  433. if (rc == 0)
  434. sdev->sdev_gendev.power.power_state = mesg;
  435. return rc;
  436. }
  437. /**
  438. * ata_scsi_device_resume - resume ATA device associated with sdev
  439. * @sdev: the SCSI device to resume
  440. *
  441. * Request resume EH action on the ATA device associated with
  442. * @sdev and return immediately. This enables parallel
  443. * wakeup/spinup of devices.
  444. *
  445. * LOCKING:
  446. * Kernel thread context (may sleep).
  447. *
  448. * RETURNS:
  449. * 0.
  450. */
  451. int ata_scsi_device_resume(struct scsi_device *sdev)
  452. {
  453. struct ata_port *ap = ata_shost_to_port(sdev->host);
  454. struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
  455. struct ata_eh_info *ehi = &ap->eh_info;
  456. unsigned long flags;
  457. unsigned int action;
  458. if (!dev)
  459. goto out;
  460. spin_lock_irqsave(ap->lock, flags);
  461. /* if @sdev is already detached, nothing to do */
  462. if (sdev->sdev_state == SDEV_OFFLINE ||
  463. sdev->sdev_state == SDEV_CANCEL || sdev->sdev_state == SDEV_DEL)
  464. goto out_unlock;
  465. /* request resume */
  466. action = ATA_EH_RESUME;
  467. if (sdev->sdev_gendev.power.power_state.event == PM_EVENT_SUSPEND)
  468. __ata_ehi_hotplugged(ehi);
  469. else
  470. action |= ATA_EH_PM_FREEZE | ATA_EH_SOFTRESET;
  471. ehi->dev_action[dev->devno] |= action;
  472. /* We don't want autopsy and verbose EH messages. Disable
  473. * those if we're the only device on this link.
  474. */
  475. if (ata_port_max_devices(ap) == 1)
  476. ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
  477. ata_port_schedule_eh(ap);
  478. out_unlock:
  479. spin_unlock_irqrestore(ap->lock, flags);
  480. out:
  481. sdev->sdev_gendev.power.power_state = PMSG_ON;
  482. return 0;
  483. }
  484. /**
  485. * ata_to_sense_error - convert ATA error to SCSI error
  486. * @id: ATA device number
  487. * @drv_stat: value contained in ATA status register
  488. * @drv_err: value contained in ATA error register
  489. * @sk: the sense key we'll fill out
  490. * @asc: the additional sense code we'll fill out
  491. * @ascq: the additional sense code qualifier we'll fill out
  492. * @verbose: be verbose
  493. *
  494. * Converts an ATA error into a SCSI error. Fill out pointers to
  495. * SK, ASC, and ASCQ bytes for later use in fixed or descriptor
  496. * format sense blocks.
  497. *
  498. * LOCKING:
  499. * spin_lock_irqsave(host lock)
  500. */
  501. void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
  502. u8 *ascq, int verbose)
  503. {
  504. int i;
  505. /* Based on the 3ware driver translation table */
  506. static const unsigned char sense_table[][4] = {
  507. /* BBD|ECC|ID|MAR */
  508. {0xd1, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
  509. /* BBD|ECC|ID */
  510. {0xd0, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
  511. /* ECC|MC|MARK */
  512. {0x61, HARDWARE_ERROR, 0x00, 0x00}, // Device fault Hardware error
  513. /* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
  514. {0x84, ABORTED_COMMAND, 0x47, 0x00}, // Data CRC error SCSI parity error
  515. /* MC|ID|ABRT|TRK0|MARK */
  516. {0x37, NOT_READY, 0x04, 0x00}, // Unit offline Not ready
  517. /* MCR|MARK */
  518. {0x09, NOT_READY, 0x04, 0x00}, // Unrecovered disk error Not ready
  519. /* Bad address mark */
  520. {0x01, MEDIUM_ERROR, 0x13, 0x00}, // Address mark not found Address mark not found for data field
  521. /* TRK0 */
  522. {0x02, HARDWARE_ERROR, 0x00, 0x00}, // Track 0 not found Hardware error
  523. /* Abort & !ICRC */
  524. {0x04, ABORTED_COMMAND, 0x00, 0x00}, // Aborted command Aborted command
  525. /* Media change request */
  526. {0x08, NOT_READY, 0x04, 0x00}, // Media change request FIXME: faking offline
  527. /* SRV */
  528. {0x10, ABORTED_COMMAND, 0x14, 0x00}, // ID not found Recorded entity not found
  529. /* Media change */
  530. {0x08, NOT_READY, 0x04, 0x00}, // Media change FIXME: faking offline
  531. /* ECC */
  532. {0x40, MEDIUM_ERROR, 0x11, 0x04}, // Uncorrectable ECC error Unrecovered read error
  533. /* BBD - block marked bad */
  534. {0x80, MEDIUM_ERROR, 0x11, 0x04}, // Block marked bad Medium error, unrecovered read error
  535. {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
  536. };
  537. static const unsigned char stat_table[][4] = {
  538. /* Must be first because BUSY means no other bits valid */
  539. {0x80, ABORTED_COMMAND, 0x47, 0x00}, // Busy, fake parity for now
  540. {0x20, HARDWARE_ERROR, 0x00, 0x00}, // Device fault
  541. {0x08, ABORTED_COMMAND, 0x47, 0x00}, // Timed out in xfer, fake parity for now
  542. {0x04, RECOVERED_ERROR, 0x11, 0x00}, // Recovered ECC error Medium error, recovered
  543. {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
  544. };
  545. /*
  546. * Is this an error we can process/parse
  547. */
  548. if (drv_stat & ATA_BUSY) {
  549. drv_err = 0; /* Ignore the err bits, they're invalid */
  550. }
  551. if (drv_err) {
  552. /* Look for drv_err */
  553. for (i = 0; sense_table[i][0] != 0xFF; i++) {
  554. /* Look for best matches first */
  555. if ((sense_table[i][0] & drv_err) ==
  556. sense_table[i][0]) {
  557. *sk = sense_table[i][1];
  558. *asc = sense_table[i][2];
  559. *ascq = sense_table[i][3];
  560. goto translate_done;
  561. }
  562. }
  563. /* No immediate match */
  564. if (verbose)
  565. printk(KERN_WARNING "ata%u: no sense translation for "
  566. "error 0x%02x\n", id, drv_err);
  567. }
  568. /* Fall back to interpreting status bits */
  569. for (i = 0; stat_table[i][0] != 0xFF; i++) {
  570. if (stat_table[i][0] & drv_stat) {
  571. *sk = stat_table[i][1];
  572. *asc = stat_table[i][2];
  573. *ascq = stat_table[i][3];
  574. goto translate_done;
  575. }
  576. }
  577. /* No error? Undecoded? */
  578. if (verbose)
  579. printk(KERN_WARNING "ata%u: no sense translation for "
  580. "status: 0x%02x\n", id, drv_stat);
  581. /* We need a sensible error return here, which is tricky, and one
  582. that won't cause people to do things like return a disk wrongly */
  583. *sk = ABORTED_COMMAND;
  584. *asc = 0x00;
  585. *ascq = 0x00;
  586. translate_done:
  587. if (verbose)
  588. printk(KERN_ERR "ata%u: translated ATA stat/err 0x%02x/%02x "
  589. "to SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n",
  590. id, drv_stat, drv_err, *sk, *asc, *ascq);
  591. return;
  592. }
  593. /*
  594. * ata_gen_passthru_sense - Generate check condition sense block.
  595. * @qc: Command that completed.
  596. *
  597. * This function is specific to the ATA descriptor format sense
  598. * block specified for the ATA pass through commands. Regardless
  599. * of whether the command errored or not, return a sense
  600. * block. Copy all controller registers into the sense
  601. * block. Clear sense key, ASC & ASCQ if there is no error.
  602. *
  603. * LOCKING:
  604. * None.
  605. */
  606. static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
  607. {
  608. struct scsi_cmnd *cmd = qc->scsicmd;
  609. struct ata_taskfile *tf = &qc->result_tf;
  610. unsigned char *sb = cmd->sense_buffer;
  611. unsigned char *desc = sb + 8;
  612. int verbose = qc->ap->ops->error_handler == NULL;
  613. memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
  614. cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
  615. /*
  616. * Use ata_to_sense_error() to map status register bits
  617. * onto sense key, asc & ascq.
  618. */
  619. if (qc->err_mask ||
  620. tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
  621. ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
  622. &sb[1], &sb[2], &sb[3], verbose);
  623. sb[1] &= 0x0f;
  624. }
  625. /*
  626. * Sense data is current and format is descriptor.
  627. */
  628. sb[0] = 0x72;
  629. desc[0] = 0x09;
  630. /* set length of additional sense data */
  631. sb[7] = 14;
  632. desc[1] = 12;
  633. /*
  634. * Copy registers into sense buffer.
  635. */
  636. desc[2] = 0x00;
  637. desc[3] = tf->feature; /* == error reg */
  638. desc[5] = tf->nsect;
  639. desc[7] = tf->lbal;
  640. desc[9] = tf->lbam;
  641. desc[11] = tf->lbah;
  642. desc[12] = tf->device;
  643. desc[13] = tf->command; /* == status reg */
  644. /*
  645. * Fill in Extend bit, and the high order bytes
  646. * if applicable.
  647. */
  648. if (tf->flags & ATA_TFLAG_LBA48) {
  649. desc[2] |= 0x01;
  650. desc[4] = tf->hob_nsect;
  651. desc[6] = tf->hob_lbal;
  652. desc[8] = tf->hob_lbam;
  653. desc[10] = tf->hob_lbah;
  654. }
  655. }
  656. /**
  657. * ata_gen_ata_sense - generate a SCSI fixed sense block
  658. * @qc: Command that we are erroring out
  659. *
  660. * Generate sense block for a failed ATA command @qc. Descriptor
  661. * format is used to accomodate LBA48 block address.
  662. *
  663. * LOCKING:
  664. * None.
  665. */
  666. static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
  667. {
  668. struct ata_device *dev = qc->dev;
  669. struct scsi_cmnd *cmd = qc->scsicmd;
  670. struct ata_taskfile *tf = &qc->result_tf;
  671. unsigned char *sb = cmd->sense_buffer;
  672. unsigned char *desc = sb + 8;
  673. int verbose = qc->ap->ops->error_handler == NULL;
  674. u64 block;
  675. memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
  676. cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
  677. /* sense data is current and format is descriptor */
  678. sb[0] = 0x72;
  679. /* Use ata_to_sense_error() to map status register bits
  680. * onto sense key, asc & ascq.
  681. */
  682. if (qc->err_mask ||
  683. tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
  684. ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
  685. &sb[1], &sb[2], &sb[3], verbose);
  686. sb[1] &= 0x0f;
  687. }
  688. block = ata_tf_read_block(&qc->result_tf, dev);
  689. /* information sense data descriptor */
  690. sb[7] = 12;
  691. desc[0] = 0x00;
  692. desc[1] = 10;
  693. desc[2] |= 0x80; /* valid */
  694. desc[6] = block >> 40;
  695. desc[7] = block >> 32;
  696. desc[8] = block >> 24;
  697. desc[9] = block >> 16;
  698. desc[10] = block >> 8;
  699. desc[11] = block;
  700. }
  701. static void ata_scsi_sdev_config(struct scsi_device *sdev)
  702. {
  703. sdev->use_10_for_rw = 1;
  704. sdev->use_10_for_ms = 1;
  705. }
  706. static void ata_scsi_dev_config(struct scsi_device *sdev,
  707. struct ata_device *dev)
  708. {
  709. /* configure max sectors */
  710. blk_queue_max_sectors(sdev->request_queue, dev->max_sectors);
  711. /* SATA DMA transfers must be multiples of 4 byte, so
  712. * we need to pad ATAPI transfers using an extra sg.
  713. * Decrement max hw segments accordingly.
  714. */
  715. if (dev->class == ATA_DEV_ATAPI) {
  716. request_queue_t *q = sdev->request_queue;
  717. blk_queue_max_hw_segments(q, q->max_hw_segments - 1);
  718. }
  719. if (dev->flags & ATA_DFLAG_NCQ) {
  720. int depth;
  721. depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
  722. depth = min(ATA_MAX_QUEUE - 1, depth);
  723. scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
  724. }
  725. }
  726. /**
  727. * ata_scsi_slave_config - Set SCSI device attributes
  728. * @sdev: SCSI device to examine
  729. *
  730. * This is called before we actually start reading
  731. * and writing to the device, to configure certain
  732. * SCSI mid-layer behaviors.
  733. *
  734. * LOCKING:
  735. * Defined by SCSI layer. We don't really care.
  736. */
  737. int ata_scsi_slave_config(struct scsi_device *sdev)
  738. {
  739. struct ata_port *ap = ata_shost_to_port(sdev->host);
  740. struct ata_device *dev = __ata_scsi_find_dev(ap, sdev);
  741. ata_scsi_sdev_config(sdev);
  742. blk_queue_max_phys_segments(sdev->request_queue, LIBATA_MAX_PRD);
  743. if (dev)
  744. ata_scsi_dev_config(sdev, dev);
  745. return 0; /* scsi layer doesn't check return value, sigh */
  746. }
  747. /**
  748. * ata_scsi_slave_destroy - SCSI device is about to be destroyed
  749. * @sdev: SCSI device to be destroyed
  750. *
  751. * @sdev is about to be destroyed for hot/warm unplugging. If
  752. * this unplugging was initiated by libata as indicated by NULL
  753. * dev->sdev, this function doesn't have to do anything.
  754. * Otherwise, SCSI layer initiated warm-unplug is in progress.
  755. * Clear dev->sdev, schedule the device for ATA detach and invoke
  756. * EH.
  757. *
  758. * LOCKING:
  759. * Defined by SCSI layer. We don't really care.
  760. */
  761. void ata_scsi_slave_destroy(struct scsi_device *sdev)
  762. {
  763. struct ata_port *ap = ata_shost_to_port(sdev->host);
  764. unsigned long flags;
  765. struct ata_device *dev;
  766. if (!ap->ops->error_handler)
  767. return;
  768. spin_lock_irqsave(ap->lock, flags);
  769. dev = __ata_scsi_find_dev(ap, sdev);
  770. if (dev && dev->sdev) {
  771. /* SCSI device already in CANCEL state, no need to offline it */
  772. dev->sdev = NULL;
  773. dev->flags |= ATA_DFLAG_DETACH;
  774. ata_port_schedule_eh(ap);
  775. }
  776. spin_unlock_irqrestore(ap->lock, flags);
  777. }
  778. /**
  779. * ata_scsi_change_queue_depth - SCSI callback for queue depth config
  780. * @sdev: SCSI device to configure queue depth for
  781. * @queue_depth: new queue depth
  782. *
  783. * This is libata standard hostt->change_queue_depth callback.
  784. * SCSI will call into this callback when user tries to set queue
  785. * depth via sysfs.
  786. *
  787. * LOCKING:
  788. * SCSI layer (we don't care)
  789. *
  790. * RETURNS:
  791. * Newly configured queue depth.
  792. */
  793. int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
  794. {
  795. struct ata_port *ap = ata_shost_to_port(sdev->host);
  796. struct ata_device *dev;
  797. unsigned long flags;
  798. int max_depth;
  799. if (queue_depth < 1)
  800. return sdev->queue_depth;
  801. dev = ata_scsi_find_dev(ap, sdev);
  802. if (!dev || !ata_dev_enabled(dev))
  803. return sdev->queue_depth;
  804. max_depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
  805. max_depth = min(ATA_MAX_QUEUE - 1, max_depth);
  806. if (queue_depth > max_depth)
  807. queue_depth = max_depth;
  808. scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
  809. spin_lock_irqsave(ap->lock, flags);
  810. if (queue_depth > 1)
  811. dev->flags &= ~ATA_DFLAG_NCQ_OFF;
  812. else
  813. dev->flags |= ATA_DFLAG_NCQ_OFF;
  814. spin_unlock_irqrestore(ap->lock, flags);
  815. return queue_depth;
  816. }
  817. /**
  818. * ata_scsi_start_stop_xlat - Translate SCSI START STOP UNIT command
  819. * @qc: Storage for translated ATA taskfile
  820. *
  821. * Sets up an ATA taskfile to issue STANDBY (to stop) or READ VERIFY
  822. * (to start). Perhaps these commands should be preceded by
  823. * CHECK POWER MODE to see what power mode the device is already in.
  824. * [See SAT revision 5 at www.t10.org]
  825. *
  826. * LOCKING:
  827. * spin_lock_irqsave(host lock)
  828. *
  829. * RETURNS:
  830. * Zero on success, non-zero on error.
  831. */
  832. static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
  833. {
  834. struct scsi_cmnd *scmd = qc->scsicmd;
  835. struct ata_taskfile *tf = &qc->tf;
  836. const u8 *cdb = scmd->cmnd;
  837. tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
  838. tf->protocol = ATA_PROT_NODATA;
  839. if (cdb[1] & 0x1) {
  840. ; /* ignore IMMED bit, violates sat-r05 */
  841. }
  842. if (cdb[4] & 0x2)
  843. goto invalid_fld; /* LOEJ bit set not supported */
  844. if (((cdb[4] >> 4) & 0xf) != 0)
  845. goto invalid_fld; /* power conditions not supported */
  846. if (cdb[4] & 0x1) {
  847. tf->nsect = 1; /* 1 sector, lba=0 */
  848. if (qc->dev->flags & ATA_DFLAG_LBA) {
  849. tf->flags |= ATA_TFLAG_LBA;
  850. tf->lbah = 0x0;
  851. tf->lbam = 0x0;
  852. tf->lbal = 0x0;
  853. tf->device |= ATA_LBA;
  854. } else {
  855. /* CHS */
  856. tf->lbal = 0x1; /* sect */
  857. tf->lbam = 0x0; /* cyl low */
  858. tf->lbah = 0x0; /* cyl high */
  859. }
  860. tf->command = ATA_CMD_VERIFY; /* READ VERIFY */
  861. } else {
  862. tf->nsect = 0; /* time period value (0 implies now) */
  863. tf->command = ATA_CMD_STANDBY;
  864. /* Consider: ATA STANDBY IMMEDIATE command */
  865. }
  866. /*
  867. * Standby and Idle condition timers could be implemented but that
  868. * would require libata to implement the Power condition mode page
  869. * and allow the user to change it. Changing mode pages requires
  870. * MODE SELECT to be implemented.
  871. */
  872. return 0;
  873. invalid_fld:
  874. ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
  875. /* "Invalid field in cbd" */
  876. return 1;
  877. }
  878. /**
  879. * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
  880. * @qc: Storage for translated ATA taskfile
  881. *
  882. * Sets up an ATA taskfile to issue FLUSH CACHE or
  883. * FLUSH CACHE EXT.
  884. *
  885. * LOCKING:
  886. * spin_lock_irqsave(host lock)
  887. *
  888. * RETURNS:
  889. * Zero on success, non-zero on error.
  890. */
  891. static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc)
  892. {
  893. struct ata_taskfile *tf = &qc->tf;
  894. tf->flags |= ATA_TFLAG_DEVICE;
  895. tf->protocol = ATA_PROT_NODATA;
  896. if (qc->dev->flags & ATA_DFLAG_FLUSH_EXT)
  897. tf->command = ATA_CMD_FLUSH_EXT;
  898. else
  899. tf->command = ATA_CMD_FLUSH;
  900. return 0;
  901. }
  902. /**
  903. * scsi_6_lba_len - Get LBA and transfer length
  904. * @cdb: SCSI command to translate
  905. *
  906. * Calculate LBA and transfer length for 6-byte commands.
  907. *
  908. * RETURNS:
  909. * @plba: the LBA
  910. * @plen: the transfer length
  911. */
  912. static void scsi_6_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
  913. {
  914. u64 lba = 0;
  915. u32 len = 0;
  916. VPRINTK("six-byte command\n");
  917. lba |= ((u64)cdb[2]) << 8;
  918. lba |= ((u64)cdb[3]);
  919. len |= ((u32)cdb[4]);
  920. *plba = lba;
  921. *plen = len;
  922. }
  923. /**
  924. * scsi_10_lba_len - Get LBA and transfer length
  925. * @cdb: SCSI command to translate
  926. *
  927. * Calculate LBA and transfer length for 10-byte commands.
  928. *
  929. * RETURNS:
  930. * @plba: the LBA
  931. * @plen: the transfer length
  932. */
  933. static void scsi_10_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
  934. {
  935. u64 lba = 0;
  936. u32 len = 0;
  937. VPRINTK("ten-byte command\n");
  938. lba |= ((u64)cdb[2]) << 24;
  939. lba |= ((u64)cdb[3]) << 16;
  940. lba |= ((u64)cdb[4]) << 8;
  941. lba |= ((u64)cdb[5]);
  942. len |= ((u32)cdb[7]) << 8;
  943. len |= ((u32)cdb[8]);
  944. *plba = lba;
  945. *plen = len;
  946. }
  947. /**
  948. * scsi_16_lba_len - Get LBA and transfer length
  949. * @cdb: SCSI command to translate
  950. *
  951. * Calculate LBA and transfer length for 16-byte commands.
  952. *
  953. * RETURNS:
  954. * @plba: the LBA
  955. * @plen: the transfer length
  956. */
  957. static void scsi_16_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
  958. {
  959. u64 lba = 0;
  960. u32 len = 0;
  961. VPRINTK("sixteen-byte command\n");
  962. lba |= ((u64)cdb[2]) << 56;
  963. lba |= ((u64)cdb[3]) << 48;
  964. lba |= ((u64)cdb[4]) << 40;
  965. lba |= ((u64)cdb[5]) << 32;
  966. lba |= ((u64)cdb[6]) << 24;
  967. lba |= ((u64)cdb[7]) << 16;
  968. lba |= ((u64)cdb[8]) << 8;
  969. lba |= ((u64)cdb[9]);
  970. len |= ((u32)cdb[10]) << 24;
  971. len |= ((u32)cdb[11]) << 16;
  972. len |= ((u32)cdb[12]) << 8;
  973. len |= ((u32)cdb[13]);
  974. *plba = lba;
  975. *plen = len;
  976. }
  977. /**
  978. * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
  979. * @qc: Storage for translated ATA taskfile
  980. *
  981. * Converts SCSI VERIFY command to an ATA READ VERIFY command.
  982. *
  983. * LOCKING:
  984. * spin_lock_irqsave(host lock)
  985. *
  986. * RETURNS:
  987. * Zero on success, non-zero on error.
  988. */
  989. static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
  990. {
  991. struct scsi_cmnd *scmd = qc->scsicmd;
  992. struct ata_taskfile *tf = &qc->tf;
  993. struct ata_device *dev = qc->dev;
  994. u64 dev_sectors = qc->dev->n_sectors;
  995. const u8 *cdb = scmd->cmnd;
  996. u64 block;
  997. u32 n_block;
  998. tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
  999. tf->protocol = ATA_PROT_NODATA;
  1000. if (cdb[0] == VERIFY)
  1001. scsi_10_lba_len(cdb, &block, &n_block);
  1002. else if (cdb[0] == VERIFY_16)
  1003. scsi_16_lba_len(cdb, &block, &n_block);
  1004. else
  1005. goto invalid_fld;
  1006. if (!n_block)
  1007. goto nothing_to_do;
  1008. if (block >= dev_sectors)
  1009. goto out_of_range;
  1010. if ((block + n_block) > dev_sectors)
  1011. goto out_of_range;
  1012. if (dev->flags & ATA_DFLAG_LBA) {
  1013. tf->flags |= ATA_TFLAG_LBA;
  1014. if (lba_28_ok(block, n_block)) {
  1015. /* use LBA28 */
  1016. tf->command = ATA_CMD_VERIFY;
  1017. tf->device |= (block >> 24) & 0xf;
  1018. } else if (lba_48_ok(block, n_block)) {
  1019. if (!(dev->flags & ATA_DFLAG_LBA48))
  1020. goto out_of_range;
  1021. /* use LBA48 */
  1022. tf->flags |= ATA_TFLAG_LBA48;
  1023. tf->command = ATA_CMD_VERIFY_EXT;
  1024. tf->hob_nsect = (n_block >> 8) & 0xff;
  1025. tf->hob_lbah = (block >> 40) & 0xff;
  1026. tf->hob_lbam = (block >> 32) & 0xff;
  1027. tf->hob_lbal = (block >> 24) & 0xff;
  1028. } else
  1029. /* request too large even for LBA48 */
  1030. goto out_of_range;
  1031. tf->nsect = n_block & 0xff;
  1032. tf->lbah = (block >> 16) & 0xff;
  1033. tf->lbam = (block >> 8) & 0xff;
  1034. tf->lbal = block & 0xff;
  1035. tf->device |= ATA_LBA;
  1036. } else {
  1037. /* CHS */
  1038. u32 sect, head, cyl, track;
  1039. if (!lba_28_ok(block, n_block))
  1040. goto out_of_range;
  1041. /* Convert LBA to CHS */
  1042. track = (u32)block / dev->sectors;
  1043. cyl = track / dev->heads;
  1044. head = track % dev->heads;
  1045. sect = (u32)block % dev->sectors + 1;
  1046. DPRINTK("block %u track %u cyl %u head %u sect %u\n",
  1047. (u32)block, track, cyl, head, sect);
  1048. /* Check whether the converted CHS can fit.
  1049. Cylinder: 0-65535
  1050. Head: 0-15
  1051. Sector: 1-255*/
  1052. if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
  1053. goto out_of_range;
  1054. tf->command = ATA_CMD_VERIFY;
  1055. tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
  1056. tf->lbal = sect;
  1057. tf->lbam = cyl;
  1058. tf->lbah = cyl >> 8;
  1059. tf->device |= head;
  1060. }
  1061. return 0;
  1062. invalid_fld:
  1063. ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
  1064. /* "Invalid field in cbd" */
  1065. return 1;
  1066. out_of_range:
  1067. ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
  1068. /* "Logical Block Address out of range" */
  1069. return 1;
  1070. nothing_to_do:
  1071. scmd->result = SAM_STAT_GOOD;
  1072. return 1;
  1073. }
  1074. /**
  1075. * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
  1076. * @qc: Storage for translated ATA taskfile
  1077. *
  1078. * Converts any of six SCSI read/write commands into the
  1079. * ATA counterpart, including starting sector (LBA),
  1080. * sector count, and taking into account the device's LBA48
  1081. * support.
  1082. *
  1083. * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
  1084. * %WRITE_16 are currently supported.
  1085. *
  1086. * LOCKING:
  1087. * spin_lock_irqsave(host lock)
  1088. *
  1089. * RETURNS:
  1090. * Zero on success, non-zero on error.
  1091. */
  1092. static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
  1093. {
  1094. struct scsi_cmnd *scmd = qc->scsicmd;
  1095. const u8 *cdb = scmd->cmnd;
  1096. unsigned int tf_flags = 0;
  1097. u64 block;
  1098. u32 n_block;
  1099. int rc;
  1100. if (cdb[0] == WRITE_10 || cdb[0] == WRITE_6 || cdb[0] == WRITE_16)
  1101. tf_flags |= ATA_TFLAG_WRITE;
  1102. /* Calculate the SCSI LBA, transfer length and FUA. */
  1103. switch (cdb[0]) {
  1104. case READ_10:
  1105. case WRITE_10:
  1106. scsi_10_lba_len(cdb, &block, &n_block);
  1107. if (unlikely(cdb[1] & (1 << 3)))
  1108. tf_flags |= ATA_TFLAG_FUA;
  1109. break;
  1110. case READ_6:
  1111. case WRITE_6:
  1112. scsi_6_lba_len(cdb, &block, &n_block);
  1113. /* for 6-byte r/w commands, transfer length 0
  1114. * means 256 blocks of data, not 0 block.
  1115. */
  1116. if (!n_block)
  1117. n_block = 256;
  1118. break;
  1119. case READ_16:
  1120. case WRITE_16:
  1121. scsi_16_lba_len(cdb, &block, &n_block);
  1122. if (unlikely(cdb[1] & (1 << 3)))
  1123. tf_flags |= ATA_TFLAG_FUA;
  1124. break;
  1125. default:
  1126. DPRINTK("no-byte command\n");
  1127. goto invalid_fld;
  1128. }
  1129. /* Check and compose ATA command */
  1130. if (!n_block)
  1131. /* For 10-byte and 16-byte SCSI R/W commands, transfer
  1132. * length 0 means transfer 0 block of data.
  1133. * However, for ATA R/W commands, sector count 0 means
  1134. * 256 or 65536 sectors, not 0 sectors as in SCSI.
  1135. *
  1136. * WARNING: one or two older ATA drives treat 0 as 0...
  1137. */
  1138. goto nothing_to_do;
  1139. qc->flags |= ATA_QCFLAG_IO;
  1140. qc->nsect = n_block;
  1141. rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
  1142. qc->tag);
  1143. if (likely(rc == 0))
  1144. return 0;
  1145. if (rc == -ERANGE)
  1146. goto out_of_range;
  1147. /* treat all other errors as -EINVAL, fall through */
  1148. invalid_fld:
  1149. ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
  1150. /* "Invalid field in cbd" */
  1151. return 1;
  1152. out_of_range:
  1153. ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
  1154. /* "Logical Block Address out of range" */
  1155. return 1;
  1156. nothing_to_do:
  1157. scmd->result = SAM_STAT_GOOD;
  1158. return 1;
  1159. }
  1160. static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
  1161. {
  1162. struct ata_port *ap = qc->ap;
  1163. struct scsi_cmnd *cmd = qc->scsicmd;
  1164. u8 *cdb = cmd->cmnd;
  1165. int need_sense = (qc->err_mask != 0);
  1166. /* We snoop the SET_FEATURES - Write Cache ON/OFF command, and
  1167. * schedule EH_REVALIDATE operation to update the IDENTIFY DEVICE
  1168. * cache
  1169. */
  1170. if (ap->ops->error_handler &&
  1171. !need_sense && (qc->tf.command == ATA_CMD_SET_FEATURES) &&
  1172. ((qc->tf.feature == SETFEATURES_WC_ON) ||
  1173. (qc->tf.feature == SETFEATURES_WC_OFF))) {
  1174. ap->eh_info.action |= ATA_EH_REVALIDATE;
  1175. ata_port_schedule_eh(ap);
  1176. }
  1177. /* For ATA pass thru (SAT) commands, generate a sense block if
  1178. * user mandated it or if there's an error. Note that if we
  1179. * generate because the user forced us to, a check condition
  1180. * is generated and the ATA register values are returned
  1181. * whether the command completed successfully or not. If there
  1182. * was no error, SK, ASC and ASCQ will all be zero.
  1183. */
  1184. if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
  1185. ((cdb[2] & 0x20) || need_sense)) {
  1186. ata_gen_passthru_sense(qc);
  1187. } else {
  1188. if (!need_sense) {
  1189. cmd->result = SAM_STAT_GOOD;
  1190. } else {
  1191. /* TODO: decide which descriptor format to use
  1192. * for 48b LBA devices and call that here
  1193. * instead of the fixed desc, which is only
  1194. * good for smaller LBA (and maybe CHS?)
  1195. * devices.
  1196. */
  1197. ata_gen_ata_sense(qc);
  1198. }
  1199. }
  1200. if (need_sense && !ap->ops->error_handler)
  1201. ata_dump_status(ap->id, &qc->result_tf);
  1202. qc->scsidone(cmd);
  1203. ata_qc_free(qc);
  1204. }
  1205. /**
  1206. * ata_scmd_need_defer - Check whether we need to defer scmd
  1207. * @dev: ATA device to which the command is addressed
  1208. * @is_io: Is the command IO (and thus possibly NCQ)?
  1209. *
  1210. * NCQ and non-NCQ commands cannot run together. As upper layer
  1211. * only knows the queue depth, we are responsible for maintaining
  1212. * exclusion. This function checks whether a new command can be
  1213. * issued to @dev.
  1214. *
  1215. * LOCKING:
  1216. * spin_lock_irqsave(host lock)
  1217. *
  1218. * RETURNS:
  1219. * 1 if deferring is needed, 0 otherwise.
  1220. */
  1221. static int ata_scmd_need_defer(struct ata_device *dev, int is_io)
  1222. {
  1223. struct ata_port *ap = dev->ap;
  1224. if (!(dev->flags & ATA_DFLAG_NCQ))
  1225. return 0;
  1226. if (is_io) {
  1227. if (!ata_tag_valid(ap->active_tag))
  1228. return 0;
  1229. } else {
  1230. if (!ata_tag_valid(ap->active_tag) && !ap->sactive)
  1231. return 0;
  1232. }
  1233. return 1;
  1234. }
  1235. /**
  1236. * ata_scsi_translate - Translate then issue SCSI command to ATA device
  1237. * @dev: ATA device to which the command is addressed
  1238. * @cmd: SCSI command to execute
  1239. * @done: SCSI command completion function
  1240. * @xlat_func: Actor which translates @cmd to an ATA taskfile
  1241. *
  1242. * Our ->queuecommand() function has decided that the SCSI
  1243. * command issued can be directly translated into an ATA
  1244. * command, rather than handled internally.
  1245. *
  1246. * This function sets up an ata_queued_cmd structure for the
  1247. * SCSI command, and sends that ata_queued_cmd to the hardware.
  1248. *
  1249. * The xlat_func argument (actor) returns 0 if ready to execute
  1250. * ATA command, else 1 to finish translation. If 1 is returned
  1251. * then cmd->result (and possibly cmd->sense_buffer) are assumed
  1252. * to be set reflecting an error condition or clean (early)
  1253. * termination.
  1254. *
  1255. * LOCKING:
  1256. * spin_lock_irqsave(host lock)
  1257. *
  1258. * RETURNS:
  1259. * 0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
  1260. * needs to be deferred.
  1261. */
  1262. static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
  1263. void (*done)(struct scsi_cmnd *),
  1264. ata_xlat_func_t xlat_func)
  1265. {
  1266. struct ata_queued_cmd *qc;
  1267. int is_io = xlat_func == ata_scsi_rw_xlat;
  1268. VPRINTK("ENTER\n");
  1269. if (unlikely(ata_scmd_need_defer(dev, is_io)))
  1270. goto defer;
  1271. qc = ata_scsi_qc_new(dev, cmd, done);
  1272. if (!qc)
  1273. goto err_mem;
  1274. /* data is present; dma-map it */
  1275. if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
  1276. cmd->sc_data_direction == DMA_TO_DEVICE) {
  1277. if (unlikely(cmd->request_bufflen < 1)) {
  1278. ata_dev_printk(dev, KERN_WARNING,
  1279. "WARNING: zero len r/w req\n");
  1280. goto err_did;
  1281. }
  1282. if (cmd->use_sg)
  1283. ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
  1284. else
  1285. ata_sg_init_one(qc, cmd->request_buffer,
  1286. cmd->request_bufflen);
  1287. qc->dma_dir = cmd->sc_data_direction;
  1288. }
  1289. qc->complete_fn = ata_scsi_qc_complete;
  1290. if (xlat_func(qc))
  1291. goto early_finish;
  1292. /* select device, send command to hardware */
  1293. ata_qc_issue(qc);
  1294. VPRINTK("EXIT\n");
  1295. return 0;
  1296. early_finish:
  1297. ata_qc_free(qc);
  1298. done(cmd);
  1299. DPRINTK("EXIT - early finish (good or error)\n");
  1300. return 0;
  1301. err_did:
  1302. ata_qc_free(qc);
  1303. cmd->result = (DID_ERROR << 16);
  1304. done(cmd);
  1305. err_mem:
  1306. DPRINTK("EXIT - internal\n");
  1307. return 0;
  1308. defer:
  1309. DPRINTK("EXIT - defer\n");
  1310. return SCSI_MLQUEUE_DEVICE_BUSY;
  1311. }
  1312. /**
  1313. * ata_scsi_rbuf_get - Map response buffer.
  1314. * @cmd: SCSI command containing buffer to be mapped.
  1315. * @buf_out: Pointer to mapped area.
  1316. *
  1317. * Maps buffer contained within SCSI command @cmd.
  1318. *
  1319. * LOCKING:
  1320. * spin_lock_irqsave(host lock)
  1321. *
  1322. * RETURNS:
  1323. * Length of response buffer.
  1324. */
  1325. static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
  1326. {
  1327. u8 *buf;
  1328. unsigned int buflen;
  1329. if (cmd->use_sg) {
  1330. struct scatterlist *sg;
  1331. sg = (struct scatterlist *) cmd->request_buffer;
  1332. buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
  1333. buflen = sg->length;
  1334. } else {
  1335. buf = cmd->request_buffer;
  1336. buflen = cmd->request_bufflen;
  1337. }
  1338. *buf_out = buf;
  1339. return buflen;
  1340. }
  1341. /**
  1342. * ata_scsi_rbuf_put - Unmap response buffer.
  1343. * @cmd: SCSI command containing buffer to be unmapped.
  1344. * @buf: buffer to unmap
  1345. *
  1346. * Unmaps response buffer contained within @cmd.
  1347. *
  1348. * LOCKING:
  1349. * spin_lock_irqsave(host lock)
  1350. */
  1351. static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
  1352. {
  1353. if (cmd->use_sg) {
  1354. struct scatterlist *sg;
  1355. sg = (struct scatterlist *) cmd->request_buffer;
  1356. kunmap_atomic(buf - sg->offset, KM_IRQ0);
  1357. }
  1358. }
  1359. /**
  1360. * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
  1361. * @args: device IDENTIFY data / SCSI command of interest.
  1362. * @actor: Callback hook for desired SCSI command simulator
  1363. *
  1364. * Takes care of the hard work of simulating a SCSI command...
  1365. * Mapping the response buffer, calling the command's handler,
  1366. * and handling the handler's return value. This return value
  1367. * indicates whether the handler wishes the SCSI command to be
  1368. * completed successfully (0), or not (in which case cmd->result
  1369. * and sense buffer are assumed to be set).
  1370. *
  1371. * LOCKING:
  1372. * spin_lock_irqsave(host lock)
  1373. */
  1374. void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
  1375. unsigned int (*actor) (struct ata_scsi_args *args,
  1376. u8 *rbuf, unsigned int buflen))
  1377. {
  1378. u8 *rbuf;
  1379. unsigned int buflen, rc;
  1380. struct scsi_cmnd *cmd = args->cmd;
  1381. buflen = ata_scsi_rbuf_get(cmd, &rbuf);
  1382. memset(rbuf, 0, buflen);
  1383. rc = actor(args, rbuf, buflen);
  1384. ata_scsi_rbuf_put(cmd, rbuf);
  1385. if (rc == 0)
  1386. cmd->result = SAM_STAT_GOOD;
  1387. args->done(cmd);
  1388. }
  1389. /**
  1390. * ATA_SCSI_RBUF_SET - helper to set values in SCSI response buffer
  1391. * @idx: byte index into SCSI response buffer
  1392. * @val: value to set
  1393. *
  1394. * To be used by SCSI command simulator functions. This macros
  1395. * expects two local variables, u8 *rbuf and unsigned int buflen,
  1396. * are in scope.
  1397. *
  1398. * LOCKING:
  1399. * None.
  1400. */
  1401. #define ATA_SCSI_RBUF_SET(idx, val) do { \
  1402. if ((idx) < buflen) rbuf[(idx)] = (u8)(val); \
  1403. } while (0)
  1404. /**
  1405. * ata_scsiop_inq_std - Simulate INQUIRY command
  1406. * @args: device IDENTIFY data / SCSI command of interest.
  1407. * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  1408. * @buflen: Response buffer length.
  1409. *
  1410. * Returns standard device identification data associated
  1411. * with non-VPD INQUIRY command output.
  1412. *
  1413. * LOCKING:
  1414. * spin_lock_irqsave(host lock)
  1415. */
  1416. unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
  1417. unsigned int buflen)
  1418. {
  1419. u8 hdr[] = {
  1420. TYPE_DISK,
  1421. 0,
  1422. 0x5, /* claim SPC-3 version compatibility */
  1423. 2,
  1424. 95 - 4
  1425. };
  1426. /* set scsi removeable (RMB) bit per ata bit */
  1427. if (ata_id_removeable(args->id))
  1428. hdr[1] |= (1 << 7);
  1429. VPRINTK("ENTER\n");
  1430. memcpy(rbuf, hdr, sizeof(hdr));
  1431. if (buflen > 35) {
  1432. memcpy(&rbuf[8], "ATA ", 8);
  1433. ata_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
  1434. ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
  1435. if (rbuf[32] == 0 || rbuf[32] == ' ')
  1436. memcpy(&rbuf[32], "n/a ", 4);
  1437. }
  1438. if (buflen > 63) {
  1439. const u8 versions[] = {
  1440. 0x60, /* SAM-3 (no version claimed) */
  1441. 0x03,
  1442. 0x20, /* SBC-2 (no version claimed) */
  1443. 0x02,
  1444. 0x60 /* SPC-3 (no version claimed) */
  1445. };
  1446. memcpy(rbuf + 59, versions, sizeof(versions));
  1447. }
  1448. return 0;
  1449. }
  1450. /**
  1451. * ata_scsiop_inq_00 - Simulate INQUIRY VPD page 0, list of pages
  1452. * @args: device IDENTIFY data / SCSI command of interest.
  1453. * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  1454. * @buflen: Response buffer length.
  1455. *
  1456. * Returns list of inquiry VPD pages available.
  1457. *
  1458. * LOCKING:
  1459. * spin_lock_irqsave(host lock)
  1460. */
  1461. unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
  1462. unsigned int buflen)
  1463. {
  1464. const u8 pages[] = {
  1465. 0x00, /* page 0x00, this page */
  1466. 0x80, /* page 0x80, unit serial no page */
  1467. 0x83 /* page 0x83, device ident page */
  1468. };
  1469. rbuf[3] = sizeof(pages); /* number of supported VPD pages */
  1470. if (buflen > 6)
  1471. memcpy(rbuf + 4, pages, sizeof(pages));
  1472. return 0;
  1473. }
  1474. /**
  1475. * ata_scsiop_inq_80 - Simulate INQUIRY VPD page 80, device serial number
  1476. * @args: device IDENTIFY data / SCSI command of interest.
  1477. * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  1478. * @buflen: Response buffer length.
  1479. *
  1480. * Returns ATA device serial number.
  1481. *
  1482. * LOCKING:
  1483. * spin_lock_irqsave(host lock)
  1484. */
  1485. unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
  1486. unsigned int buflen)
  1487. {
  1488. const u8 hdr[] = {
  1489. 0,
  1490. 0x80, /* this page code */
  1491. 0,
  1492. ATA_SERNO_LEN, /* page len */
  1493. };
  1494. memcpy(rbuf, hdr, sizeof(hdr));
  1495. if (buflen > (ATA_SERNO_LEN + 4 - 1))
  1496. ata_id_string(args->id, (unsigned char *) &rbuf[4],
  1497. ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
  1498. return 0;
  1499. }
  1500. /**
  1501. * ata_scsiop_inq_83 - Simulate INQUIRY VPD page 83, device identity
  1502. * @args: device IDENTIFY data / SCSI command of interest.
  1503. * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  1504. * @buflen: Response buffer length.
  1505. *
  1506. * Yields two logical unit device identification designators:
  1507. * - vendor specific ASCII containing the ATA serial number
  1508. * - SAT defined "t10 vendor id based" containing ASCII vendor
  1509. * name ("ATA "), model and serial numbers.
  1510. *
  1511. * LOCKING:
  1512. * spin_lock_irqsave(host lock)
  1513. */
  1514. unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
  1515. unsigned int buflen)
  1516. {
  1517. int num;
  1518. const int sat_model_serial_desc_len = 68;
  1519. const int ata_model_byte_len = 40;
  1520. rbuf[1] = 0x83; /* this page code */
  1521. num = 4;
  1522. if (buflen > (ATA_SERNO_LEN + num + 3)) {
  1523. /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
  1524. rbuf[num + 0] = 2;
  1525. rbuf[num + 3] = ATA_SERNO_LEN;
  1526. num += 4;
  1527. ata_id_string(args->id, (unsigned char *) rbuf + num,
  1528. ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
  1529. num += ATA_SERNO_LEN;
  1530. }
  1531. if (buflen > (sat_model_serial_desc_len + num + 3)) {
  1532. /* SAT defined lu model and serial numbers descriptor */
  1533. /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
  1534. rbuf[num + 0] = 2;
  1535. rbuf[num + 1] = 1;
  1536. rbuf[num + 3] = sat_model_serial_desc_len;
  1537. num += 4;
  1538. memcpy(rbuf + num, "ATA ", 8);
  1539. num += 8;
  1540. ata_id_string(args->id, (unsigned char *) rbuf + num,
  1541. ATA_ID_PROD_OFS, ata_model_byte_len);
  1542. num += ata_model_byte_len;
  1543. ata_id_string(args->id, (unsigned char *) rbuf + num,
  1544. ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
  1545. num += ATA_SERNO_LEN;
  1546. }
  1547. rbuf[3] = num - 4; /* page len (assume less than 256 bytes) */
  1548. return 0;
  1549. }
  1550. /**
  1551. * ata_scsiop_noop - Command handler that simply returns success.
  1552. * @args: device IDENTIFY data / SCSI command of interest.
  1553. * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  1554. * @buflen: Response buffer length.
  1555. *
  1556. * No operation. Simply returns success to caller, to indicate
  1557. * that the caller should successfully complete this SCSI command.
  1558. *
  1559. * LOCKING:
  1560. * spin_lock_irqsave(host lock)
  1561. */
  1562. unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
  1563. unsigned int buflen)
  1564. {
  1565. VPRINTK("ENTER\n");
  1566. return 0;
  1567. }
  1568. /**
  1569. * ata_msense_push - Push data onto MODE SENSE data output buffer
  1570. * @ptr_io: (input/output) Location to store more output data
  1571. * @last: End of output data buffer
  1572. * @buf: Pointer to BLOB being added to output buffer
  1573. * @buflen: Length of BLOB
  1574. *
  1575. * Store MODE SENSE data on an output buffer.
  1576. *
  1577. * LOCKING:
  1578. * None.
  1579. */
  1580. static void ata_msense_push(u8 **ptr_io, const u8 *last,
  1581. const u8 *buf, unsigned int buflen)
  1582. {
  1583. u8 *ptr = *ptr_io;
  1584. if ((ptr + buflen - 1) > last)
  1585. return;
  1586. memcpy(ptr, buf, buflen);
  1587. ptr += buflen;
  1588. *ptr_io = ptr;
  1589. }
  1590. /**
  1591. * ata_msense_caching - Simulate MODE SENSE caching info page
  1592. * @id: device IDENTIFY data
  1593. * @ptr_io: (input/output) Location to store more output data
  1594. * @last: End of output data buffer
  1595. *
  1596. * Generate a caching info page, which conditionally indicates
  1597. * write caching to the SCSI layer, depending on device
  1598. * capabilities.
  1599. *
  1600. * LOCKING:
  1601. * None.
  1602. */
  1603. static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
  1604. const u8 *last)
  1605. {
  1606. u8 page[CACHE_MPAGE_LEN];
  1607. memcpy(page, def_cache_mpage, sizeof(page));
  1608. if (ata_id_wcache_enabled(id))
  1609. page[2] |= (1 << 2); /* write cache enable */
  1610. if (!ata_id_rahead_enabled(id))
  1611. page[12] |= (1 << 5); /* disable read ahead */
  1612. ata_msense_push(ptr_io, last, page, sizeof(page));
  1613. return sizeof(page);
  1614. }
  1615. /**
  1616. * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
  1617. * @dev: Device associated with this MODE SENSE command
  1618. * @ptr_io: (input/output) Location to store more output data
  1619. * @last: End of output data buffer
  1620. *
  1621. * Generate a generic MODE SENSE control mode page.
  1622. *
  1623. * LOCKING:
  1624. * None.
  1625. */
  1626. static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
  1627. {
  1628. ata_msense_push(ptr_io, last, def_control_mpage,
  1629. sizeof(def_control_mpage));
  1630. return sizeof(def_control_mpage);
  1631. }
  1632. /**
  1633. * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
  1634. * @dev: Device associated with this MODE SENSE command
  1635. * @ptr_io: (input/output) Location to store more output data
  1636. * @last: End of output data buffer
  1637. *
  1638. * Generate a generic MODE SENSE r/w error recovery page.
  1639. *
  1640. * LOCKING:
  1641. * None.
  1642. */
  1643. static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
  1644. {
  1645. ata_msense_push(ptr_io, last, def_rw_recovery_mpage,
  1646. sizeof(def_rw_recovery_mpage));
  1647. return sizeof(def_rw_recovery_mpage);
  1648. }
  1649. /*
  1650. * We can turn this into a real blacklist if it's needed, for now just
  1651. * blacklist any Maxtor BANC1G10 revision firmware
  1652. */
  1653. static int ata_dev_supports_fua(u16 *id)
  1654. {
  1655. unsigned char model[41], fw[9];
  1656. if (!libata_fua)
  1657. return 0;
  1658. if (!ata_id_has_fua(id))
  1659. return 0;
  1660. ata_id_c_string(id, model, ATA_ID_PROD_OFS, sizeof(model));
  1661. ata_id_c_string(id, fw, ATA_ID_FW_REV_OFS, sizeof(fw));
  1662. if (strcmp(model, "Maxtor"))
  1663. return 1;
  1664. if (strcmp(fw, "BANC1G10"))
  1665. return 1;
  1666. return 0; /* blacklisted */
  1667. }
  1668. /**
  1669. * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
  1670. * @args: device IDENTIFY data / SCSI command of interest.
  1671. * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  1672. * @buflen: Response buffer length.
  1673. *
  1674. * Simulate MODE SENSE commands. Assume this is invoked for direct
  1675. * access devices (e.g. disks) only. There should be no block
  1676. * descriptor for other device types.
  1677. *
  1678. * LOCKING:
  1679. * spin_lock_irqsave(host lock)
  1680. */
  1681. unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
  1682. unsigned int buflen)
  1683. {
  1684. struct ata_device *dev = args->dev;
  1685. u8 *scsicmd = args->cmd->cmnd, *p, *last;
  1686. const u8 sat_blk_desc[] = {
  1687. 0, 0, 0, 0, /* number of blocks: sat unspecified */
  1688. 0,
  1689. 0, 0x2, 0x0 /* block length: 512 bytes */
  1690. };
  1691. u8 pg, spg;
  1692. unsigned int ebd, page_control, six_byte, output_len, alloc_len, minlen;
  1693. u8 dpofua;
  1694. VPRINTK("ENTER\n");
  1695. six_byte = (scsicmd[0] == MODE_SENSE);
  1696. ebd = !(scsicmd[1] & 0x8); /* dbd bit inverted == edb */
  1697. /*
  1698. * LLBA bit in msense(10) ignored (compliant)
  1699. */
  1700. page_control = scsicmd[2] >> 6;
  1701. switch (page_control) {
  1702. case 0: /* current */
  1703. break; /* supported */
  1704. case 3: /* saved */
  1705. goto saving_not_supp;
  1706. case 1: /* changeable */
  1707. case 2: /* defaults */
  1708. default:
  1709. goto invalid_fld;
  1710. }
  1711. if (six_byte) {
  1712. output_len = 4 + (ebd ? 8 : 0);
  1713. alloc_len = scsicmd[4];
  1714. } else {
  1715. output_len = 8 + (ebd ? 8 : 0);
  1716. alloc_len = (scsicmd[7] << 8) + scsicmd[8];
  1717. }
  1718. minlen = (alloc_len < buflen) ? alloc_len : buflen;
  1719. p = rbuf + output_len;
  1720. last = rbuf + minlen - 1;
  1721. pg = scsicmd[2] & 0x3f;
  1722. spg = scsicmd[3];
  1723. /*
  1724. * No mode subpages supported (yet) but asking for _all_
  1725. * subpages may be valid
  1726. */
  1727. if (spg && (spg != ALL_SUB_MPAGES))
  1728. goto invalid_fld;
  1729. switch(pg) {
  1730. case RW_RECOVERY_MPAGE:
  1731. output_len += ata_msense_rw_recovery(&p, last);
  1732. break;
  1733. case CACHE_MPAGE:
  1734. output_len += ata_msense_caching(args->id, &p, last);
  1735. break;
  1736. case CONTROL_MPAGE: {
  1737. output_len += ata_msense_ctl_mode(&p, last);
  1738. break;
  1739. }
  1740. case ALL_MPAGES:
  1741. output_len += ata_msense_rw_recovery(&p, last);
  1742. output_len += ata_msense_caching(args->id, &p, last);
  1743. output_len += ata_msense_ctl_mode(&p, last);
  1744. break;
  1745. default: /* invalid page code */
  1746. goto invalid_fld;
  1747. }
  1748. if (minlen < 1)
  1749. return 0;
  1750. dpofua = 0;
  1751. if (ata_dev_supports_fua(args->id) && (dev->flags & ATA_DFLAG_LBA48) &&
  1752. (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
  1753. dpofua = 1 << 4;
  1754. if (six_byte) {
  1755. output_len--;
  1756. rbuf[0] = output_len;
  1757. if (minlen > 2)
  1758. rbuf[2] |= dpofua;
  1759. if (ebd) {
  1760. if (minlen > 3)
  1761. rbuf[3] = sizeof(sat_blk_desc);
  1762. if (minlen > 11)
  1763. memcpy(rbuf + 4, sat_blk_desc,
  1764. sizeof(sat_blk_desc));
  1765. }
  1766. } else {
  1767. output_len -= 2;
  1768. rbuf[0] = output_len >> 8;
  1769. if (minlen > 1)
  1770. rbuf[1] = output_len;
  1771. if (minlen > 3)
  1772. rbuf[3] |= dpofua;
  1773. if (ebd) {
  1774. if (minlen > 7)
  1775. rbuf[7] = sizeof(sat_blk_desc);
  1776. if (minlen > 15)
  1777. memcpy(rbuf + 8, sat_blk_desc,
  1778. sizeof(sat_blk_desc));
  1779. }
  1780. }
  1781. return 0;
  1782. invalid_fld:
  1783. ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x24, 0x0);
  1784. /* "Invalid field in cbd" */
  1785. return 1;
  1786. saving_not_supp:
  1787. ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
  1788. /* "Saving parameters not supported" */
  1789. return 1;
  1790. }
  1791. /**
  1792. * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
  1793. * @args: device IDENTIFY data / SCSI command of interest.
  1794. * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  1795. * @buflen: Response buffer length.
  1796. *
  1797. * Simulate READ CAPACITY commands.
  1798. *
  1799. * LOCKING:
  1800. * None.
  1801. */
  1802. unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
  1803. unsigned int buflen)
  1804. {
  1805. u64 last_lba = args->dev->n_sectors - 1; /* LBA of the last block */
  1806. VPRINTK("ENTER\n");
  1807. if (args->cmd->cmnd[0] == READ_CAPACITY) {
  1808. if (last_lba >= 0xffffffffULL)
  1809. last_lba = 0xffffffff;
  1810. /* sector count, 32-bit */
  1811. ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 3));
  1812. ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 2));
  1813. ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 1));
  1814. ATA_SCSI_RBUF_SET(3, last_lba);
  1815. /* sector size */
  1816. ATA_SCSI_RBUF_SET(6, ATA_SECT_SIZE >> 8);
  1817. ATA_SCSI_RBUF_SET(7, ATA_SECT_SIZE);
  1818. } else {
  1819. /* sector count, 64-bit */
  1820. ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 7));
  1821. ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 6));
  1822. ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 5));
  1823. ATA_SCSI_RBUF_SET(3, last_lba >> (8 * 4));
  1824. ATA_SCSI_RBUF_SET(4, last_lba >> (8 * 3));
  1825. ATA_SCSI_RBUF_SET(5, last_lba >> (8 * 2));
  1826. ATA_SCSI_RBUF_SET(6, last_lba >> (8 * 1));
  1827. ATA_SCSI_RBUF_SET(7, last_lba);
  1828. /* sector size */
  1829. ATA_SCSI_RBUF_SET(10, ATA_SECT_SIZE >> 8);
  1830. ATA_SCSI_RBUF_SET(11, ATA_SECT_SIZE);
  1831. }
  1832. return 0;
  1833. }
  1834. /**
  1835. * ata_scsiop_report_luns - Simulate REPORT LUNS command
  1836. * @args: device IDENTIFY data / SCSI command of interest.
  1837. * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  1838. * @buflen: Response buffer length.
  1839. *
  1840. * Simulate REPORT LUNS command.
  1841. *
  1842. * LOCKING:
  1843. * spin_lock_irqsave(host lock)
  1844. */
  1845. unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
  1846. unsigned int buflen)
  1847. {
  1848. VPRINTK("ENTER\n");
  1849. rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
  1850. return 0;
  1851. }
  1852. /**
  1853. * ata_scsi_set_sense - Set SCSI sense data and status
  1854. * @cmd: SCSI request to be handled
  1855. * @sk: SCSI-defined sense key
  1856. * @asc: SCSI-defined additional sense code
  1857. * @ascq: SCSI-defined additional sense code qualifier
  1858. *
  1859. * Helper function that builds a valid fixed format, current
  1860. * response code and the given sense key (sk), additional sense
  1861. * code (asc) and additional sense code qualifier (ascq) with
  1862. * a SCSI command status of %SAM_STAT_CHECK_CONDITION and
  1863. * DRIVER_SENSE set in the upper bits of scsi_cmnd::result .
  1864. *
  1865. * LOCKING:
  1866. * Not required
  1867. */
  1868. void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
  1869. {
  1870. cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
  1871. cmd->sense_buffer[0] = 0x70; /* fixed format, current */
  1872. cmd->sense_buffer[2] = sk;
  1873. cmd->sense_buffer[7] = 18 - 8; /* additional sense length */
  1874. cmd->sense_buffer[12] = asc;
  1875. cmd->sense_buffer[13] = ascq;
  1876. }
  1877. /**
  1878. * ata_scsi_badcmd - End a SCSI request with an error
  1879. * @cmd: SCSI request to be handled
  1880. * @done: SCSI command completion function
  1881. * @asc: SCSI-defined additional sense code
  1882. * @ascq: SCSI-defined additional sense code qualifier
  1883. *
  1884. * Helper function that completes a SCSI command with
  1885. * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
  1886. * and the specified additional sense codes.
  1887. *
  1888. * LOCKING:
  1889. * spin_lock_irqsave(host lock)
  1890. */
  1891. void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
  1892. {
  1893. DPRINTK("ENTER\n");
  1894. ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, asc, ascq);
  1895. done(cmd);
  1896. }
  1897. static void atapi_sense_complete(struct ata_queued_cmd *qc)
  1898. {
  1899. if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) {
  1900. /* FIXME: not quite right; we don't want the
  1901. * translation of taskfile registers into
  1902. * a sense descriptors, since that's only
  1903. * correct for ATA, not ATAPI
  1904. */
  1905. ata_gen_passthru_sense(qc);
  1906. }
  1907. qc->scsidone(qc->scsicmd);
  1908. ata_qc_free(qc);
  1909. }
  1910. /* is it pointless to prefer PIO for "safety reasons"? */
  1911. static inline int ata_pio_use_silly(struct ata_port *ap)
  1912. {
  1913. return (ap->flags & ATA_FLAG_PIO_DMA);
  1914. }
  1915. static void atapi_request_sense(struct ata_queued_cmd *qc)
  1916. {
  1917. struct ata_port *ap = qc->ap;
  1918. struct scsi_cmnd *cmd = qc->scsicmd;
  1919. DPRINTK("ATAPI request sense\n");
  1920. /* FIXME: is this needed? */
  1921. memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
  1922. ap->ops->tf_read(ap, &qc->tf);
  1923. /* fill these in, for the case where they are -not- overwritten */
  1924. cmd->sense_buffer[0] = 0x70;
  1925. cmd->sense_buffer[2] = qc->tf.feature >> 4;
  1926. ata_qc_reinit(qc);
  1927. ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
  1928. qc->dma_dir = DMA_FROM_DEVICE;
  1929. memset(&qc->cdb, 0, qc->dev->cdb_len);
  1930. qc->cdb[0] = REQUEST_SENSE;
  1931. qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
  1932. qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
  1933. qc->tf.command = ATA_CMD_PACKET;
  1934. if (ata_pio_use_silly(ap)) {
  1935. qc->tf.protocol = ATA_PROT_ATAPI_DMA;
  1936. qc->tf.feature |= ATAPI_PKT_DMA;
  1937. } else {
  1938. qc->tf.protocol = ATA_PROT_ATAPI;
  1939. qc->tf.lbam = (8 * 1024) & 0xff;
  1940. qc->tf.lbah = (8 * 1024) >> 8;
  1941. }
  1942. qc->nbytes = SCSI_SENSE_BUFFERSIZE;
  1943. qc->complete_fn = atapi_sense_complete;
  1944. ata_qc_issue(qc);
  1945. DPRINTK("EXIT\n");
  1946. }
  1947. static void atapi_qc_complete(struct ata_queued_cmd *qc)
  1948. {
  1949. struct scsi_cmnd *cmd = qc->scsicmd;
  1950. unsigned int err_mask = qc->err_mask;
  1951. VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
  1952. /* handle completion from new EH */
  1953. if (unlikely(qc->ap->ops->error_handler &&
  1954. (err_mask || qc->flags & ATA_QCFLAG_SENSE_VALID))) {
  1955. if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)) {
  1956. /* FIXME: not quite right; we don't want the
  1957. * translation of taskfile registers into a
  1958. * sense descriptors, since that's only
  1959. * correct for ATA, not ATAPI
  1960. */
  1961. ata_gen_passthru_sense(qc);
  1962. }
  1963. /* SCSI EH automatically locks door if sdev->locked is
  1964. * set. Sometimes door lock request continues to
  1965. * fail, for example, when no media is present. This
  1966. * creates a loop - SCSI EH issues door lock which
  1967. * fails and gets invoked again to acquire sense data
  1968. * for the failed command.
  1969. *
  1970. * If door lock fails, always clear sdev->locked to
  1971. * avoid this infinite loop.
  1972. */
  1973. if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL)
  1974. qc->dev->sdev->locked = 0;
  1975. qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
  1976. qc->scsidone(cmd);
  1977. ata_qc_free(qc);
  1978. return;
  1979. }
  1980. /* successful completion or old EH failure path */
  1981. if (unlikely(err_mask & AC_ERR_DEV)) {
  1982. cmd->result = SAM_STAT_CHECK_CONDITION;
  1983. atapi_request_sense(qc);
  1984. return;
  1985. } else if (unlikely(err_mask)) {
  1986. /* FIXME: not quite right; we don't want the
  1987. * translation of taskfile registers into
  1988. * a sense descriptors, since that's only
  1989. * correct for ATA, not ATAPI
  1990. */
  1991. ata_gen_passthru_sense(qc);
  1992. } else {
  1993. u8 *scsicmd = cmd->cmnd;
  1994. if ((scsicmd[0] == INQUIRY) && ((scsicmd[1] & 0x03) == 0)) {
  1995. u8 *buf = NULL;
  1996. unsigned int buflen;
  1997. buflen = ata_scsi_rbuf_get(cmd, &buf);
  1998. /* ATAPI devices typically report zero for their SCSI version,
  1999. * and sometimes deviate from the spec WRT response data
  2000. * format. If SCSI version is reported as zero like normal,
  2001. * then we make the following fixups: 1) Fake MMC-5 version,
  2002. * to indicate to the Linux scsi midlayer this is a modern
  2003. * device. 2) Ensure response data format / ATAPI information
  2004. * are always correct.
  2005. */
  2006. if (buf[2] == 0) {
  2007. buf[2] = 0x5;
  2008. buf[3] = 0x32;
  2009. }
  2010. ata_scsi_rbuf_put(cmd, buf);
  2011. }
  2012. cmd->result = SAM_STAT_GOOD;
  2013. }
  2014. qc->scsidone(cmd);
  2015. ata_qc_free(qc);
  2016. }
  2017. /**
  2018. * atapi_xlat - Initialize PACKET taskfile
  2019. * @qc: command structure to be initialized
  2020. *
  2021. * LOCKING:
  2022. * spin_lock_irqsave(host lock)
  2023. *
  2024. * RETURNS:
  2025. * Zero on success, non-zero on failure.
  2026. */
  2027. static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
  2028. {
  2029. struct scsi_cmnd *scmd = qc->scsicmd;
  2030. struct ata_device *dev = qc->dev;
  2031. int using_pio = (dev->flags & ATA_DFLAG_PIO);
  2032. int nodata = (scmd->sc_data_direction == DMA_NONE);
  2033. if (!using_pio)
  2034. /* Check whether ATAPI DMA is safe */
  2035. if (ata_check_atapi_dma(qc))
  2036. using_pio = 1;
  2037. memcpy(&qc->cdb, scmd->cmnd, dev->cdb_len);
  2038. qc->complete_fn = atapi_qc_complete;
  2039. qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
  2040. if (scmd->sc_data_direction == DMA_TO_DEVICE) {
  2041. qc->tf.flags |= ATA_TFLAG_WRITE;
  2042. DPRINTK("direction: write\n");
  2043. }
  2044. qc->tf.command = ATA_CMD_PACKET;
  2045. /* no data, or PIO data xfer */
  2046. if (using_pio || nodata) {
  2047. if (nodata)
  2048. qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
  2049. else
  2050. qc->tf.protocol = ATA_PROT_ATAPI;
  2051. qc->tf.lbam = (8 * 1024) & 0xff;
  2052. qc->tf.lbah = (8 * 1024) >> 8;
  2053. }
  2054. /* DMA data xfer */
  2055. else {
  2056. qc->tf.protocol = ATA_PROT_ATAPI_DMA;
  2057. qc->tf.feature |= ATAPI_PKT_DMA;
  2058. if (atapi_dmadir && (scmd->sc_data_direction != DMA_TO_DEVICE))
  2059. /* some SATA bridges need us to indicate data xfer direction */
  2060. qc->tf.feature |= ATAPI_DMADIR;
  2061. }
  2062. qc->nbytes = scmd->request_bufflen;
  2063. return 0;
  2064. }
  2065. static struct ata_device * ata_find_dev(struct ata_port *ap, int id)
  2066. {
  2067. if (likely(id < ATA_MAX_DEVICES))
  2068. return &ap->device[id];
  2069. return NULL;
  2070. }
  2071. static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
  2072. const struct scsi_device *scsidev)
  2073. {
  2074. /* skip commands not addressed to targets we simulate */
  2075. if (unlikely(scsidev->channel || scsidev->lun))
  2076. return NULL;
  2077. return ata_find_dev(ap, scsidev->id);
  2078. }
  2079. /**
  2080. * ata_scsi_dev_enabled - determine if device is enabled
  2081. * @dev: ATA device
  2082. *
  2083. * Determine if commands should be sent to the specified device.
  2084. *
  2085. * LOCKING:
  2086. * spin_lock_irqsave(host lock)
  2087. *
  2088. * RETURNS:
  2089. * 0 if commands are not allowed / 1 if commands are allowed
  2090. */
  2091. static int ata_scsi_dev_enabled(struct ata_device *dev)
  2092. {
  2093. if (unlikely(!ata_dev_enabled(dev)))
  2094. return 0;
  2095. if (!atapi_enabled || (dev->ap->flags & ATA_FLAG_NO_ATAPI)) {
  2096. if (unlikely(dev->class == ATA_DEV_ATAPI)) {
  2097. ata_dev_printk(dev, KERN_WARNING,
  2098. "WARNING: ATAPI is %s, device ignored.\n",
  2099. atapi_enabled ? "not supported with this driver" : "disabled");
  2100. return 0;
  2101. }
  2102. }
  2103. return 1;
  2104. }
  2105. /**
  2106. * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
  2107. * @ap: ATA port to which the device is attached
  2108. * @scsidev: SCSI device from which we derive the ATA device
  2109. *
  2110. * Given various information provided in struct scsi_cmnd,
  2111. * map that onto an ATA bus, and using that mapping
  2112. * determine which ata_device is associated with the
  2113. * SCSI command to be sent.
  2114. *
  2115. * LOCKING:
  2116. * spin_lock_irqsave(host lock)
  2117. *
  2118. * RETURNS:
  2119. * Associated ATA device, or %NULL if not found.
  2120. */
  2121. static struct ata_device *
  2122. ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
  2123. {
  2124. struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
  2125. if (unlikely(!dev || !ata_scsi_dev_enabled(dev)))
  2126. return NULL;
  2127. return dev;
  2128. }
  2129. /*
  2130. * ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
  2131. * @byte1: Byte 1 from pass-thru CDB.
  2132. *
  2133. * RETURNS:
  2134. * ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
  2135. */
  2136. static u8
  2137. ata_scsi_map_proto(u8 byte1)
  2138. {
  2139. switch((byte1 & 0x1e) >> 1) {
  2140. case 3: /* Non-data */
  2141. return ATA_PROT_NODATA;
  2142. case 6: /* DMA */
  2143. return ATA_PROT_DMA;
  2144. case 4: /* PIO Data-in */
  2145. case 5: /* PIO Data-out */
  2146. return ATA_PROT_PIO;
  2147. case 10: /* Device Reset */
  2148. case 0: /* Hard Reset */
  2149. case 1: /* SRST */
  2150. case 2: /* Bus Idle */
  2151. case 7: /* Packet */
  2152. case 8: /* DMA Queued */
  2153. case 9: /* Device Diagnostic */
  2154. case 11: /* UDMA Data-in */
  2155. case 12: /* UDMA Data-Out */
  2156. case 13: /* FPDMA */
  2157. default: /* Reserved */
  2158. break;
  2159. }
  2160. return ATA_PROT_UNKNOWN;
  2161. }
  2162. /**
  2163. * ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
  2164. * @qc: command structure to be initialized
  2165. *
  2166. * Handles either 12 or 16-byte versions of the CDB.
  2167. *
  2168. * RETURNS:
  2169. * Zero on success, non-zero on failure.
  2170. */
  2171. static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
  2172. {
  2173. struct ata_taskfile *tf = &(qc->tf);
  2174. struct scsi_cmnd *scmd = qc->scsicmd;
  2175. struct ata_device *dev = qc->dev;
  2176. const u8 *cdb = scmd->cmnd;
  2177. if ((tf->protocol = ata_scsi_map_proto(cdb[1])) == ATA_PROT_UNKNOWN)
  2178. goto invalid_fld;
  2179. /* We may not issue DMA commands if no DMA mode is set */
  2180. if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
  2181. goto invalid_fld;
  2182. if (cdb[1] & 0xe0)
  2183. /* PIO multi not supported yet */
  2184. goto invalid_fld;
  2185. /*
  2186. * 12 and 16 byte CDBs use different offsets to
  2187. * provide the various register values.
  2188. */
  2189. if (cdb[0] == ATA_16) {
  2190. /*
  2191. * 16-byte CDB - may contain extended commands.
  2192. *
  2193. * If that is the case, copy the upper byte register values.
  2194. */
  2195. if (cdb[1] & 0x01) {
  2196. tf->hob_feature = cdb[3];
  2197. tf->hob_nsect = cdb[5];
  2198. tf->hob_lbal = cdb[7];
  2199. tf->hob_lbam = cdb[9];
  2200. tf->hob_lbah = cdb[11];
  2201. tf->flags |= ATA_TFLAG_LBA48;
  2202. } else
  2203. tf->flags &= ~ATA_TFLAG_LBA48;
  2204. /*
  2205. * Always copy low byte, device and command registers.
  2206. */
  2207. tf->feature = cdb[4];
  2208. tf->nsect = cdb[6];
  2209. tf->lbal = cdb[8];
  2210. tf->lbam = cdb[10];
  2211. tf->lbah = cdb[12];
  2212. tf->device = cdb[13];
  2213. tf->command = cdb[14];
  2214. } else {
  2215. /*
  2216. * 12-byte CDB - incapable of extended commands.
  2217. */
  2218. tf->flags &= ~ATA_TFLAG_LBA48;
  2219. tf->feature = cdb[3];
  2220. tf->nsect = cdb[4];
  2221. tf->lbal = cdb[5];
  2222. tf->lbam = cdb[6];
  2223. tf->lbah = cdb[7];
  2224. tf->device = cdb[8];
  2225. tf->command = cdb[9];
  2226. }
  2227. /*
  2228. * If slave is possible, enforce correct master/slave bit
  2229. */
  2230. if (qc->ap->flags & ATA_FLAG_SLAVE_POSS)
  2231. tf->device = qc->dev->devno ?
  2232. tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
  2233. /*
  2234. * Filter SET_FEATURES - XFER MODE command -- otherwise,
  2235. * SET_FEATURES - XFER MODE must be preceded/succeeded
  2236. * by an update to hardware-specific registers for each
  2237. * controller (i.e. the reason for ->set_piomode(),
  2238. * ->set_dmamode(), and ->post_set_mode() hooks).
  2239. */
  2240. if ((tf->command == ATA_CMD_SET_FEATURES)
  2241. && (tf->feature == SETFEATURES_XFER))
  2242. goto invalid_fld;
  2243. /*
  2244. * Set flags so that all registers will be written,
  2245. * and pass on write indication (used for PIO/DMA
  2246. * setup.)
  2247. */
  2248. tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
  2249. if (scmd->sc_data_direction == DMA_TO_DEVICE)
  2250. tf->flags |= ATA_TFLAG_WRITE;
  2251. /*
  2252. * Set transfer length.
  2253. *
  2254. * TODO: find out if we need to do more here to
  2255. * cover scatter/gather case.
  2256. */
  2257. qc->nsect = scmd->request_bufflen / ATA_SECT_SIZE;
  2258. /* request result TF */
  2259. qc->flags |= ATA_QCFLAG_RESULT_TF;
  2260. return 0;
  2261. invalid_fld:
  2262. ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x00);
  2263. /* "Invalid field in cdb" */
  2264. return 1;
  2265. }
  2266. /**
  2267. * ata_get_xlat_func - check if SCSI to ATA translation is possible
  2268. * @dev: ATA device
  2269. * @cmd: SCSI command opcode to consider
  2270. *
  2271. * Look up the SCSI command given, and determine whether the
  2272. * SCSI command is to be translated or simulated.
  2273. *
  2274. * RETURNS:
  2275. * Pointer to translation function if possible, %NULL if not.
  2276. */
  2277. static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
  2278. {
  2279. switch (cmd) {
  2280. case READ_6:
  2281. case READ_10:
  2282. case READ_16:
  2283. case WRITE_6:
  2284. case WRITE_10:
  2285. case WRITE_16:
  2286. return ata_scsi_rw_xlat;
  2287. case SYNCHRONIZE_CACHE:
  2288. if (ata_try_flush_cache(dev))
  2289. return ata_scsi_flush_xlat;
  2290. break;
  2291. case VERIFY:
  2292. case VERIFY_16:
  2293. return ata_scsi_verify_xlat;
  2294. case ATA_12:
  2295. case ATA_16:
  2296. return ata_scsi_pass_thru;
  2297. case START_STOP:
  2298. return ata_scsi_start_stop_xlat;
  2299. }
  2300. return NULL;
  2301. }
  2302. /**
  2303. * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
  2304. * @ap: ATA port to which the command was being sent
  2305. * @cmd: SCSI command to dump
  2306. *
  2307. * Prints the contents of a SCSI command via printk().
  2308. */
  2309. static inline void ata_scsi_dump_cdb(struct ata_port *ap,
  2310. struct scsi_cmnd *cmd)
  2311. {
  2312. #ifdef ATA_DEBUG
  2313. struct scsi_device *scsidev = cmd->device;
  2314. u8 *scsicmd = cmd->cmnd;
  2315. DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
  2316. ap->id,
  2317. scsidev->channel, scsidev->id, scsidev->lun,
  2318. scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
  2319. scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
  2320. scsicmd[8]);
  2321. #endif
  2322. }
  2323. static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
  2324. void (*done)(struct scsi_cmnd *),
  2325. struct ata_device *dev)
  2326. {
  2327. int rc = 0;
  2328. if (dev->class == ATA_DEV_ATA) {
  2329. ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
  2330. scmd->cmnd[0]);
  2331. if (xlat_func)
  2332. rc = ata_scsi_translate(dev, scmd, done, xlat_func);
  2333. else
  2334. ata_scsi_simulate(dev, scmd, done);
  2335. } else
  2336. rc = ata_scsi_translate(dev, scmd, done, atapi_xlat);
  2337. return rc;
  2338. }
  2339. /**
  2340. * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
  2341. * @cmd: SCSI command to be sent
  2342. * @done: Completion function, called when command is complete
  2343. *
  2344. * In some cases, this function translates SCSI commands into
  2345. * ATA taskfiles, and queues the taskfiles to be sent to
  2346. * hardware. In other cases, this function simulates a
  2347. * SCSI device by evaluating and responding to certain
  2348. * SCSI commands. This creates the overall effect of
  2349. * ATA and ATAPI devices appearing as SCSI devices.
  2350. *
  2351. * LOCKING:
  2352. * Releases scsi-layer-held lock, and obtains host lock.
  2353. *
  2354. * RETURNS:
  2355. * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
  2356. * 0 otherwise.
  2357. */
  2358. int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
  2359. {
  2360. struct ata_port *ap;
  2361. struct ata_device *dev;
  2362. struct scsi_device *scsidev = cmd->device;
  2363. struct Scsi_Host *shost = scsidev->host;
  2364. int rc = 0;
  2365. ap = ata_shost_to_port(shost);
  2366. spin_unlock(shost->host_lock);
  2367. spin_lock(ap->lock);
  2368. ata_scsi_dump_cdb(ap, cmd);
  2369. dev = ata_scsi_find_dev(ap, scsidev);
  2370. if (likely(dev))
  2371. rc = __ata_scsi_queuecmd(cmd, done, dev);
  2372. else {
  2373. cmd->result = (DID_BAD_TARGET << 16);
  2374. done(cmd);
  2375. }
  2376. spin_unlock(ap->lock);
  2377. spin_lock(shost->host_lock);
  2378. return rc;
  2379. }
  2380. /**
  2381. * ata_scsi_simulate - simulate SCSI command on ATA device
  2382. * @dev: the target device
  2383. * @cmd: SCSI command being sent to device.
  2384. * @done: SCSI command completion function.
  2385. *
  2386. * Interprets and directly executes a select list of SCSI commands
  2387. * that can be handled internally.
  2388. *
  2389. * LOCKING:
  2390. * spin_lock_irqsave(host lock)
  2391. */
  2392. void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
  2393. void (*done)(struct scsi_cmnd *))
  2394. {
  2395. struct ata_scsi_args args;
  2396. const u8 *scsicmd = cmd->cmnd;
  2397. args.dev = dev;
  2398. args.id = dev->id;
  2399. args.cmd = cmd;
  2400. args.done = done;
  2401. switch(scsicmd[0]) {
  2402. /* no-op's, complete with success */
  2403. case SYNCHRONIZE_CACHE:
  2404. case REZERO_UNIT:
  2405. case SEEK_6:
  2406. case SEEK_10:
  2407. case TEST_UNIT_READY:
  2408. case FORMAT_UNIT: /* FIXME: correct? */
  2409. case SEND_DIAGNOSTIC: /* FIXME: correct? */
  2410. ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
  2411. break;
  2412. case INQUIRY:
  2413. if (scsicmd[1] & 2) /* is CmdDt set? */
  2414. ata_scsi_invalid_field(cmd, done);
  2415. else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
  2416. ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
  2417. else if (scsicmd[2] == 0x00)
  2418. ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
  2419. else if (scsicmd[2] == 0x80)
  2420. ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
  2421. else if (scsicmd[2] == 0x83)
  2422. ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
  2423. else
  2424. ata_scsi_invalid_field(cmd, done);
  2425. break;
  2426. case MODE_SENSE:
  2427. case MODE_SENSE_10:
  2428. ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
  2429. break;
  2430. case MODE_SELECT: /* unconditionally return */
  2431. case MODE_SELECT_10: /* bad-field-in-cdb */
  2432. ata_scsi_invalid_field(cmd, done);
  2433. break;
  2434. case READ_CAPACITY:
  2435. ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
  2436. break;
  2437. case SERVICE_ACTION_IN:
  2438. if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
  2439. ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
  2440. else
  2441. ata_scsi_invalid_field(cmd, done);
  2442. break;
  2443. case REPORT_LUNS:
  2444. ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
  2445. break;
  2446. /* mandatory commands we haven't implemented yet */
  2447. case REQUEST_SENSE:
  2448. /* all other commands */
  2449. default:
  2450. ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
  2451. /* "Invalid command operation code" */
  2452. done(cmd);
  2453. break;
  2454. }
  2455. }
  2456. void ata_scsi_scan_host(struct ata_port *ap)
  2457. {
  2458. unsigned int i;
  2459. if (ap->flags & ATA_FLAG_DISABLED)
  2460. return;
  2461. for (i = 0; i < ATA_MAX_DEVICES; i++) {
  2462. struct ata_device *dev = &ap->device[i];
  2463. struct scsi_device *sdev;
  2464. if (!ata_dev_enabled(dev) || dev->sdev)
  2465. continue;
  2466. sdev = __scsi_add_device(ap->scsi_host, 0, i, 0, NULL);
  2467. if (!IS_ERR(sdev)) {
  2468. dev->sdev = sdev;
  2469. scsi_device_put(sdev);
  2470. }
  2471. }
  2472. }
  2473. /**
  2474. * ata_scsi_offline_dev - offline attached SCSI device
  2475. * @dev: ATA device to offline attached SCSI device for
  2476. *
  2477. * This function is called from ata_eh_hotplug() and responsible
  2478. * for taking the SCSI device attached to @dev offline. This
  2479. * function is called with host lock which protects dev->sdev
  2480. * against clearing.
  2481. *
  2482. * LOCKING:
  2483. * spin_lock_irqsave(host lock)
  2484. *
  2485. * RETURNS:
  2486. * 1 if attached SCSI device exists, 0 otherwise.
  2487. */
  2488. int ata_scsi_offline_dev(struct ata_device *dev)
  2489. {
  2490. if (dev->sdev) {
  2491. scsi_device_set_state(dev->sdev, SDEV_OFFLINE);
  2492. return 1;
  2493. }
  2494. return 0;
  2495. }
  2496. /**
  2497. * ata_scsi_remove_dev - remove attached SCSI device
  2498. * @dev: ATA device to remove attached SCSI device for
  2499. *
  2500. * This function is called from ata_eh_scsi_hotplug() and
  2501. * responsible for removing the SCSI device attached to @dev.
  2502. *
  2503. * LOCKING:
  2504. * Kernel thread context (may sleep).
  2505. */
  2506. static void ata_scsi_remove_dev(struct ata_device *dev)
  2507. {
  2508. struct ata_port *ap = dev->ap;
  2509. struct scsi_device *sdev;
  2510. unsigned long flags;
  2511. /* Alas, we need to grab scan_mutex to ensure SCSI device
  2512. * state doesn't change underneath us and thus
  2513. * scsi_device_get() always succeeds. The mutex locking can
  2514. * be removed if there is __scsi_device_get() interface which
  2515. * increments reference counts regardless of device state.
  2516. */
  2517. mutex_lock(&ap->scsi_host->scan_mutex);
  2518. spin_lock_irqsave(ap->lock, flags);
  2519. /* clearing dev->sdev is protected by host lock */
  2520. sdev = dev->sdev;
  2521. dev->sdev = NULL;
  2522. if (sdev) {
  2523. /* If user initiated unplug races with us, sdev can go
  2524. * away underneath us after the host lock and
  2525. * scan_mutex are released. Hold onto it.
  2526. */
  2527. if (scsi_device_get(sdev) == 0) {
  2528. /* The following ensures the attached sdev is
  2529. * offline on return from ata_scsi_offline_dev()
  2530. * regardless it wins or loses the race
  2531. * against this function.
  2532. */
  2533. scsi_device_set_state(sdev, SDEV_OFFLINE);
  2534. } else {
  2535. WARN_ON(1);
  2536. sdev = NULL;
  2537. }
  2538. }
  2539. spin_unlock_irqrestore(ap->lock, flags);
  2540. mutex_unlock(&ap->scsi_host->scan_mutex);
  2541. if (sdev) {
  2542. ata_dev_printk(dev, KERN_INFO, "detaching (SCSI %s)\n",
  2543. sdev->sdev_gendev.bus_id);
  2544. scsi_remove_device(sdev);
  2545. scsi_device_put(sdev);
  2546. }
  2547. }
  2548. /**
  2549. * ata_scsi_hotplug - SCSI part of hotplug
  2550. * @work: Pointer to ATA port to perform SCSI hotplug on
  2551. *
  2552. * Perform SCSI part of hotplug. It's executed from a separate
  2553. * workqueue after EH completes. This is necessary because SCSI
  2554. * hot plugging requires working EH and hot unplugging is
  2555. * synchronized with hot plugging with a mutex.
  2556. *
  2557. * LOCKING:
  2558. * Kernel thread context (may sleep).
  2559. */
  2560. void ata_scsi_hotplug(struct work_struct *work)
  2561. {
  2562. struct ata_port *ap =
  2563. container_of(work, struct ata_port, hotplug_task.work);
  2564. int i;
  2565. if (ap->pflags & ATA_PFLAG_UNLOADING) {
  2566. DPRINTK("ENTER/EXIT - unloading\n");
  2567. return;
  2568. }
  2569. DPRINTK("ENTER\n");
  2570. /* unplug detached devices */
  2571. for (i = 0; i < ATA_MAX_DEVICES; i++) {
  2572. struct ata_device *dev = &ap->device[i];
  2573. unsigned long flags;
  2574. if (!(dev->flags & ATA_DFLAG_DETACHED))
  2575. continue;
  2576. spin_lock_irqsave(ap->lock, flags);
  2577. dev->flags &= ~ATA_DFLAG_DETACHED;
  2578. spin_unlock_irqrestore(ap->lock, flags);
  2579. ata_scsi_remove_dev(dev);
  2580. }
  2581. /* scan for new ones */
  2582. ata_scsi_scan_host(ap);
  2583. /* If we scanned while EH was in progress, scan would have
  2584. * failed silently. Requeue if there are enabled but
  2585. * unattached devices.
  2586. */
  2587. for (i = 0; i < ATA_MAX_DEVICES; i++) {
  2588. struct ata_device *dev = &ap->device[i];
  2589. if (ata_dev_enabled(dev) && !dev->sdev) {
  2590. queue_delayed_work(ata_aux_wq, &ap->hotplug_task, HZ);
  2591. break;
  2592. }
  2593. }
  2594. DPRINTK("EXIT\n");
  2595. }
  2596. /**
  2597. * ata_scsi_user_scan - indication for user-initiated bus scan
  2598. * @shost: SCSI host to scan
  2599. * @channel: Channel to scan
  2600. * @id: ID to scan
  2601. * @lun: LUN to scan
  2602. *
  2603. * This function is called when user explicitly requests bus
  2604. * scan. Set probe pending flag and invoke EH.
  2605. *
  2606. * LOCKING:
  2607. * SCSI layer (we don't care)
  2608. *
  2609. * RETURNS:
  2610. * Zero.
  2611. */
  2612. static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
  2613. unsigned int id, unsigned int lun)
  2614. {
  2615. struct ata_port *ap = ata_shost_to_port(shost);
  2616. unsigned long flags;
  2617. int rc = 0;
  2618. if (!ap->ops->error_handler)
  2619. return -EOPNOTSUPP;
  2620. if ((channel != SCAN_WILD_CARD && channel != 0) ||
  2621. (lun != SCAN_WILD_CARD && lun != 0))
  2622. return -EINVAL;
  2623. spin_lock_irqsave(ap->lock, flags);
  2624. if (id == SCAN_WILD_CARD) {
  2625. ap->eh_info.probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
  2626. ap->eh_info.action |= ATA_EH_SOFTRESET;
  2627. } else {
  2628. struct ata_device *dev = ata_find_dev(ap, id);
  2629. if (dev) {
  2630. ap->eh_info.probe_mask |= 1 << dev->devno;
  2631. ap->eh_info.action |= ATA_EH_SOFTRESET;
  2632. ap->eh_info.flags |= ATA_EHI_RESUME_LINK;
  2633. } else
  2634. rc = -EINVAL;
  2635. }
  2636. if (rc == 0) {
  2637. ata_port_schedule_eh(ap);
  2638. spin_unlock_irqrestore(ap->lock, flags);
  2639. ata_port_wait_eh(ap);
  2640. } else
  2641. spin_unlock_irqrestore(ap->lock, flags);
  2642. return rc;
  2643. }
  2644. /**
  2645. * ata_scsi_dev_rescan - initiate scsi_rescan_device()
  2646. * @work: Pointer to ATA port to perform scsi_rescan_device()
  2647. *
  2648. * After ATA pass thru (SAT) commands are executed successfully,
  2649. * libata need to propagate the changes to SCSI layer. This
  2650. * function must be executed from ata_aux_wq such that sdev
  2651. * attach/detach don't race with rescan.
  2652. *
  2653. * LOCKING:
  2654. * Kernel thread context (may sleep).
  2655. */
  2656. void ata_scsi_dev_rescan(struct work_struct *work)
  2657. {
  2658. struct ata_port *ap =
  2659. container_of(work, struct ata_port, scsi_rescan_task);
  2660. unsigned long flags;
  2661. unsigned int i;
  2662. spin_lock_irqsave(ap->lock, flags);
  2663. for (i = 0; i < ATA_MAX_DEVICES; i++) {
  2664. struct ata_device *dev = &ap->device[i];
  2665. struct scsi_device *sdev = dev->sdev;
  2666. if (!ata_dev_enabled(dev) || !sdev)
  2667. continue;
  2668. if (scsi_device_get(sdev))
  2669. continue;
  2670. spin_unlock_irqrestore(ap->lock, flags);
  2671. scsi_rescan_device(&(sdev->sdev_gendev));
  2672. scsi_device_put(sdev);
  2673. spin_lock_irqsave(ap->lock, flags);
  2674. }
  2675. spin_unlock_irqrestore(ap->lock, flags);
  2676. }
  2677. /**
  2678. * ata_sas_port_alloc - Allocate port for a SAS attached SATA device
  2679. * @host: ATA host container for all SAS ports
  2680. * @port_info: Information from low-level host driver
  2681. * @shost: SCSI host that the scsi device is attached to
  2682. *
  2683. * LOCKING:
  2684. * PCI/etc. bus probe sem.
  2685. *
  2686. * RETURNS:
  2687. * ata_port pointer on success / NULL on failure.
  2688. */
  2689. struct ata_port *ata_sas_port_alloc(struct ata_host *host,
  2690. struct ata_port_info *port_info,
  2691. struct Scsi_Host *shost)
  2692. {
  2693. struct ata_port *ap = kzalloc(sizeof(*ap), GFP_KERNEL);
  2694. struct ata_probe_ent *ent;
  2695. if (!ap)
  2696. return NULL;
  2697. ent = ata_probe_ent_alloc(host->dev, port_info);
  2698. if (!ent) {
  2699. kfree(ap);
  2700. return NULL;
  2701. }
  2702. ata_port_init(ap, host, ent, 0);
  2703. ap->lock = shost->host_lock;
  2704. kfree(ent);
  2705. return ap;
  2706. }
  2707. EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
  2708. /**
  2709. * ata_sas_port_start - Set port up for dma.
  2710. * @ap: Port to initialize
  2711. *
  2712. * Called just after data structures for each port are
  2713. * initialized. Allocates DMA pad.
  2714. *
  2715. * May be used as the port_start() entry in ata_port_operations.
  2716. *
  2717. * LOCKING:
  2718. * Inherited from caller.
  2719. */
  2720. int ata_sas_port_start(struct ata_port *ap)
  2721. {
  2722. return ata_pad_alloc(ap, ap->dev);
  2723. }
  2724. EXPORT_SYMBOL_GPL(ata_sas_port_start);
  2725. /**
  2726. * ata_port_stop - Undo ata_sas_port_start()
  2727. * @ap: Port to shut down
  2728. *
  2729. * Frees the DMA pad.
  2730. *
  2731. * May be used as the port_stop() entry in ata_port_operations.
  2732. *
  2733. * LOCKING:
  2734. * Inherited from caller.
  2735. */
  2736. void ata_sas_port_stop(struct ata_port *ap)
  2737. {
  2738. ata_pad_free(ap, ap->dev);
  2739. }
  2740. EXPORT_SYMBOL_GPL(ata_sas_port_stop);
  2741. /**
  2742. * ata_sas_port_init - Initialize a SATA device
  2743. * @ap: SATA port to initialize
  2744. *
  2745. * LOCKING:
  2746. * PCI/etc. bus probe sem.
  2747. *
  2748. * RETURNS:
  2749. * Zero on success, non-zero on error.
  2750. */
  2751. int ata_sas_port_init(struct ata_port *ap)
  2752. {
  2753. int rc = ap->ops->port_start(ap);
  2754. if (!rc)
  2755. rc = ata_bus_probe(ap);
  2756. return rc;
  2757. }
  2758. EXPORT_SYMBOL_GPL(ata_sas_port_init);
  2759. /**
  2760. * ata_sas_port_destroy - Destroy a SATA port allocated by ata_sas_port_alloc
  2761. * @ap: SATA port to destroy
  2762. *
  2763. */
  2764. void ata_sas_port_destroy(struct ata_port *ap)
  2765. {
  2766. ap->ops->port_stop(ap);
  2767. kfree(ap);
  2768. }
  2769. EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
  2770. /**
  2771. * ata_sas_slave_configure - Default slave_config routine for libata devices
  2772. * @sdev: SCSI device to configure
  2773. * @ap: ATA port to which SCSI device is attached
  2774. *
  2775. * RETURNS:
  2776. * Zero.
  2777. */
  2778. int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
  2779. {
  2780. ata_scsi_sdev_config(sdev);
  2781. ata_scsi_dev_config(sdev, ap->device);
  2782. return 0;
  2783. }
  2784. EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
  2785. /**
  2786. * ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
  2787. * @cmd: SCSI command to be sent
  2788. * @done: Completion function, called when command is complete
  2789. * @ap: ATA port to which the command is being sent
  2790. *
  2791. * RETURNS:
  2792. * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
  2793. * 0 otherwise.
  2794. */
  2795. int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
  2796. struct ata_port *ap)
  2797. {
  2798. int rc = 0;
  2799. ata_scsi_dump_cdb(ap, cmd);
  2800. if (likely(ata_scsi_dev_enabled(ap->device)))
  2801. rc = __ata_scsi_queuecmd(cmd, done, ap->device);
  2802. else {
  2803. cmd->result = (DID_BAD_TARGET << 16);
  2804. done(cmd);
  2805. }
  2806. return rc;
  2807. }
  2808. EXPORT_SYMBOL_GPL(ata_sas_queuecmd);