libata.h 37 KB

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