libata.h 38 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216
  1. /*
  2. * Copyright 2003-2005 Red Hat, Inc. All rights reserved.
  3. * Copyright 2003-2005 Jeff Garzik
  4. *
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2, or (at your option)
  9. * any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; see the file COPYING. If not, write to
  18. * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19. *
  20. *
  21. * libata documentation is available via 'make {ps|pdf}docs',
  22. * as Documentation/DocBook/libata.*
  23. *
  24. */
  25. #ifndef __LINUX_LIBATA_H__
  26. #define __LINUX_LIBATA_H__
  27. #include <linux/delay.h>
  28. #include <linux/interrupt.h>
  29. #include <linux/pci.h>
  30. #include <linux/dma-mapping.h>
  31. #include <asm/scatterlist.h>
  32. #include <linux/io.h>
  33. #include <linux/ata.h>
  34. #include <linux/workqueue.h>
  35. #include <scsi/scsi_host.h>
  36. #include <linux/acpi.h>
  37. /*
  38. * Define if arch has non-standard setup. This is a _PCI_ standard
  39. * not a legacy or ISA standard.
  40. */
  41. #ifdef CONFIG_ATA_NONSTANDARD
  42. #include <asm/libata-portmap.h>
  43. #else
  44. #include <asm-generic/libata-portmap.h>
  45. #endif
  46. /*
  47. * compile-time options: to be removed as soon as all the drivers are
  48. * converted to the new debugging mechanism
  49. */
  50. #undef ATA_DEBUG /* debugging output */
  51. #undef ATA_VERBOSE_DEBUG /* yet more debugging output */
  52. #undef ATA_IRQ_TRAP /* define to ack screaming irqs */
  53. #undef ATA_NDEBUG /* define to disable quick runtime checks */
  54. /* note: prints function name for you */
  55. #ifdef ATA_DEBUG
  56. #define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  57. #ifdef ATA_VERBOSE_DEBUG
  58. #define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  59. #else
  60. #define VPRINTK(fmt, args...)
  61. #endif /* ATA_VERBOSE_DEBUG */
  62. #else
  63. #define DPRINTK(fmt, args...)
  64. #define VPRINTK(fmt, args...)
  65. #endif /* ATA_DEBUG */
  66. #define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  67. /* NEW: debug levels */
  68. #define HAVE_LIBATA_MSG 1
  69. enum {
  70. ATA_MSG_DRV = 0x0001,
  71. ATA_MSG_INFO = 0x0002,
  72. ATA_MSG_PROBE = 0x0004,
  73. ATA_MSG_WARN = 0x0008,
  74. ATA_MSG_MALLOC = 0x0010,
  75. ATA_MSG_CTL = 0x0020,
  76. ATA_MSG_INTR = 0x0040,
  77. ATA_MSG_ERR = 0x0080,
  78. };
  79. #define ata_msg_drv(p) ((p)->msg_enable & ATA_MSG_DRV)
  80. #define ata_msg_info(p) ((p)->msg_enable & ATA_MSG_INFO)
  81. #define ata_msg_probe(p) ((p)->msg_enable & ATA_MSG_PROBE)
  82. #define ata_msg_warn(p) ((p)->msg_enable & ATA_MSG_WARN)
  83. #define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC)
  84. #define ata_msg_ctl(p) ((p)->msg_enable & ATA_MSG_CTL)
  85. #define ata_msg_intr(p) ((p)->msg_enable & ATA_MSG_INTR)
  86. #define ata_msg_err(p) ((p)->msg_enable & ATA_MSG_ERR)
  87. static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
  88. {
  89. if (dval < 0 || dval >= (sizeof(u32) * 8))
  90. return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */
  91. if (!dval)
  92. return 0;
  93. return (1 << dval) - 1;
  94. }
  95. /* defines only for the constants which don't work well as enums */
  96. #define ATA_TAG_POISON 0xfafbfcfdU
  97. /* move to PCI layer? */
  98. static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
  99. {
  100. return &pdev->dev;
  101. }
  102. enum {
  103. /* various global constants */
  104. LIBATA_MAX_PRD = ATA_MAX_PRD / 2,
  105. ATA_MAX_PORTS = 8,
  106. ATA_DEF_QUEUE = 1,
  107. /* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
  108. ATA_MAX_QUEUE = 32,
  109. ATA_TAG_INTERNAL = ATA_MAX_QUEUE - 1,
  110. ATA_MAX_BUS = 2,
  111. ATA_DEF_BUSY_WAIT = 10000,
  112. ATA_SHORT_PAUSE = (HZ >> 6) + 1,
  113. ATA_SHT_EMULATED = 1,
  114. ATA_SHT_CMD_PER_LUN = 1,
  115. ATA_SHT_THIS_ID = -1,
  116. ATA_SHT_USE_CLUSTERING = 1,
  117. /* struct ata_device stuff */
  118. ATA_DFLAG_LBA = (1 << 0), /* device supports LBA */
  119. ATA_DFLAG_LBA48 = (1 << 1), /* device supports LBA48 */
  120. ATA_DFLAG_CDB_INTR = (1 << 2), /* device asserts INTRQ when ready for CDB */
  121. ATA_DFLAG_NCQ = (1 << 3), /* device supports NCQ */
  122. ATA_DFLAG_FLUSH_EXT = (1 << 4), /* do FLUSH_EXT instead of FLUSH */
  123. ATA_DFLAG_CFG_MASK = (1 << 8) - 1,
  124. ATA_DFLAG_PIO = (1 << 8), /* device limited to PIO mode */
  125. ATA_DFLAG_NCQ_OFF = (1 << 9), /* device limited to non-NCQ mode */
  126. ATA_DFLAG_SUSPENDED = (1 << 10), /* device suspended */
  127. ATA_DFLAG_INIT_MASK = (1 << 16) - 1,
  128. ATA_DFLAG_DETACH = (1 << 16),
  129. ATA_DFLAG_DETACHED = (1 << 17),
  130. ATA_DEV_UNKNOWN = 0, /* unknown device */
  131. ATA_DEV_ATA = 1, /* ATA device */
  132. ATA_DEV_ATA_UNSUP = 2, /* ATA device (unsupported) */
  133. ATA_DEV_ATAPI = 3, /* ATAPI device */
  134. ATA_DEV_ATAPI_UNSUP = 4, /* ATAPI device (unsupported) */
  135. ATA_DEV_NONE = 5, /* no device */
  136. /* struct ata_port flags */
  137. ATA_FLAG_SLAVE_POSS = (1 << 0), /* host supports slave dev */
  138. /* (doesn't imply presence) */
  139. ATA_FLAG_SATA = (1 << 1),
  140. ATA_FLAG_NO_LEGACY = (1 << 2), /* no legacy mode check */
  141. ATA_FLAG_MMIO = (1 << 3), /* use MMIO, not PIO */
  142. ATA_FLAG_SRST = (1 << 4), /* (obsolete) use ATA SRST, not E.D.D. */
  143. ATA_FLAG_SATA_RESET = (1 << 5), /* (obsolete) use COMRESET */
  144. ATA_FLAG_NO_ATAPI = (1 << 6), /* No ATAPI support */
  145. ATA_FLAG_PIO_DMA = (1 << 7), /* PIO cmds via DMA */
  146. ATA_FLAG_PIO_LBA48 = (1 << 8), /* Host DMA engine is LBA28 only */
  147. ATA_FLAG_PIO_POLLING = (1 << 9), /* use polling PIO if LLD
  148. * doesn't handle PIO interrupts */
  149. ATA_FLAG_NCQ = (1 << 10), /* host supports NCQ */
  150. ATA_FLAG_HRST_TO_RESUME = (1 << 11), /* hardreset to resume phy */
  151. ATA_FLAG_SKIP_D2H_BSY = (1 << 12), /* can't wait for the first D2H
  152. * Register FIS clearing BSY */
  153. ATA_FLAG_DEBUGMSG = (1 << 13),
  154. ATA_FLAG_SETXFER_POLLING= (1 << 14), /* use polling for SETXFER */
  155. ATA_FLAG_IGN_SIMPLEX = (1 << 15), /* ignore SIMPLEX */
  156. ATA_FLAG_NO_IORDY = (1 << 16), /* controller lacks iordy */
  157. /* The following flag belongs to ap->pflags but is kept in
  158. * ap->flags because it's referenced in many LLDs and will be
  159. * removed in not-too-distant future.
  160. */
  161. ATA_FLAG_DISABLED = (1 << 23), /* port is disabled, ignore it */
  162. /* bits 24:31 of ap->flags are reserved for LLD specific flags */
  163. /* struct ata_port pflags */
  164. ATA_PFLAG_EH_PENDING = (1 << 0), /* EH pending */
  165. ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
  166. ATA_PFLAG_FROZEN = (1 << 2), /* port is frozen */
  167. ATA_PFLAG_RECOVERED = (1 << 3), /* recovery action performed */
  168. ATA_PFLAG_LOADING = (1 << 4), /* boot/loading probe */
  169. ATA_PFLAG_UNLOADING = (1 << 5), /* module is unloading */
  170. ATA_PFLAG_SCSI_HOTPLUG = (1 << 6), /* SCSI hotplug scheduled */
  171. ATA_PFLAG_FLUSH_PORT_TASK = (1 << 16), /* flush port task */
  172. ATA_PFLAG_SUSPENDED = (1 << 17), /* port is suspended (power) */
  173. ATA_PFLAG_PM_PENDING = (1 << 18), /* PM operation pending */
  174. /* struct ata_queued_cmd flags */
  175. ATA_QCFLAG_ACTIVE = (1 << 0), /* cmd not yet ack'd to scsi lyer */
  176. ATA_QCFLAG_SG = (1 << 1), /* have s/g table? */
  177. ATA_QCFLAG_SINGLE = (1 << 2), /* no s/g, just a single buffer */
  178. ATA_QCFLAG_DMAMAP = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
  179. ATA_QCFLAG_IO = (1 << 3), /* standard IO command */
  180. ATA_QCFLAG_RESULT_TF = (1 << 4), /* result TF requested */
  181. ATA_QCFLAG_FAILED = (1 << 16), /* cmd failed and is owned by EH */
  182. ATA_QCFLAG_SENSE_VALID = (1 << 17), /* sense data valid */
  183. ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */
  184. /* host set flags */
  185. ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host only */
  186. ATA_HOST_STARTED = (1 << 1), /* Host started */
  187. /* various lengths of time */
  188. ATA_TMOUT_BOOT = 30 * HZ, /* heuristic */
  189. ATA_TMOUT_BOOT_QUICK = 7 * HZ, /* heuristic */
  190. ATA_TMOUT_INTERNAL = 30 * HZ,
  191. ATA_TMOUT_INTERNAL_QUICK = 5 * HZ,
  192. /* ATA bus states */
  193. BUS_UNKNOWN = 0,
  194. BUS_DMA = 1,
  195. BUS_IDLE = 2,
  196. BUS_NOINTR = 3,
  197. BUS_NODATA = 4,
  198. BUS_TIMER = 5,
  199. BUS_PIO = 6,
  200. BUS_EDD = 7,
  201. BUS_IDENTIFY = 8,
  202. BUS_PACKET = 9,
  203. /* SATA port states */
  204. PORT_UNKNOWN = 0,
  205. PORT_ENABLED = 1,
  206. PORT_DISABLED = 2,
  207. /* encoding various smaller bitmaps into a single
  208. * unsigned int bitmap
  209. */
  210. ATA_BITS_PIO = 7,
  211. ATA_BITS_MWDMA = 5,
  212. ATA_BITS_UDMA = 8,
  213. ATA_SHIFT_PIO = 0,
  214. ATA_SHIFT_MWDMA = ATA_SHIFT_PIO + ATA_BITS_PIO,
  215. ATA_SHIFT_UDMA = ATA_SHIFT_MWDMA + ATA_BITS_MWDMA,
  216. ATA_MASK_PIO = ((1 << ATA_BITS_PIO) - 1) << ATA_SHIFT_PIO,
  217. ATA_MASK_MWDMA = ((1 << ATA_BITS_MWDMA) - 1) << ATA_SHIFT_MWDMA,
  218. ATA_MASK_UDMA = ((1 << ATA_BITS_UDMA) - 1) << ATA_SHIFT_UDMA,
  219. /* size of buffer to pad xfers ending on unaligned boundaries */
  220. ATA_DMA_PAD_SZ = 4,
  221. ATA_DMA_PAD_BUF_SZ = ATA_DMA_PAD_SZ * ATA_MAX_QUEUE,
  222. /* masks for port functions */
  223. ATA_PORT_PRIMARY = (1 << 0),
  224. ATA_PORT_SECONDARY = (1 << 1),
  225. /* ering size */
  226. ATA_ERING_SIZE = 32,
  227. /* desc_len for ata_eh_info and context */
  228. ATA_EH_DESC_LEN = 80,
  229. /* reset / recovery action types */
  230. ATA_EH_REVALIDATE = (1 << 0),
  231. ATA_EH_SOFTRESET = (1 << 1),
  232. ATA_EH_HARDRESET = (1 << 2),
  233. ATA_EH_SUSPEND = (1 << 3),
  234. ATA_EH_RESUME = (1 << 4),
  235. ATA_EH_PM_FREEZE = (1 << 5),
  236. ATA_EH_RESET_MASK = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
  237. ATA_EH_PERDEV_MASK = ATA_EH_REVALIDATE | ATA_EH_SUSPEND |
  238. ATA_EH_RESUME | ATA_EH_PM_FREEZE,
  239. /* ata_eh_info->flags */
  240. ATA_EHI_HOTPLUGGED = (1 << 0), /* could have been hotplugged */
  241. ATA_EHI_RESUME_LINK = (1 << 1), /* resume link (reset modifier) */
  242. ATA_EHI_NO_AUTOPSY = (1 << 2), /* no autopsy */
  243. ATA_EHI_QUIET = (1 << 3), /* be quiet */
  244. ATA_EHI_DID_SOFTRESET = (1 << 16), /* already soft-reset this port */
  245. ATA_EHI_DID_HARDRESET = (1 << 17), /* already soft-reset this port */
  246. ATA_EHI_PRINTINFO = (1 << 18), /* print configuration info */
  247. ATA_EHI_SETMODE = (1 << 19), /* configure transfer mode */
  248. ATA_EHI_POST_SETMODE = (1 << 20), /* revaildating after setmode */
  249. ATA_EHI_DID_RESET = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
  250. ATA_EHI_RESET_MODIFIER_MASK = ATA_EHI_RESUME_LINK,
  251. /* max repeat if error condition is still set after ->error_handler */
  252. ATA_EH_MAX_REPEAT = 5,
  253. /* how hard are we gonna try to probe/recover devices */
  254. ATA_PROBE_MAX_TRIES = 3,
  255. ATA_EH_DEV_TRIES = 3,
  256. /* Horkage types. May be set by libata or controller on drives
  257. (some horkage may be drive/controller pair dependant */
  258. ATA_HORKAGE_DIAGNOSTIC = (1 << 0), /* Failed boot diag */
  259. ATA_HORKAGE_NODMA = (1 << 1), /* DMA problems */
  260. ATA_HORKAGE_NONCQ = (1 << 2), /* Don't use NCQ */
  261. ATA_HORKAGE_MAX_SEC_128 = (1 << 3), /* Limit max sects to 128 */
  262. ATA_HORKAGE_DMA_RW_ONLY = (1 << 4), /* ATAPI DMA for RW only */
  263. };
  264. enum hsm_task_states {
  265. HSM_ST_IDLE, /* no command on going */
  266. HSM_ST_FIRST, /* (waiting the device to)
  267. write CDB or first data block */
  268. HSM_ST, /* (waiting the device to) transfer data */
  269. HSM_ST_LAST, /* (waiting the device to) complete command */
  270. HSM_ST_ERR, /* error */
  271. };
  272. enum ata_completion_errors {
  273. AC_ERR_DEV = (1 << 0), /* device reported error */
  274. AC_ERR_HSM = (1 << 1), /* host state machine violation */
  275. AC_ERR_TIMEOUT = (1 << 2), /* timeout */
  276. AC_ERR_MEDIA = (1 << 3), /* media error */
  277. AC_ERR_ATA_BUS = (1 << 4), /* ATA bus error */
  278. AC_ERR_HOST_BUS = (1 << 5), /* host bus error */
  279. AC_ERR_SYSTEM = (1 << 6), /* system error */
  280. AC_ERR_INVALID = (1 << 7), /* invalid argument */
  281. AC_ERR_OTHER = (1 << 8), /* unknown */
  282. AC_ERR_NODEV_HINT = (1 << 9), /* polling device detection hint */
  283. };
  284. /* forward declarations */
  285. struct scsi_device;
  286. struct ata_port_operations;
  287. struct ata_port;
  288. struct ata_queued_cmd;
  289. /* typedefs */
  290. typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
  291. typedef int (*ata_prereset_fn_t)(struct ata_port *ap, unsigned long deadline);
  292. typedef int (*ata_reset_fn_t)(struct ata_port *ap, unsigned int *classes,
  293. unsigned long deadline);
  294. typedef void (*ata_postreset_fn_t)(struct ata_port *ap, unsigned int *classes);
  295. struct ata_ioports {
  296. void __iomem *cmd_addr;
  297. void __iomem *data_addr;
  298. void __iomem *error_addr;
  299. void __iomem *feature_addr;
  300. void __iomem *nsect_addr;
  301. void __iomem *lbal_addr;
  302. void __iomem *lbam_addr;
  303. void __iomem *lbah_addr;
  304. void __iomem *device_addr;
  305. void __iomem *status_addr;
  306. void __iomem *command_addr;
  307. void __iomem *altstatus_addr;
  308. void __iomem *ctl_addr;
  309. void __iomem *bmdma_addr;
  310. void __iomem *scr_addr;
  311. };
  312. struct ata_host {
  313. spinlock_t lock;
  314. struct device *dev;
  315. unsigned long irq;
  316. unsigned long irq2;
  317. void __iomem * const *iomap;
  318. unsigned int n_ports;
  319. void *private_data;
  320. const struct ata_port_operations *ops;
  321. unsigned long flags;
  322. struct ata_port *simplex_claimed; /* channel owning the DMA */
  323. struct ata_port *ports[0];
  324. };
  325. struct ata_queued_cmd {
  326. struct ata_port *ap;
  327. struct ata_device *dev;
  328. struct scsi_cmnd *scsicmd;
  329. void (*scsidone)(struct scsi_cmnd *);
  330. struct ata_taskfile tf;
  331. u8 cdb[ATAPI_CDB_LEN];
  332. unsigned long flags; /* ATA_QCFLAG_xxx */
  333. unsigned int tag;
  334. unsigned int n_elem;
  335. unsigned int orig_n_elem;
  336. int dma_dir;
  337. unsigned int pad_len;
  338. unsigned int sect_size;
  339. unsigned int nbytes;
  340. unsigned int curbytes;
  341. unsigned int cursg;
  342. unsigned int cursg_ofs;
  343. struct scatterlist sgent;
  344. struct scatterlist pad_sgent;
  345. void *buf_virt;
  346. /* DO NOT iterate over __sg manually, use ata_for_each_sg() */
  347. struct scatterlist *__sg;
  348. unsigned int err_mask;
  349. struct ata_taskfile result_tf;
  350. ata_qc_cb_t complete_fn;
  351. void *private_data;
  352. };
  353. struct ata_port_stats {
  354. unsigned long unhandled_irq;
  355. unsigned long idle_irq;
  356. unsigned long rw_reqbuf;
  357. };
  358. struct ata_ering_entry {
  359. int is_io;
  360. unsigned int err_mask;
  361. u64 timestamp;
  362. };
  363. struct ata_ering {
  364. int cursor;
  365. struct ata_ering_entry ring[ATA_ERING_SIZE];
  366. };
  367. struct ata_device {
  368. struct ata_port *ap;
  369. unsigned int devno; /* 0 or 1 */
  370. unsigned long flags; /* ATA_DFLAG_xxx */
  371. struct scsi_device *sdev; /* attached SCSI device */
  372. /* n_sector is used as CLEAR_OFFSET, read comment above CLEAR_OFFSET */
  373. u64 n_sectors; /* size of device, if ATA */
  374. u64 n_sectors_boot; /* size of ATA device at startup */
  375. unsigned int class; /* ATA_DEV_xxx */
  376. u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
  377. u8 pio_mode;
  378. u8 dma_mode;
  379. u8 xfer_mode;
  380. unsigned int xfer_shift; /* ATA_SHIFT_xxx */
  381. unsigned int multi_count; /* sectors count for
  382. READ/WRITE MULTIPLE */
  383. unsigned int max_sectors; /* per-device max sectors */
  384. unsigned int cdb_len;
  385. /* per-dev xfer mask */
  386. unsigned int pio_mask;
  387. unsigned int mwdma_mask;
  388. unsigned int udma_mask;
  389. /* for CHS addressing */
  390. u16 cylinders; /* Number of cylinders */
  391. u16 heads; /* Number of heads */
  392. u16 sectors; /* Number of sectors per track */
  393. /* error history */
  394. struct ata_ering ering;
  395. int spdn_cnt;
  396. unsigned int horkage; /* List of broken features */
  397. #ifdef CONFIG_SATA_ACPI
  398. /* ACPI objects info */
  399. acpi_handle obj_handle;
  400. #endif
  401. };
  402. /* Offset into struct ata_device. Fields above it are maintained
  403. * acress device init. Fields below are zeroed.
  404. */
  405. #define ATA_DEVICE_CLEAR_OFFSET offsetof(struct ata_device, n_sectors)
  406. struct ata_eh_info {
  407. struct ata_device *dev; /* offending device */
  408. u32 serror; /* SError from LLDD */
  409. unsigned int err_mask; /* port-wide err_mask */
  410. unsigned int action; /* ATA_EH_* action mask */
  411. unsigned int dev_action[ATA_MAX_DEVICES]; /* dev EH action */
  412. unsigned int flags; /* ATA_EHI_* flags */
  413. unsigned int probe_mask;
  414. char desc[ATA_EH_DESC_LEN];
  415. int desc_len;
  416. };
  417. struct ata_eh_context {
  418. struct ata_eh_info i;
  419. int tries[ATA_MAX_DEVICES];
  420. unsigned int classes[ATA_MAX_DEVICES];
  421. unsigned int did_probe_mask;
  422. };
  423. struct ata_port {
  424. struct Scsi_Host *scsi_host; /* our co-allocated scsi host */
  425. const struct ata_port_operations *ops;
  426. spinlock_t *lock;
  427. unsigned long flags; /* ATA_FLAG_xxx */
  428. unsigned int pflags; /* ATA_PFLAG_xxx */
  429. unsigned int print_id; /* user visible unique port ID */
  430. unsigned int port_no; /* 0 based port no. inside the host */
  431. struct ata_prd *prd; /* our SG list */
  432. dma_addr_t prd_dma; /* and its DMA mapping */
  433. void *pad; /* array of DMA pad buffers */
  434. dma_addr_t pad_dma;
  435. struct ata_ioports ioaddr; /* ATA cmd/ctl/dma register blocks */
  436. u8 ctl; /* cache of ATA control register */
  437. u8 last_ctl; /* Cache last written value */
  438. unsigned int pio_mask;
  439. unsigned int mwdma_mask;
  440. unsigned int udma_mask;
  441. unsigned int cbl; /* cable type; ATA_CBL_xxx */
  442. unsigned int hw_sata_spd_limit;
  443. unsigned int sata_spd_limit; /* SATA PHY speed limit */
  444. /* record runtime error info, protected by host lock */
  445. struct ata_eh_info eh_info;
  446. /* EH context owned by EH */
  447. struct ata_eh_context eh_context;
  448. struct ata_device device[ATA_MAX_DEVICES];
  449. struct ata_queued_cmd qcmd[ATA_MAX_QUEUE];
  450. unsigned long qc_allocated;
  451. unsigned int qc_active;
  452. unsigned int active_tag;
  453. u32 sactive;
  454. struct ata_port_stats stats;
  455. struct ata_host *host;
  456. struct device *dev;
  457. void *port_task_data;
  458. struct delayed_work port_task;
  459. struct delayed_work hotplug_task;
  460. struct work_struct scsi_rescan_task;
  461. unsigned int hsm_task_state;
  462. u32 msg_enable;
  463. struct list_head eh_done_q;
  464. wait_queue_head_t eh_wait_q;
  465. pm_message_t pm_mesg;
  466. int *pm_result;
  467. void *private_data;
  468. u8 sector_buf[ATA_SECT_SIZE]; /* owned by EH */
  469. };
  470. struct ata_port_operations {
  471. void (*port_disable) (struct ata_port *);
  472. void (*dev_config) (struct ata_device *);
  473. void (*set_piomode) (struct ata_port *, struct ata_device *);
  474. void (*set_dmamode) (struct ata_port *, struct ata_device *);
  475. unsigned long (*mode_filter) (struct ata_device *, unsigned long);
  476. void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
  477. void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
  478. void (*exec_command)(struct ata_port *ap, const struct ata_taskfile *tf);
  479. u8 (*check_status)(struct ata_port *ap);
  480. u8 (*check_altstatus)(struct ata_port *ap);
  481. void (*dev_select)(struct ata_port *ap, unsigned int device);
  482. void (*phy_reset) (struct ata_port *ap); /* obsolete */
  483. int (*set_mode) (struct ata_port *ap, struct ata_device **r_failed_dev);
  484. void (*post_set_mode) (struct ata_port *ap);
  485. int (*cable_detect) (struct ata_port *ap);
  486. int (*check_atapi_dma) (struct ata_queued_cmd *qc);
  487. void (*bmdma_setup) (struct ata_queued_cmd *qc);
  488. void (*bmdma_start) (struct ata_queued_cmd *qc);
  489. void (*data_xfer) (struct ata_device *, unsigned char *, unsigned int, int);
  490. void (*qc_prep) (struct ata_queued_cmd *qc);
  491. unsigned int (*qc_issue) (struct ata_queued_cmd *qc);
  492. /* Error handlers. ->error_handler overrides ->eng_timeout and
  493. * indicates that new-style EH is in place.
  494. */
  495. void (*eng_timeout) (struct ata_port *ap); /* obsolete */
  496. void (*freeze) (struct ata_port *ap);
  497. void (*thaw) (struct ata_port *ap);
  498. void (*error_handler) (struct ata_port *ap);
  499. void (*post_internal_cmd) (struct ata_queued_cmd *qc);
  500. irq_handler_t irq_handler;
  501. void (*irq_clear) (struct ata_port *);
  502. u8 (*irq_on) (struct ata_port *);
  503. u8 (*irq_ack) (struct ata_port *ap, unsigned int chk_drq);
  504. u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
  505. void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
  506. u32 val);
  507. int (*port_suspend) (struct ata_port *ap, pm_message_t mesg);
  508. int (*port_resume) (struct ata_port *ap);
  509. int (*port_start) (struct ata_port *ap);
  510. void (*port_stop) (struct ata_port *ap);
  511. void (*host_stop) (struct ata_host *host);
  512. void (*bmdma_stop) (struct ata_queued_cmd *qc);
  513. u8 (*bmdma_status) (struct ata_port *ap);
  514. };
  515. struct ata_port_info {
  516. struct scsi_host_template *sht;
  517. unsigned long flags;
  518. unsigned long pio_mask;
  519. unsigned long mwdma_mask;
  520. unsigned long udma_mask;
  521. const struct ata_port_operations *port_ops;
  522. irq_handler_t irq_handler;
  523. void *private_data;
  524. };
  525. struct ata_timing {
  526. unsigned short mode; /* ATA mode */
  527. unsigned short setup; /* t1 */
  528. unsigned short act8b; /* t2 for 8-bit I/O */
  529. unsigned short rec8b; /* t2i for 8-bit I/O */
  530. unsigned short cyc8b; /* t0 for 8-bit I/O */
  531. unsigned short active; /* t2 or tD */
  532. unsigned short recover; /* t2i or tK */
  533. unsigned short cycle; /* t0 */
  534. unsigned short udma; /* t2CYCTYP/2 */
  535. };
  536. #define FIT(v,vmin,vmax) max_t(short,min_t(short,v,vmax),vmin)
  537. extern const unsigned long sata_deb_timing_normal[];
  538. extern const unsigned long sata_deb_timing_hotplug[];
  539. extern const unsigned long sata_deb_timing_long[];
  540. extern const struct ata_port_operations ata_dummy_port_ops;
  541. extern const struct ata_port_info ata_dummy_port_info;
  542. static inline const unsigned long *
  543. sata_ehc_deb_timing(struct ata_eh_context *ehc)
  544. {
  545. if (ehc->i.flags & ATA_EHI_HOTPLUGGED)
  546. return sata_deb_timing_hotplug;
  547. else
  548. return sata_deb_timing_normal;
  549. }
  550. static inline int ata_port_is_dummy(struct ata_port *ap)
  551. {
  552. return ap->ops == &ata_dummy_port_ops;
  553. }
  554. extern void sata_print_link_status(struct ata_port *ap);
  555. extern void ata_port_probe(struct ata_port *);
  556. extern void __sata_phy_reset(struct ata_port *ap);
  557. extern void sata_phy_reset(struct ata_port *ap);
  558. extern void ata_bus_reset(struct ata_port *ap);
  559. extern int sata_set_spd(struct ata_port *ap);
  560. extern int sata_phy_debounce(struct ata_port *ap, const unsigned long *param,
  561. unsigned long deadline);
  562. extern int sata_phy_resume(struct ata_port *ap, const unsigned long *param,
  563. unsigned long deadline);
  564. extern int ata_std_prereset(struct ata_port *ap, unsigned long deadline);
  565. extern int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
  566. unsigned long deadline);
  567. extern int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
  568. unsigned long deadline);
  569. extern int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
  570. unsigned long deadline);
  571. extern void ata_std_postreset(struct ata_port *ap, unsigned int *classes);
  572. extern void ata_port_disable(struct ata_port *);
  573. extern void ata_std_ports(struct ata_ioports *ioaddr);
  574. #ifdef CONFIG_PCI
  575. extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
  576. unsigned int n_ports);
  577. extern void ata_pci_remove_one (struct pci_dev *pdev);
  578. #ifdef CONFIG_PM
  579. extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
  580. extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
  581. extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
  582. extern int ata_pci_device_resume(struct pci_dev *pdev);
  583. #endif
  584. extern int ata_pci_clear_simplex(struct pci_dev *pdev);
  585. #endif /* CONFIG_PCI */
  586. extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
  587. extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
  588. const struct ata_port_info * const * ppi, int n_ports);
  589. extern int ata_host_start(struct ata_host *host);
  590. extern int ata_host_register(struct ata_host *host,
  591. struct scsi_host_template *sht);
  592. extern int ata_host_activate(struct ata_host *host, int irq,
  593. irq_handler_t irq_handler, unsigned long irq_flags,
  594. struct scsi_host_template *sht);
  595. extern void ata_host_detach(struct ata_host *host);
  596. extern void ata_host_init(struct ata_host *, struct device *,
  597. unsigned long, const struct ata_port_operations *);
  598. extern int ata_scsi_detect(struct scsi_host_template *sht);
  599. extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
  600. extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
  601. extern void ata_sas_port_destroy(struct ata_port *);
  602. extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
  603. struct ata_port_info *, struct Scsi_Host *);
  604. extern int ata_sas_port_init(struct ata_port *);
  605. extern int ata_sas_port_start(struct ata_port *ap);
  606. extern void ata_sas_port_stop(struct ata_port *ap);
  607. extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
  608. extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
  609. struct ata_port *ap);
  610. extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
  611. extern int sata_scr_valid(struct ata_port *ap);
  612. extern int sata_scr_read(struct ata_port *ap, int reg, u32 *val);
  613. extern int sata_scr_write(struct ata_port *ap, int reg, u32 val);
  614. extern int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val);
  615. extern int ata_port_online(struct ata_port *ap);
  616. extern int ata_port_offline(struct ata_port *ap);
  617. #ifdef CONFIG_PM
  618. extern int ata_scsi_device_resume(struct scsi_device *);
  619. extern int ata_scsi_device_suspend(struct scsi_device *, pm_message_t mesg);
  620. extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
  621. extern void ata_host_resume(struct ata_host *host);
  622. #endif
  623. extern int ata_ratelimit(void);
  624. extern int ata_busy_sleep(struct ata_port *ap,
  625. unsigned long timeout_pat, unsigned long timeout);
  626. extern int ata_wait_ready(struct ata_port *ap, unsigned long deadline);
  627. extern void ata_port_queue_task(struct ata_port *ap, work_func_t fn,
  628. void *data, unsigned long delay);
  629. extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
  630. unsigned long interval_msec,
  631. unsigned long timeout_msec);
  632. extern unsigned int ata_dev_try_classify(struct ata_port *, unsigned int, u8 *);
  633. /*
  634. * Default driver ops implementations
  635. */
  636. extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
  637. extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
  638. extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp);
  639. extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
  640. extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
  641. extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
  642. extern u8 ata_check_status(struct ata_port *ap);
  643. extern u8 ata_altstatus(struct ata_port *ap);
  644. extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
  645. extern int ata_port_start (struct ata_port *ap);
  646. extern irqreturn_t ata_interrupt (int irq, void *dev_instance);
  647. extern void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
  648. unsigned int buflen, int write_data);
  649. extern void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
  650. unsigned int buflen, int write_data);
  651. extern void ata_qc_prep(struct ata_queued_cmd *qc);
  652. extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
  653. extern unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc);
  654. extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
  655. unsigned int buflen);
  656. extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
  657. unsigned int n_elem);
  658. extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
  659. extern void ata_dev_disable(struct ata_device *adev);
  660. extern void ata_id_string(const u16 *id, unsigned char *s,
  661. unsigned int ofs, unsigned int len);
  662. extern void ata_id_c_string(const u16 *id, unsigned char *s,
  663. unsigned int ofs, unsigned int len);
  664. extern void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown);
  665. extern unsigned long ata_device_blacklisted(const struct ata_device *dev);
  666. extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
  667. extern void ata_bmdma_start (struct ata_queued_cmd *qc);
  668. extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
  669. extern u8 ata_bmdma_status(struct ata_port *ap);
  670. extern void ata_bmdma_irq_clear(struct ata_port *ap);
  671. extern void ata_bmdma_freeze(struct ata_port *ap);
  672. extern void ata_bmdma_thaw(struct ata_port *ap);
  673. extern void ata_bmdma_drive_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
  674. ata_reset_fn_t softreset,
  675. ata_reset_fn_t hardreset,
  676. ata_postreset_fn_t postreset);
  677. extern void ata_bmdma_error_handler(struct ata_port *ap);
  678. extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
  679. extern int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
  680. u8 status, int in_wq);
  681. extern void ata_qc_complete(struct ata_queued_cmd *qc);
  682. extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
  683. void (*finish_qc)(struct ata_queued_cmd *));
  684. extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
  685. void (*done)(struct scsi_cmnd *));
  686. extern int ata_std_bios_param(struct scsi_device *sdev,
  687. struct block_device *bdev,
  688. sector_t capacity, int geom[]);
  689. extern int ata_scsi_slave_config(struct scsi_device *sdev);
  690. extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
  691. extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
  692. int queue_depth);
  693. extern struct ata_device *ata_dev_pair(struct ata_device *adev);
  694. extern int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev);
  695. extern u8 ata_irq_on(struct ata_port *ap);
  696. extern u8 ata_dummy_irq_on(struct ata_port *ap);
  697. extern u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq);
  698. extern u8 ata_dummy_irq_ack(struct ata_port *ap, unsigned int chk_drq);
  699. extern int ata_cable_40wire(struct ata_port *ap);
  700. extern int ata_cable_80wire(struct ata_port *ap);
  701. extern int ata_cable_sata(struct ata_port *ap);
  702. extern int ata_cable_unknown(struct ata_port *ap);
  703. /*
  704. * Timing helpers
  705. */
  706. extern unsigned int ata_pio_need_iordy(const struct ata_device *);
  707. extern int ata_timing_compute(struct ata_device *, unsigned short,
  708. struct ata_timing *, int, int);
  709. extern void ata_timing_merge(const struct ata_timing *,
  710. const struct ata_timing *, struct ata_timing *,
  711. unsigned int);
  712. enum {
  713. ATA_TIMING_SETUP = (1 << 0),
  714. ATA_TIMING_ACT8B = (1 << 1),
  715. ATA_TIMING_REC8B = (1 << 2),
  716. ATA_TIMING_CYC8B = (1 << 3),
  717. ATA_TIMING_8BIT = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
  718. ATA_TIMING_CYC8B,
  719. ATA_TIMING_ACTIVE = (1 << 4),
  720. ATA_TIMING_RECOVER = (1 << 5),
  721. ATA_TIMING_CYCLE = (1 << 6),
  722. ATA_TIMING_UDMA = (1 << 7),
  723. ATA_TIMING_ALL = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
  724. ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
  725. ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
  726. ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
  727. };
  728. #ifdef CONFIG_PCI
  729. struct pci_bits {
  730. unsigned int reg; /* PCI config register to read */
  731. unsigned int width; /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
  732. unsigned long mask;
  733. unsigned long val;
  734. };
  735. extern int ata_pci_init_native_host(struct ata_host *host,
  736. unsigned int port_mask);
  737. extern int ata_pci_prepare_native_host(struct pci_dev *pdev,
  738. const struct ata_port_info * const * ppi,
  739. int n_ports, struct ata_host **r_host);
  740. extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
  741. extern unsigned long ata_pci_default_filter(struct ata_device *, unsigned long);
  742. #endif /* CONFIG_PCI */
  743. /*
  744. * EH
  745. */
  746. extern void ata_eng_timeout(struct ata_port *ap);
  747. extern void ata_port_schedule_eh(struct ata_port *ap);
  748. extern int ata_port_abort(struct ata_port *ap);
  749. extern int ata_port_freeze(struct ata_port *ap);
  750. extern void ata_eh_freeze_port(struct ata_port *ap);
  751. extern void ata_eh_thaw_port(struct ata_port *ap);
  752. extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
  753. extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
  754. extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
  755. ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
  756. ata_postreset_fn_t postreset);
  757. /*
  758. * printk helpers
  759. */
  760. #define ata_port_printk(ap, lv, fmt, args...) \
  761. printk(lv"ata%u: "fmt, (ap)->print_id , ##args)
  762. #define ata_dev_printk(dev, lv, fmt, args...) \
  763. printk(lv"ata%u.%02u: "fmt, (dev)->ap->print_id, (dev)->devno , ##args)
  764. /*
  765. * ata_eh_info helpers
  766. */
  767. #define ata_ehi_push_desc(ehi, fmt, args...) do { \
  768. (ehi)->desc_len += scnprintf((ehi)->desc + (ehi)->desc_len, \
  769. ATA_EH_DESC_LEN - (ehi)->desc_len, \
  770. fmt , ##args); \
  771. } while (0)
  772. #define ata_ehi_clear_desc(ehi) do { \
  773. (ehi)->desc[0] = '\0'; \
  774. (ehi)->desc_len = 0; \
  775. } while (0)
  776. static inline void __ata_ehi_hotplugged(struct ata_eh_info *ehi)
  777. {
  778. ehi->flags |= ATA_EHI_HOTPLUGGED | ATA_EHI_RESUME_LINK;
  779. ehi->action |= ATA_EH_SOFTRESET;
  780. ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
  781. }
  782. static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
  783. {
  784. __ata_ehi_hotplugged(ehi);
  785. ehi->err_mask |= AC_ERR_ATA_BUS;
  786. }
  787. /*
  788. * qc helpers
  789. */
  790. static inline int
  791. ata_sg_is_last(struct scatterlist *sg, struct ata_queued_cmd *qc)
  792. {
  793. if (sg == &qc->pad_sgent)
  794. return 1;
  795. if (qc->pad_len)
  796. return 0;
  797. if (((sg - qc->__sg) + 1) == qc->n_elem)
  798. return 1;
  799. return 0;
  800. }
  801. static inline struct scatterlist *
  802. ata_qc_first_sg(struct ata_queued_cmd *qc)
  803. {
  804. if (qc->n_elem)
  805. return qc->__sg;
  806. if (qc->pad_len)
  807. return &qc->pad_sgent;
  808. return NULL;
  809. }
  810. static inline struct scatterlist *
  811. ata_qc_next_sg(struct scatterlist *sg, struct ata_queued_cmd *qc)
  812. {
  813. if (sg == &qc->pad_sgent)
  814. return NULL;
  815. if (++sg - qc->__sg < qc->n_elem)
  816. return sg;
  817. if (qc->pad_len)
  818. return &qc->pad_sgent;
  819. return NULL;
  820. }
  821. #define ata_for_each_sg(sg, qc) \
  822. for (sg = ata_qc_first_sg(qc); sg; sg = ata_qc_next_sg(sg, qc))
  823. static inline unsigned int ata_tag_valid(unsigned int tag)
  824. {
  825. return (tag < ATA_MAX_QUEUE) ? 1 : 0;
  826. }
  827. static inline unsigned int ata_tag_internal(unsigned int tag)
  828. {
  829. return tag == ATA_MAX_QUEUE - 1;
  830. }
  831. /*
  832. * device helpers
  833. */
  834. static inline unsigned int ata_class_enabled(unsigned int class)
  835. {
  836. return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI;
  837. }
  838. static inline unsigned int ata_class_disabled(unsigned int class)
  839. {
  840. return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP;
  841. }
  842. static inline unsigned int ata_class_absent(unsigned int class)
  843. {
  844. return !ata_class_enabled(class) && !ata_class_disabled(class);
  845. }
  846. static inline unsigned int ata_dev_enabled(const struct ata_device *dev)
  847. {
  848. return ata_class_enabled(dev->class);
  849. }
  850. static inline unsigned int ata_dev_disabled(const struct ata_device *dev)
  851. {
  852. return ata_class_disabled(dev->class);
  853. }
  854. static inline unsigned int ata_dev_absent(const struct ata_device *dev)
  855. {
  856. return ata_class_absent(dev->class);
  857. }
  858. static inline unsigned int ata_dev_ready(const struct ata_device *dev)
  859. {
  860. return ata_dev_enabled(dev) && !(dev->flags & ATA_DFLAG_SUSPENDED);
  861. }
  862. /*
  863. * port helpers
  864. */
  865. static inline int ata_port_max_devices(const struct ata_port *ap)
  866. {
  867. if (ap->flags & ATA_FLAG_SLAVE_POSS)
  868. return 2;
  869. return 1;
  870. }
  871. static inline u8 ata_chk_status(struct ata_port *ap)
  872. {
  873. return ap->ops->check_status(ap);
  874. }
  875. /**
  876. * ata_ncq_enabled - Test whether NCQ is enabled
  877. * @dev: ATA device to test for
  878. *
  879. * LOCKING:
  880. * spin_lock_irqsave(host lock)
  881. *
  882. * RETURNS:
  883. * 1 if NCQ is enabled for @dev, 0 otherwise.
  884. */
  885. static inline int ata_ncq_enabled(struct ata_device *dev)
  886. {
  887. return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
  888. ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;
  889. }
  890. /**
  891. * ata_pause - Flush writes and pause 400 nanoseconds.
  892. * @ap: Port to wait for.
  893. *
  894. * LOCKING:
  895. * Inherited from caller.
  896. */
  897. static inline void ata_pause(struct ata_port *ap)
  898. {
  899. ata_altstatus(ap);
  900. ndelay(400);
  901. }
  902. /**
  903. * ata_busy_wait - Wait for a port status register
  904. * @ap: Port to wait for.
  905. * @bits: bits that must be clear
  906. * @max: number of 10uS waits to perform
  907. *
  908. * Waits up to max*10 microseconds for the selected bits in the port's
  909. * status register to be cleared.
  910. * Returns final value of status register.
  911. *
  912. * LOCKING:
  913. * Inherited from caller.
  914. */
  915. static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
  916. unsigned int max)
  917. {
  918. u8 status;
  919. do {
  920. udelay(10);
  921. status = ata_chk_status(ap);
  922. max--;
  923. } while (status != 0xff && (status & bits) && (max > 0));
  924. return status;
  925. }
  926. /**
  927. * ata_wait_idle - Wait for a port to be idle.
  928. * @ap: Port to wait for.
  929. *
  930. * Waits up to 10ms for port's BUSY and DRQ signals to clear.
  931. * Returns final value of status register.
  932. *
  933. * LOCKING:
  934. * Inherited from caller.
  935. */
  936. static inline u8 ata_wait_idle(struct ata_port *ap)
  937. {
  938. u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
  939. if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ))) {
  940. if (ata_msg_warn(ap))
  941. printk(KERN_WARNING "ATA: abnormal status 0x%X on port 0x%p\n",
  942. status, ap->ioaddr.status_addr);
  943. }
  944. return status;
  945. }
  946. static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
  947. {
  948. qc->tf.ctl |= ATA_NIEN;
  949. }
  950. static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
  951. unsigned int tag)
  952. {
  953. if (likely(ata_tag_valid(tag)))
  954. return &ap->qcmd[tag];
  955. return NULL;
  956. }
  957. static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
  958. unsigned int tag)
  959. {
  960. struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
  961. if (unlikely(!qc) || !ap->ops->error_handler)
  962. return qc;
  963. if ((qc->flags & (ATA_QCFLAG_ACTIVE |
  964. ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE)
  965. return qc;
  966. return NULL;
  967. }
  968. static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
  969. {
  970. memset(tf, 0, sizeof(*tf));
  971. tf->ctl = dev->ap->ctl;
  972. if (dev->devno == 0)
  973. tf->device = ATA_DEVICE_OBS;
  974. else
  975. tf->device = ATA_DEVICE_OBS | ATA_DEV1;
  976. }
  977. static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
  978. {
  979. qc->dma_dir = DMA_NONE;
  980. qc->__sg = NULL;
  981. qc->flags = 0;
  982. qc->cursg = qc->cursg_ofs = 0;
  983. qc->nbytes = qc->curbytes = 0;
  984. qc->n_elem = 0;
  985. qc->err_mask = 0;
  986. qc->pad_len = 0;
  987. qc->sect_size = ATA_SECT_SIZE;
  988. ata_tf_init(qc->dev, &qc->tf);
  989. /* init result_tf such that it indicates normal completion */
  990. qc->result_tf.command = ATA_DRDY;
  991. qc->result_tf.feature = 0;
  992. }
  993. static inline int ata_try_flush_cache(const struct ata_device *dev)
  994. {
  995. return ata_id_wcache_enabled(dev->id) ||
  996. ata_id_has_flush(dev->id) ||
  997. ata_id_has_flush_ext(dev->id);
  998. }
  999. static inline unsigned int ac_err_mask(u8 status)
  1000. {
  1001. if (status & (ATA_BUSY | ATA_DRQ))
  1002. return AC_ERR_HSM;
  1003. if (status & (ATA_ERR | ATA_DF))
  1004. return AC_ERR_DEV;
  1005. return 0;
  1006. }
  1007. static inline unsigned int __ac_err_mask(u8 status)
  1008. {
  1009. unsigned int mask = ac_err_mask(status);
  1010. if (mask == 0)
  1011. return AC_ERR_OTHER;
  1012. return mask;
  1013. }
  1014. static inline int ata_pad_alloc(struct ata_port *ap, struct device *dev)
  1015. {
  1016. ap->pad_dma = 0;
  1017. ap->pad = dmam_alloc_coherent(dev, ATA_DMA_PAD_BUF_SZ,
  1018. &ap->pad_dma, GFP_KERNEL);
  1019. return (ap->pad == NULL) ? -ENOMEM : 0;
  1020. }
  1021. static inline void ata_pad_free(struct ata_port *ap, struct device *dev)
  1022. {
  1023. dmam_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
  1024. }
  1025. static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host)
  1026. {
  1027. return *(struct ata_port **)&host->hostdata[0];
  1028. }
  1029. #endif /* __LINUX_LIBATA_H__ */