Blame view
include/linux/libata.h
52.7 KB
1da177e4c
|
1 |
/* |
af36d7f0d
|
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
* Copyright 2003-2005 Red Hat, Inc. All rights reserved. * Copyright 2003-2005 Jeff Garzik * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; see the file COPYING. If not, write to * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. * * * libata documentation is available via 'make {ps|pdf}docs', * as Documentation/DocBook/libata.* * |
1da177e4c
|
24 25 26 27 28 29 |
*/ #ifndef __LINUX_LIBATA_H__ #define __LINUX_LIBATA_H__ #include <linux/delay.h> |
341c2c958
|
30 |
#include <linux/jiffies.h> |
1da177e4c
|
31 |
#include <linux/interrupt.h> |
1c72d8d90
|
32 |
#include <linux/dma-mapping.h> |
872602162
|
33 |
#include <linux/scatterlist.h> |
f0d36efdc
|
34 |
#include <linux/io.h> |
1da177e4c
|
35 36 |
#include <linux/ata.h> #include <linux/workqueue.h> |
35bb94b11
|
37 |
#include <scsi/scsi_host.h> |
11ef697b3
|
38 |
#include <linux/acpi.h> |
ceb0c6426
|
39 |
#include <linux/cdrom.h> |
1da177e4c
|
40 |
|
a6d967a48
|
41 42 43 44 45 |
/* * Define if arch has non-standard setup. This is a _PCI_ standard * not a legacy or ISA standard. */ #ifdef CONFIG_ATA_NONSTANDARD |
2ec7df045
|
46 |
#include <asm/libata-portmap.h> |
a6d967a48
|
47 48 49 |
#else #include <asm-generic/libata-portmap.h> #endif |
2ec7df045
|
50 |
|
1da177e4c
|
51 |
/* |
bfd605795
|
52 53 |
* compile-time options: to be removed as soon as all the drivers are * converted to the new debugging mechanism |
1da177e4c
|
54 55 56 57 58 |
*/ #undef ATA_DEBUG /* debugging output */ #undef ATA_VERBOSE_DEBUG /* yet more debugging output */ #undef ATA_IRQ_TRAP /* define to ack screaming irqs */ #undef ATA_NDEBUG /* define to disable quick runtime checks */ |
1da177e4c
|
59 60 61 62 |
/* note: prints function name for you */ #ifdef ATA_DEBUG |
1f938d060
|
63 |
#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args) |
1da177e4c
|
64 |
#ifdef ATA_VERBOSE_DEBUG |
1f938d060
|
65 |
#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args) |
1da177e4c
|
66 67 68 69 70 71 72 |
#else #define VPRINTK(fmt, args...) #endif /* ATA_VERBOSE_DEBUG */ #else #define DPRINTK(fmt, args...) #define VPRINTK(fmt, args...) #endif /* ATA_DEBUG */ |
1f938d060
|
73 |
#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args) |
2c13b7cee
|
74 |
|
bfd605795
|
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
/* NEW: debug levels */ #define HAVE_LIBATA_MSG 1 enum { ATA_MSG_DRV = 0x0001, ATA_MSG_INFO = 0x0002, ATA_MSG_PROBE = 0x0004, ATA_MSG_WARN = 0x0008, ATA_MSG_MALLOC = 0x0010, ATA_MSG_CTL = 0x0020, ATA_MSG_INTR = 0x0040, ATA_MSG_ERR = 0x0080, }; #define ata_msg_drv(p) ((p)->msg_enable & ATA_MSG_DRV) #define ata_msg_info(p) ((p)->msg_enable & ATA_MSG_INFO) #define ata_msg_probe(p) ((p)->msg_enable & ATA_MSG_PROBE) #define ata_msg_warn(p) ((p)->msg_enable & ATA_MSG_WARN) #define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC) #define ata_msg_ctl(p) ((p)->msg_enable & ATA_MSG_CTL) #define ata_msg_intr(p) ((p)->msg_enable & ATA_MSG_INTR) #define ata_msg_err(p) ((p)->msg_enable & ATA_MSG_ERR) static inline u32 ata_msg_init(int dval, int default_msg_enable_bits) { if (dval < 0 || dval >= (sizeof(u32) * 8)) return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */ if (!dval) return 0; return (1 << dval) - 1; } |
1da177e4c
|
106 107 |
/* defines only for the constants which don't work well as enums */ #define ATA_TAG_POISON 0xfafbfcfdU |
1da177e4c
|
108 109 110 |
enum { /* various global constants */ LIBATA_MAX_PRD = ATA_MAX_PRD / 2, |
d26fc9551
|
111 |
LIBATA_DUMB_MAX_PRD = ATA_MAX_PRD / 4, /* Worst case */ |
1da177e4c
|
112 |
ATA_DEF_QUEUE = 1, |
2ab7db1ff
|
113 |
/* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */ |
a6e6ce8e8
|
114 |
ATA_MAX_QUEUE = 32, |
2ab7db1ff
|
115 |
ATA_TAG_INTERNAL = ATA_MAX_QUEUE - 1, |
341c2c958
|
116 |
ATA_SHORT_PAUSE = 16, |
1da177e4c
|
117 |
|
140b5e591
|
118 |
ATAPI_MAX_DRAIN = 16 << 10, |
b558edddb
|
119 |
ATA_ALL_DEVICES = (1 << ATA_MAX_DEVICES) - 1, |
1da177e4c
|
120 121 122 |
ATA_SHT_EMULATED = 1, ATA_SHT_CMD_PER_LUN = 1, ATA_SHT_THIS_ID = -1, |
cf482935c
|
123 |
ATA_SHT_USE_CLUSTERING = 1, |
1da177e4c
|
124 125 |
/* struct ata_device stuff */ |
949b38af4
|
126 127 |
ATA_DFLAG_LBA = (1 << 0), /* device supports LBA */ ATA_DFLAG_LBA48 = (1 << 1), /* device supports LBA48 */ |
029f5468b
|
128 |
ATA_DFLAG_CDB_INTR = (1 << 2), /* device asserts INTRQ when ready for CDB */ |
88e490340
|
129 |
ATA_DFLAG_NCQ = (1 << 3), /* device supports NCQ */ |
6fc49adb9
|
130 |
ATA_DFLAG_FLUSH_EXT = (1 << 4), /* do FLUSH_EXT instead of FLUSH */ |
6746544c3
|
131 132 |
ATA_DFLAG_ACPI_PENDING = (1 << 5), /* ACPI resume action pending */ ATA_DFLAG_ACPI_FAILED = (1 << 6), /* ACPI on devcfg has failed */ |
7d77b2470
|
133 |
ATA_DFLAG_AN = (1 << 7), /* AN configured */ |
ca77329fb
|
134 135 |
ATA_DFLAG_HIPM = (1 << 8), /* device supports HIPM */ ATA_DFLAG_DIPM = (1 << 9), /* device supports DIPM */ |
911630063
|
136 |
ATA_DFLAG_DMADIR = (1 << 10), /* device requires DMADIR */ |
2557164e0
|
137 |
ATA_DFLAG_CFG_MASK = (1 << 12) - 1, |
949b38af4
|
138 |
|
2557164e0
|
139 140 141 |
ATA_DFLAG_PIO = (1 << 12), /* device limited to PIO mode */ ATA_DFLAG_NCQ_OFF = (1 << 13), /* device limited to non-NCQ mode */ ATA_DFLAG_SPUNDOWN = (1 << 14), /* XXX: for spindown_compat */ |
054a5fbac
|
142 |
ATA_DFLAG_SLEEPING = (1 << 15), /* device is sleeping */ |
00115e0f5
|
143 |
ATA_DFLAG_DUBIOUS_XFER = (1 << 16), /* data transfer not verified */ |
45fabbb77
|
144 |
ATA_DFLAG_NO_UNLOAD = (1 << 17), /* device doesn't support unload */ |
f20ded38a
|
145 |
ATA_DFLAG_INIT_MASK = (1 << 24) - 1, |
1da177e4c
|
146 |
|
f20ded38a
|
147 148 |
ATA_DFLAG_DETACH = (1 << 24), ATA_DFLAG_DETACHED = (1 << 25), |
abdda7331
|
149 |
|
1da177e4c
|
150 151 152 153 154 |
ATA_DEV_UNKNOWN = 0, /* unknown device */ ATA_DEV_ATA = 1, /* ATA device */ ATA_DEV_ATA_UNSUP = 2, /* ATA device (unsupported) */ ATA_DEV_ATAPI = 3, /* ATAPI device */ ATA_DEV_ATAPI_UNSUP = 4, /* ATAPI device (unsupported) */ |
e0a717526
|
155 156 157 158 159 |
ATA_DEV_PMP = 5, /* SATA port multiplier */ ATA_DEV_PMP_UNSUP = 6, /* SATA port multiplier (unsupported) */ ATA_DEV_SEMB = 7, /* SEMB */ ATA_DEV_SEMB_UNSUP = 8, /* SEMB (unsupported) */ ATA_DEV_NONE = 9, /* no device */ |
1da177e4c
|
160 |
|
0c88758b5
|
161 |
/* struct ata_link flags */ |
05944bdf6
|
162 |
ATA_LFLAG_NO_HRST = (1 << 1), /* avoid hardreset */ |
ae791c056
|
163 164 165 166 |
ATA_LFLAG_NO_SRST = (1 << 2), /* avoid softreset */ ATA_LFLAG_ASSUME_ATA = (1 << 3), /* assume ATA class */ ATA_LFLAG_ASSUME_SEMB = (1 << 4), /* assume SEMB class */ ATA_LFLAG_ASSUME_CLASS = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB, |
fd995f703
|
167 |
ATA_LFLAG_NO_RETRY = (1 << 5), /* don't retry this link */ |
f9df58cb2
|
168 |
ATA_LFLAG_DISABLED = (1 << 6), /* link is disabled */ |
18f7ba4c2
|
169 |
ATA_LFLAG_SW_ACTIVITY = (1 << 7), /* keep activity stats */ |
0c88758b5
|
170 |
|
1da177e4c
|
171 |
/* struct ata_port flags */ |
949b38af4
|
172 |
ATA_FLAG_SLAVE_POSS = (1 << 0), /* host supports slave dev */ |
1da177e4c
|
173 |
/* (doesn't imply presence) */ |
949b38af4
|
174 175 176 177 178 179 180 181 |
ATA_FLAG_SATA = (1 << 1), ATA_FLAG_NO_LEGACY = (1 << 2), /* no legacy mode check */ ATA_FLAG_MMIO = (1 << 3), /* use MMIO, not PIO */ ATA_FLAG_SRST = (1 << 4), /* (obsolete) use ATA SRST, not E.D.D. */ ATA_FLAG_SATA_RESET = (1 << 5), /* (obsolete) use COMRESET */ ATA_FLAG_NO_ATAPI = (1 << 6), /* No ATAPI support */ ATA_FLAG_PIO_DMA = (1 << 7), /* PIO cmds via DMA */ ATA_FLAG_PIO_LBA48 = (1 << 8), /* Host DMA engine is LBA28 only */ |
7395acb2c
|
182 183 184 |
ATA_FLAG_PIO_POLLING = (1 << 9), /* use polling PIO if LLD * doesn't handle PIO interrupts */ ATA_FLAG_NCQ = (1 << 10), /* host supports NCQ */ |
7395acb2c
|
185 |
ATA_FLAG_DEBUGMSG = (1 << 13), |
b2a8bbe67
|
186 |
ATA_FLAG_IGN_SIMPLEX = (1 << 15), /* ignore SIMPLEX */ |
f834e49f1
|
187 |
ATA_FLAG_NO_IORDY = (1 << 16), /* controller lacks iordy */ |
3cadbcc09
|
188 |
ATA_FLAG_ACPI_SATA = (1 << 17), /* need native SATA ACPI layout */ |
9f45cbd3f
|
189 |
ATA_FLAG_AN = (1 << 18), /* controller supports AN */ |
e0a717526
|
190 |
ATA_FLAG_PMP = (1 << 19), /* controller supports PMP */ |
ca77329fb
|
191 |
ATA_FLAG_IPM = (1 << 20), /* driver can handle IPM */ |
18f7ba4c2
|
192 193 194 195 |
ATA_FLAG_EM = (1 << 21), /* driver supports enclosure * management */ ATA_FLAG_SW_ACTIVITY = (1 << 22), /* driver supports sw activity * led */ |
949b38af4
|
196 |
|
b51e9e5db
|
197 198 199 200 201 202 203 |
/* The following flag belongs to ap->pflags but is kept in * ap->flags because it's referenced in many LLDs and will be * removed in not-too-distant future. */ ATA_FLAG_DISABLED = (1 << 23), /* port is disabled, ignore it */ /* bits 24:31 of ap->flags are reserved for LLD specific flags */ |
9ec957f20
|
204 |
|
b51e9e5db
|
205 206 207 208 209 210 |
/* struct ata_port pflags */ ATA_PFLAG_EH_PENDING = (1 << 0), /* EH pending */ ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */ ATA_PFLAG_FROZEN = (1 << 2), /* port is frozen */ ATA_PFLAG_RECOVERED = (1 << 3), /* recovery action performed */ ATA_PFLAG_LOADING = (1 << 4), /* boot/loading probe */ |
b51e9e5db
|
211 |
ATA_PFLAG_SCSI_HOTPLUG = (1 << 6), /* SCSI hotplug scheduled */ |
f4d6d0046
|
212 |
ATA_PFLAG_INITIALIZING = (1 << 7), /* being initialized, don't touch */ |
afaa5c373
|
213 |
ATA_PFLAG_RESETTING = (1 << 8), /* reset in progress */ |
ece180d1c
|
214 215 |
ATA_PFLAG_UNLOADING = (1 << 9), /* driver is being unloaded */ ATA_PFLAG_UNLOADED = (1 << 10), /* driver is unloaded */ |
949b38af4
|
216 |
|
b51e9e5db
|
217 |
ATA_PFLAG_SUSPENDED = (1 << 17), /* port is suspended (power) */ |
500530f65
|
218 |
ATA_PFLAG_PM_PENDING = (1 << 18), /* PM operation pending */ |
c05e6ff03
|
219 |
ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */ |
949b38af4
|
220 221 222 |
/* struct ata_queued_cmd flags */ ATA_QCFLAG_ACTIVE = (1 << 0), /* cmd not yet ack'd to scsi lyer */ |
001102d78
|
223 |
ATA_QCFLAG_DMAMAP = (1 << 1), /* SG table is DMA mapped */ |
271973677
|
224 |
ATA_QCFLAG_IO = (1 << 3), /* standard IO command */ |
e61e06722
|
225 |
ATA_QCFLAG_RESULT_TF = (1 << 4), /* result TF requested */ |
da917d69d
|
226 |
ATA_QCFLAG_CLEAR_EXCL = (1 << 5), /* clear excl_link on completion */ |
e027bd36c
|
227 |
ATA_QCFLAG_QUIET = (1 << 6), /* don't report device error */ |
03faab782
|
228 |
ATA_QCFLAG_RETRY = (1 << 7), /* retry after failure */ |
e61e06722
|
229 |
|
9ec957f20
|
230 231 232 |
ATA_QCFLAG_FAILED = (1 << 16), /* cmd failed and is owned by EH */ ATA_QCFLAG_SENSE_VALID = (1 << 17), /* sense data valid */ ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */ |
1da177e4c
|
233 |
|
4e5ec5dba
|
234 |
/* host set flags */ |
cca3974e4
|
235 |
ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host only */ |
ecef72532
|
236 |
ATA_HOST_STARTED = (1 << 1), /* Host started */ |
9bec2e385
|
237 |
|
b8b275efc
|
238 |
/* bits 24:31 of host->flags are reserved for LLD specific flags */ |
1da177e4c
|
239 |
/* various lengths of time */ |
341c2c958
|
240 241 |
ATA_TMOUT_BOOT = 30000, /* heuristic */ ATA_TMOUT_BOOT_QUICK = 7000, /* heuristic */ |
341c2c958
|
242 |
ATA_TMOUT_INTERNAL_QUICK = 5000, |
45fabbb77
|
243 |
ATA_TMOUT_MAX_PARK = 30000, |
1da177e4c
|
244 |
|
88ff6eafb
|
245 246 247 248 249 |
/* FIXME: GoVault needs 2s but we can't afford that without * parallel probing. 800ms is enough for iVDR disk * HHD424020F7SV00. Increase to 2secs when parallel probing * is in place. */ |
341c2c958
|
250 |
ATA_TMOUT_FF_WAIT = 800, |
88ff6eafb
|
251 |
|
705e76beb
|
252 253 254 255 256 257 258 259 260 261 |
/* Spec mandates to wait for ">= 2ms" before checking status * after reset. We wait 150ms, because that was the magic * delay used for ATAPI devices in Hale Landis's ATADRVR, for * the period of time between when the ATA command register is * written, and then status is checked. Because waiting for * "a while" before checking status is fine, post SRST, we * perform this magic delay here as well. * * Old drivers/ide uses the 2mS rule and then waits for ready. */ |
341c2c958
|
262 |
ATA_WAIT_AFTER_RESET = 150, |
705e76beb
|
263 |
|
9dadd45b2
|
264 265 266 267 268 |
/* If PMP is supported, we have to do follow-up SRST. As some * PMPs don't send D2H Reg FIS after hardreset, LLDs are * advised to wait only for the following duration before * doing SRST. */ |
341c2c958
|
269 |
ATA_TMOUT_PMP_SRST_WAIT = 1000, |
9dadd45b2
|
270 |
|
1da177e4c
|
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 |
/* ATA bus states */ BUS_UNKNOWN = 0, BUS_DMA = 1, BUS_IDLE = 2, BUS_NOINTR = 3, BUS_NODATA = 4, BUS_TIMER = 5, BUS_PIO = 6, BUS_EDD = 7, BUS_IDENTIFY = 8, BUS_PACKET = 9, /* SATA port states */ PORT_UNKNOWN = 0, PORT_ENABLED = 1, PORT_DISABLED = 2, /* encoding various smaller bitmaps into a single |
7dc951aef
|
289 |
* unsigned long bitmap |
1da177e4c
|
290 |
*/ |
70cd071e4
|
291 292 293 |
ATA_NR_PIO_MODES = 7, ATA_NR_MWDMA_MODES = 5, ATA_NR_UDMA_MODES = 8, |
1da7b0d01
|
294 295 |
ATA_SHIFT_PIO = 0, |
70cd071e4
|
296 297 |
ATA_SHIFT_MWDMA = ATA_SHIFT_PIO + ATA_NR_PIO_MODES, ATA_SHIFT_UDMA = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES, |
cedc9a478
|
298 299 |
/* size of buffer to pad xfers ending on unaligned boundaries */ ATA_DMA_PAD_SZ = 4, |
949b38af4
|
300 |
|
0c247c559
|
301 302 |
/* ering size */ ATA_ERING_SIZE = 32, |
31cc23b34
|
303 304 305 |
/* return values for ->qc_defer */ ATA_DEFER_LINK = 1, ATA_DEFER_PORT = 2, |
f3e81b19a
|
306 307 |
/* desc_len for ata_eh_info and context */ ATA_EH_DESC_LEN = 80, |
9be1e979f
|
308 309 |
/* reset / recovery action types */ ATA_EH_REVALIDATE = (1 << 0), |
cf4806265
|
310 311 312 |
ATA_EH_SOFTRESET = (1 << 1), /* meaningful only in ->prereset */ ATA_EH_HARDRESET = (1 << 2), /* meaningful only in ->prereset */ ATA_EH_RESET = ATA_EH_SOFTRESET | ATA_EH_HARDRESET, |
f9df58cb2
|
313 |
ATA_EH_ENABLE_LINK = (1 << 3), |
3ec25ebd6
|
314 |
ATA_EH_LPM = (1 << 4), /* link power management action */ |
45fabbb77
|
315 |
ATA_EH_PARK = (1 << 5), /* unload heads and stop I/O */ |
9be1e979f
|
316 |
|
45fabbb77
|
317 |
ATA_EH_PERDEV_MASK = ATA_EH_REVALIDATE | ATA_EH_PARK, |
b5b3fa386
|
318 319 |
ATA_EH_ALL_ACTIONS = ATA_EH_REVALIDATE | ATA_EH_RESET | ATA_EH_ENABLE_LINK | ATA_EH_LPM, |
9be1e979f
|
320 |
|
f3e81b19a
|
321 |
/* ata_eh_info->flags */ |
abdda7331
|
322 |
ATA_EHI_HOTPLUGGED = (1 << 0), /* could have been hotplugged */ |
1cdaf534f
|
323 324 |
ATA_EHI_NO_AUTOPSY = (1 << 2), /* no autopsy */ ATA_EHI_QUIET = (1 << 3), /* be quiet */ |
abdda7331
|
325 |
|
0d64a233f
|
326 327 328 329 330 |
ATA_EHI_DID_SOFTRESET = (1 << 16), /* already soft-reset this port */ ATA_EHI_DID_HARDRESET = (1 << 17), /* already soft-reset this port */ ATA_EHI_PRINTINFO = (1 << 18), /* print configuration info */ ATA_EHI_SETMODE = (1 << 19), /* configure transfer mode */ ATA_EHI_POST_SETMODE = (1 << 20), /* revaildating after setmode */ |
f3e81b19a
|
331 |
|
0d64a233f
|
332 |
ATA_EHI_DID_RESET = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET, |
13abf50df
|
333 |
|
848e4c68c
|
334 335 |
/* mask of flags to transfer *to* the slave link */ ATA_EHI_TO_SLAVE_MASK = ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, |
a1e10f7e6
|
336 337 |
/* max tries if error condition is still set after ->error_handler */ ATA_EH_MAX_TRIES = 5, |
ad9e27624
|
338 |
|
14d2bac18
|
339 340 |
/* how hard are we gonna try to probe/recover devices */ ATA_PROBE_MAX_TRIES = 3, |
022bdb075
|
341 |
ATA_EH_DEV_TRIES = 3, |
e0a717526
|
342 343 |
ATA_EH_PMP_TRIES = 5, ATA_EH_PMP_LINK_TRIES = 3, |
bf1bff6fa
|
344 |
SATA_PMP_RW_TIMEOUT = 3000, /* PMP read/write timeout */ |
f5914a461
|
345 |
|
87fbc5a06
|
346 347 348 349 |
/* This should match the actual table size of * ata_eh_cmd_timeout_table in libata-eh.c. */ ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 5, |
935908598
|
350 351 352 353 |
/* Horkage types. May be set by libata or controller on drives (some horkage may be drive/controller pair dependant */ ATA_HORKAGE_DIAGNOSTIC = (1 << 0), /* Failed boot diag */ |
6919a0a6c
|
354 355 |
ATA_HORKAGE_NODMA = (1 << 1), /* DMA problems */ ATA_HORKAGE_NONCQ = (1 << 2), /* Don't use NCQ */ |
18d6e9d51
|
356 |
ATA_HORKAGE_MAX_SEC_128 = (1 << 3), /* Limit max sects to 128 */ |
16c55b038
|
357 |
ATA_HORKAGE_BROKEN_HPA = (1 << 4), /* Broken HPA */ |
50af2fa1e
|
358 |
ATA_HORKAGE_DISABLE = (1 << 5), /* Disable it */ |
93328e114
|
359 |
ATA_HORKAGE_HPA_SIZE = (1 << 6), /* native size off by one */ |
ca77329fb
|
360 |
ATA_HORKAGE_IPM = (1 << 7), /* Link PM problems */ |
6bbfd53d4
|
361 |
ATA_HORKAGE_IVB = (1 << 8), /* cbl det validity bit bugs */ |
2d3b8eea7
|
362 |
ATA_HORKAGE_STUCK_ERR = (1 << 9), /* stuck ERR on next PACKET */ |
9ce8e3073
|
363 |
ATA_HORKAGE_BRIDGE_OK = (1 << 10), /* no bridge limits */ |
6a87e42e9
|
364 365 |
ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands not multiple of 16 bytes */ |
ac70a964b
|
366 |
ATA_HORKAGE_FIRMWARE_WARN = (1 << 12), /* firwmare update warning */ |
b3a706014
|
367 |
|
2dcb407e6
|
368 |
/* DMA mask for user DMA control: User visible values; DO NOT |
b3a706014
|
369 370 371 372 |
renumber */ ATA_DMA_MASK_ATA = (1 << 0), /* DMA on ATA Disk */ ATA_DMA_MASK_ATAPI = (1 << 1), /* DMA on ATAPI */ ATA_DMA_MASK_CFA = (1 << 2), /* DMA on CF Card */ |
ceb0c6426
|
373 374 375 376 377 |
/* ATAPI command types */ ATAPI_READ = 0, /* READs */ ATAPI_WRITE = 1, /* WRITEs */ ATAPI_READ_CD = 2, /* READ CD [MSF] */ |
e52dcc489
|
378 379 |
ATAPI_PASS_THRU = 3, /* SAT pass-thru */ ATAPI_MISC = 4, /* the rest */ |
624d5c514
|
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 |
/* Timing constants */ ATA_TIMING_SETUP = (1 << 0), ATA_TIMING_ACT8B = (1 << 1), ATA_TIMING_REC8B = (1 << 2), ATA_TIMING_CYC8B = (1 << 3), ATA_TIMING_8BIT = ATA_TIMING_ACT8B | ATA_TIMING_REC8B | ATA_TIMING_CYC8B, ATA_TIMING_ACTIVE = (1 << 4), ATA_TIMING_RECOVER = (1 << 5), ATA_TIMING_CYCLE = (1 << 6), ATA_TIMING_UDMA = (1 << 7), ATA_TIMING_ALL = ATA_TIMING_SETUP | ATA_TIMING_ACT8B | ATA_TIMING_REC8B | ATA_TIMING_CYC8B | ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER | ATA_TIMING_CYCLE | ATA_TIMING_UDMA, |
1da177e4c
|
396 |
}; |
7dc951aef
|
397 398 399 400 401 402 403 404 |
enum ata_xfer_mask { ATA_MASK_PIO = ((1LU << ATA_NR_PIO_MODES) - 1) << ATA_SHIFT_PIO, ATA_MASK_MWDMA = ((1LU << ATA_NR_MWDMA_MODES) - 1) << ATA_SHIFT_MWDMA, ATA_MASK_UDMA = ((1LU << ATA_NR_UDMA_MODES) - 1) << ATA_SHIFT_UDMA, }; |
14be71f4c
|
405 |
enum hsm_task_states { |
c56b14d2a
|
406 |
HSM_ST_IDLE, /* no command on going */ |
715276470
|
407 408 |
HSM_ST_FIRST, /* (waiting the device to) write CDB or first data block */ |
c56b14d2a
|
409 410 |
HSM_ST, /* (waiting the device to) transfer data */ HSM_ST_LAST, /* (waiting the device to) complete command */ |
c56b14d2a
|
411 |
HSM_ST_ERR, /* error */ |
1da177e4c
|
412 |
}; |
a7dac447b
|
413 |
enum ata_completion_errors { |
11a56d243
|
414 415 416 417 418 419 420 421 422 |
AC_ERR_DEV = (1 << 0), /* device reported error */ AC_ERR_HSM = (1 << 1), /* host state machine violation */ AC_ERR_TIMEOUT = (1 << 2), /* timeout */ AC_ERR_MEDIA = (1 << 3), /* media error */ AC_ERR_ATA_BUS = (1 << 4), /* ATA bus error */ AC_ERR_HOST_BUS = (1 << 5), /* host bus error */ AC_ERR_SYSTEM = (1 << 6), /* system error */ AC_ERR_INVALID = (1 << 7), /* invalid argument */ AC_ERR_OTHER = (1 << 8), /* unknown */ |
55a8e2c83
|
423 |
AC_ERR_NODEV_HINT = (1 << 9), /* polling device detection hint */ |
5335b7290
|
424 |
AC_ERR_NCQ = (1 << 10), /* marker for offending NCQ qc */ |
a7dac447b
|
425 |
}; |
1da177e4c
|
426 427 428 429 |
/* forward declarations */ struct scsi_device; struct ata_port_operations; struct ata_port; |
cc0680a58
|
430 |
struct ata_link; |
1da177e4c
|
431 432 433 |
struct ata_queued_cmd; /* typedefs */ |
77853bf2b
|
434 |
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc); |
cc0680a58
|
435 436 |
typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline); typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes, |
d4b2bab4f
|
437 |
unsigned long deadline); |
cc0680a58
|
438 |
typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes); |
1da177e4c
|
439 |
|
ca77329fb
|
440 441 442 443 444 445 446 447 448 449 |
/* * host pm policy: If you alter this, you also need to alter libata-scsi.c * (for the ascii descriptions) */ enum link_pm { NOT_AVAILABLE, MIN_POWER, MAX_PERFORMANCE, MEDIUM_POWER, }; |
ee959b00c
|
450 |
extern struct device_attribute dev_attr_link_power_management_policy; |
45fabbb77
|
451 |
extern struct device_attribute dev_attr_unload_heads; |
18f7ba4c2
|
452 453 454 455 456 457 458 459 460 |
extern struct device_attribute dev_attr_em_message_type; extern struct device_attribute dev_attr_em_message; extern struct device_attribute dev_attr_sw_activity; enum sw_activity { OFF, BLINK_ON, BLINK_OFF, }; |
ca77329fb
|
461 |
|
127102aea
|
462 |
#ifdef CONFIG_ATA_SFF |
1da177e4c
|
463 |
struct ata_ioports { |
0d5ff5667
|
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 |
void __iomem *cmd_addr; void __iomem *data_addr; void __iomem *error_addr; void __iomem *feature_addr; void __iomem *nsect_addr; void __iomem *lbal_addr; void __iomem *lbam_addr; void __iomem *lbah_addr; void __iomem *device_addr; void __iomem *status_addr; void __iomem *command_addr; void __iomem *altstatus_addr; void __iomem *ctl_addr; void __iomem *bmdma_addr; void __iomem *scr_addr; |
1da177e4c
|
479 |
}; |
127102aea
|
480 |
#endif /* CONFIG_ATA_SFF */ |
1da177e4c
|
481 |
|
cca3974e4
|
482 |
struct ata_host { |
1da177e4c
|
483 484 |
spinlock_t lock; struct device *dev; |
0d5ff5667
|
485 |
void __iomem * const *iomap; |
1da177e4c
|
486 487 |
unsigned int n_ports; void *private_data; |
029cfd6b7
|
488 |
struct ata_port_operations *ops; |
5444a6f40
|
489 |
unsigned long flags; |
fafbae87d
|
490 491 492 |
#ifdef CONFIG_ATA_ACPI acpi_handle acpi_handle; #endif |
032af1ce1
|
493 |
struct ata_port *simplex_claimed; /* channel owning the DMA */ |
f0eb62b81
|
494 |
struct ata_port *ports[0]; |
1da177e4c
|
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 |
}; struct ata_queued_cmd { struct ata_port *ap; struct ata_device *dev; struct scsi_cmnd *scsicmd; void (*scsidone)(struct scsi_cmnd *); struct ata_taskfile tf; u8 cdb[ATAPI_CDB_LEN]; unsigned long flags; /* ATA_QCFLAG_xxx */ unsigned int tag; unsigned int n_elem; int dma_dir; |
5a5dbd18a
|
512 |
unsigned int sect_size; |
cedc9a478
|
513 |
|
1da177e4c
|
514 |
unsigned int nbytes; |
aacda3753
|
515 |
unsigned int extrabytes; |
1da177e4c
|
516 |
unsigned int curbytes; |
872602162
|
517 |
struct scatterlist *cursg; |
1da177e4c
|
518 519 520 |
unsigned int cursg_ofs; struct scatterlist sgent; |
1da177e4c
|
521 |
|
ff2aeb1eb
|
522 |
struct scatterlist *sg; |
1da177e4c
|
523 |
|
a22e2eb07
|
524 |
unsigned int err_mask; |
e61e06722
|
525 |
struct ata_taskfile result_tf; |
1da177e4c
|
526 |
ata_qc_cb_t complete_fn; |
1da177e4c
|
527 |
void *private_data; |
1c50dc83f
|
528 |
void *lldd_task; |
1da177e4c
|
529 |
}; |
cca3974e4
|
530 |
struct ata_port_stats { |
1da177e4c
|
531 532 533 534 |
unsigned long unhandled_irq; unsigned long idle_irq; unsigned long rw_reqbuf; }; |
0c247c559
|
535 |
struct ata_ering_entry { |
3884f7b0a
|
536 |
unsigned int eflags; |
0c247c559
|
537 538 539 540 541 542 543 544 |
unsigned int err_mask; u64 timestamp; }; struct ata_ering { int cursor; struct ata_ering_entry ring[ATA_ERING_SIZE]; }; |
1da177e4c
|
545 |
struct ata_device { |
9af5c9c97
|
546 |
struct ata_link *link; |
72fa4b742
|
547 |
unsigned int devno; /* 0 or 1 */ |
75683fe71
|
548 |
unsigned int horkage; /* List of broken features */ |
6866e7bc8
|
549 |
unsigned long flags; /* ATA_DFLAG_xxx */ |
3edebac41
|
550 |
struct scsi_device *sdev; /* attached SCSI device */ |
fafbae87d
|
551 552 |
#ifdef CONFIG_ATA_ACPI acpi_handle acpi_handle; |
398e07826
|
553 |
union acpi_object *gtf_cache; |
fafbae87d
|
554 |
#endif |
72fa4b742
|
555 556 |
/* n_sector is used as CLEAR_OFFSET, read comment above CLEAR_OFFSET */ u64 n_sectors; /* size of device, if ATA */ |
1da177e4c
|
557 |
unsigned int class; /* ATA_DEV_xxx */ |
45fabbb77
|
558 |
unsigned long unpark_deadline; |
e0a717526
|
559 |
|
1da177e4c
|
560 561 562 563 |
u8 pio_mode; u8 dma_mode; u8 xfer_mode; unsigned int xfer_shift; /* ATA_SHIFT_xxx */ |
8cbd6df1f
|
564 565 |
unsigned int multi_count; /* sectors count for READ/WRITE MULTIPLE */ |
b00eec1d5
|
566 |
unsigned int max_sectors; /* per-device max sectors */ |
6e7846e9c
|
567 |
unsigned int cdb_len; |
8bf62ecee
|
568 |
|
acf356b12
|
569 |
/* per-dev xfer mask */ |
7dc951aef
|
570 571 572 |
unsigned long pio_mask; unsigned long mwdma_mask; unsigned long udma_mask; |
acf356b12
|
573 |
|
8bf62ecee
|
574 575 576 577 |
/* for CHS addressing */ u16 cylinders; /* Number of cylinders */ u16 heads; /* Number of heads */ u16 sectors; /* Number of sectors per track */ |
0c247c559
|
578 579 |
/* error history */ |
7d47e8d4d
|
580 |
int spdn_cnt; |
f7e989301
|
581 582 583 584 585 586 |
struct ata_ering ering; union { u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */ u32 gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */ }; |
1da177e4c
|
587 |
}; |
72fa4b742
|
588 589 590 591 |
/* Offset into struct ata_device. Fields above it are maintained * acress device init. Fields below are zeroed. */ #define ATA_DEVICE_CLEAR_OFFSET offsetof(struct ata_device, n_sectors) |
f3e81b19a
|
592 593 594 595 596 |
struct ata_eh_info { struct ata_device *dev; /* offending device */ u32 serror; /* SError from LLDD */ unsigned int err_mask; /* port-wide err_mask */ unsigned int action; /* ATA_EH_* action mask */ |
47005f255
|
597 |
unsigned int dev_action[ATA_MAX_DEVICES]; /* dev EH action */ |
f3e81b19a
|
598 |
unsigned int flags; /* ATA_EHI_* flags */ |
abdda7331
|
599 |
|
abdda7331
|
600 |
unsigned int probe_mask; |
f3e81b19a
|
601 602 603 604 605 606 607 |
char desc[ATA_EH_DESC_LEN]; int desc_len; }; struct ata_eh_context { struct ata_eh_info i; int tries[ATA_MAX_DEVICES]; |
87fbc5a06
|
608 609 |
int cmd_timeout_idx[ATA_MAX_DEVICES] [ATA_EH_CMD_TIMEOUT_TABLE_SIZE]; |
abdda7331
|
610 611 |
unsigned int classes[ATA_MAX_DEVICES]; unsigned int did_probe_mask; |
45fabbb77
|
612 |
unsigned int unloaded_mask; |
00115e0f5
|
613 614 |
unsigned int saved_ncq_enabled; u8 saved_xfer_mode[ATA_MAX_DEVICES]; |
0a2c0f561
|
615 616 |
/* timestamp for the last reset attempt or success */ unsigned long last_reset; |
f3e81b19a
|
617 |
}; |
64578a3de
|
618 619 620 621 622 623 624 625 626 627 |
struct ata_acpi_drive { u32 pio; u32 dma; } __packed; struct ata_acpi_gtm { struct ata_acpi_drive drive[2]; u32 flags; } __packed; |
9af5c9c97
|
628 629 |
struct ata_link { struct ata_port *ap; |
8989805d6
|
630 |
int pmp; /* port multiplier port # */ |
9af5c9c97
|
631 632 633 |
unsigned int active_tag; /* active tag on this link */ u32 sactive; /* active NCQ commands */ |
0c88758b5
|
634 |
unsigned int flags; /* ATA_LFLAG_xxx */ |
d127ea7b8
|
635 |
u32 saved_scontrol; /* SControl on probe */ |
9af5c9c97
|
636 637 638 639 640 641 642 643 644 645 646 |
unsigned int hw_sata_spd_limit; unsigned int sata_spd_limit; unsigned int sata_spd; /* current SATA PHY speed */ /* record runtime error info, protected by host_set lock */ struct ata_eh_info eh_info; /* EH context */ struct ata_eh_context eh_context; struct ata_device device[ATA_MAX_DEVICES]; }; |
1da177e4c
|
647 |
struct ata_port { |
cca3974e4
|
648 |
struct Scsi_Host *scsi_host; /* our co-allocated scsi host */ |
029cfd6b7
|
649 |
struct ata_port_operations *ops; |
ba6a13083
|
650 |
spinlock_t *lock; |
1da177e4c
|
651 |
unsigned long flags; /* ATA_FLAG_xxx */ |
b51e9e5db
|
652 |
unsigned int pflags; /* ATA_PFLAG_xxx */ |
44877b4e2
|
653 654 |
unsigned int print_id; /* user visible unique port ID */ unsigned int port_no; /* 0 based port no. inside the host */ |
1da177e4c
|
655 656 657 |
struct ata_prd *prd; /* our SG list */ dma_addr_t prd_dma; /* and its DMA mapping */ |
127102aea
|
658 |
#ifdef CONFIG_ATA_SFF |
1da177e4c
|
659 |
struct ata_ioports ioaddr; /* ATA cmd/ctl/dma register blocks */ |
127102aea
|
660 |
#endif /* CONFIG_ATA_SFF */ |
1da177e4c
|
661 662 663 |
u8 ctl; /* cache of ATA control register */ u8 last_ctl; /* Cache last written value */ |
1da177e4c
|
664 665 666 667 |
unsigned int pio_mask; unsigned int mwdma_mask; unsigned int udma_mask; unsigned int cbl; /* cable type; ATA_CBL_xxx */ |
1da177e4c
|
668 669 |
struct ata_queued_cmd qcmd[ATA_MAX_QUEUE]; |
8a8bc2233
|
670 |
unsigned long qc_allocated; |
dedaf2b03
|
671 |
unsigned int qc_active; |
da917d69d
|
672 |
int nr_active_links; /* #links with active qcs */ |
dedaf2b03
|
673 |
|
b1c72916a
|
674 675 |
struct ata_link link; /* host default link */ struct ata_link *slave_link; /* see ata_slave_link_init() */ |
1da177e4c
|
676 |
|
8989805d6
|
677 678 |
int nr_pmp_links; /* nr of available PMP links */ struct ata_link *pmp_link; /* array of PMP links */ |
da917d69d
|
679 |
struct ata_link *excl_link; /* for PMP qc exclusion */ |
8989805d6
|
680 |
|
cca3974e4
|
681 682 |
struct ata_port_stats stats; struct ata_host *host; |
2f1f610b6
|
683 |
struct device *dev; |
1da177e4c
|
684 |
|
65f27f384
|
685 |
void *port_task_data; |
52bad64d9
|
686 687 |
struct delayed_work port_task; struct delayed_work hotplug_task; |
3b01b8af2
|
688 |
struct work_struct scsi_rescan_task; |
86e45b6bd
|
689 |
|
14be71f4c
|
690 |
unsigned int hsm_task_state; |
1da177e4c
|
691 |
|
bfd605795
|
692 |
u32 msg_enable; |
a72ec4ce6
|
693 |
struct list_head eh_done_q; |
c6cf9e99d
|
694 |
wait_queue_head_t eh_wait_q; |
a1e10f7e6
|
695 |
int eh_tries; |
45fabbb77
|
696 |
struct completion park_req_pending; |
bfd605795
|
697 |
|
500530f65
|
698 699 |
pm_message_t pm_mesg; int *pm_result; |
ca77329fb
|
700 |
enum link_pm pm_policy; |
500530f65
|
701 |
|
5ddf24c5e
|
702 703 |
struct timer_list fastdrain_timer; unsigned long fastdrain_cnt; |
18f7ba4c2
|
704 |
int em_message_type; |
1da177e4c
|
705 |
void *private_data; |
fe635c7e9
|
706 |
|
fafbae87d
|
707 708 |
#ifdef CONFIG_ATA_ACPI acpi_handle acpi_handle; |
c05e6ff03
|
709 |
struct ata_acpi_gtm __acpi_init_gtm; /* use ata_acpi_init_gtm() */ |
fafbae87d
|
710 |
#endif |
fe635c7e9
|
711 |
u8 sector_buf[ATA_SECT_SIZE]; /* owned by EH */ |
1da177e4c
|
712 |
}; |
029cfd6b7
|
713 714 715 716 717 718 |
/* The following initializer overrides a method to NULL whether one of * its parent has the method defined or not. This is equivalent to * ERR_PTR(-ENOENT). Unfortunately, ERR_PTR doesn't render a constant * expression and thus can't be used as an initializer. */ #define ATA_OP_NULL (void *)(unsigned long)(-ENOENT) |
1da177e4c
|
719 |
struct ata_port_operations { |
c1bc899f5
|
720 721 722 723 724 725 726 |
/* * Command execution */ int (*qc_defer)(struct ata_queued_cmd *qc); int (*check_atapi_dma)(struct ata_queued_cmd *qc); void (*qc_prep)(struct ata_queued_cmd *qc); unsigned int (*qc_issue)(struct ata_queued_cmd *qc); |
22183bf56
|
727 |
bool (*qc_fill_rtf)(struct ata_queued_cmd *qc); |
1da177e4c
|
728 |
|
c1bc899f5
|
729 730 731 732 733 734 735 736 |
/* * Configuration and exception handling */ int (*cable_detect)(struct ata_port *ap); unsigned long (*mode_filter)(struct ata_device *dev, unsigned long xfer_mask); void (*set_piomode)(struct ata_port *ap, struct ata_device *dev); void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev); int (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev); |
963e4975c
|
737 |
unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16 *id); |
1da177e4c
|
738 |
|
c1bc899f5
|
739 |
void (*dev_config)(struct ata_device *dev); |
1da177e4c
|
740 |
|
c1bc899f5
|
741 742 |
void (*freeze)(struct ata_port *ap); void (*thaw)(struct ata_port *ap); |
a1efdaba2
|
743 744 745 746 747 748 749 750 |
ata_prereset_fn_t prereset; ata_reset_fn_t softreset; ata_reset_fn_t hardreset; ata_postreset_fn_t postreset; ata_prereset_fn_t pmp_prereset; ata_reset_fn_t pmp_softreset; ata_reset_fn_t pmp_hardreset; ata_postreset_fn_t pmp_postreset; |
c1bc899f5
|
751 752 753 754 755 756 |
void (*error_handler)(struct ata_port *ap); void (*post_internal_cmd)(struct ata_queued_cmd *qc); /* * Optional features */ |
82ef04fb4
|
757 758 |
int (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val); int (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val); |
c1bc899f5
|
759 760 761 762 763 764 765 766 767 768 769 770 771 |
void (*pmp_attach)(struct ata_port *ap); void (*pmp_detach)(struct ata_port *ap); int (*enable_pm)(struct ata_port *ap, enum link_pm policy); void (*disable_pm)(struct ata_port *ap); /* * Start, stop, suspend and resume */ int (*port_suspend)(struct ata_port *ap, pm_message_t mesg); int (*port_resume)(struct ata_port *ap); int (*port_start)(struct ata_port *ap); void (*port_stop)(struct ata_port *ap); void (*host_stop)(struct ata_host *host); |
127102aea
|
772 |
#ifdef CONFIG_ATA_SFF |
c1bc899f5
|
773 774 775 |
/* * SFF / taskfile oriented ops */ |
5682ed33a
|
776 777 778 779 780 781 782 783 784 785 786 |
void (*sff_dev_select)(struct ata_port *ap, unsigned int device); u8 (*sff_check_status)(struct ata_port *ap); u8 (*sff_check_altstatus)(struct ata_port *ap); void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf); void (*sff_tf_read)(struct ata_port *ap, struct ata_taskfile *tf); void (*sff_exec_command)(struct ata_port *ap, const struct ata_taskfile *tf); unsigned int (*sff_data_xfer)(struct ata_device *dev, unsigned char *buf, unsigned int buflen, int rw); u8 (*sff_irq_on)(struct ata_port *); void (*sff_irq_clear)(struct ata_port *); |
c1bc899f5
|
787 788 789 790 |
void (*bmdma_setup)(struct ata_queued_cmd *qc); void (*bmdma_start)(struct ata_queued_cmd *qc); void (*bmdma_stop)(struct ata_queued_cmd *qc); u8 (*bmdma_status)(struct ata_port *ap); |
127102aea
|
791 |
#endif /* CONFIG_ATA_SFF */ |
c1bc899f5
|
792 |
|
18f7ba4c2
|
793 794 795 796 797 798 |
ssize_t (*em_show)(struct ata_port *ap, char *buf); ssize_t (*em_store)(struct ata_port *ap, const char *message, size_t size); ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf); ssize_t (*sw_activity_store)(struct ata_device *dev, enum sw_activity val); |
c1bc899f5
|
799 800 |
/* * Obsolete |
9ec957f20
|
801 |
*/ |
c1bc899f5
|
802 803 |
void (*phy_reset)(struct ata_port *ap); void (*eng_timeout)(struct ata_port *ap); |
029cfd6b7
|
804 805 806 807 808 809 |
/* * ->inherits must be the last field and all the preceding * fields must be pointers. */ const struct ata_port_operations *inherits; |
1da177e4c
|
810 811 812 |
}; struct ata_port_info { |
cca3974e4
|
813 |
unsigned long flags; |
0c88758b5
|
814 |
unsigned long link_flags; |
1da177e4c
|
815 816 817 |
unsigned long pio_mask; unsigned long mwdma_mask; unsigned long udma_mask; |
029cfd6b7
|
818 |
struct ata_port_operations *port_ops; |
e99f8b5ef
|
819 |
void *private_data; |
1da177e4c
|
820 |
}; |
452503f99
|
821 822 823 824 825 826 827 828 829 830 831 |
struct ata_timing { unsigned short mode; /* ATA mode */ unsigned short setup; /* t1 */ unsigned short act8b; /* t2 for 8-bit I/O */ unsigned short rec8b; /* t2i for 8-bit I/O */ unsigned short cyc8b; /* t0 for 8-bit I/O */ unsigned short active; /* t2 or tD */ unsigned short recover; /* t2i or tK */ unsigned short cycle; /* t0 */ unsigned short udma; /* t2CYCTYP/2 */ }; |
624d5c514
|
832 833 834 |
/* * Core layer - drivers/ata/libata-core.c */ |
e9c839142
|
835 836 837 |
extern const unsigned long sata_deb_timing_normal[]; extern const unsigned long sata_deb_timing_hotplug[]; extern const unsigned long sata_deb_timing_long[]; |
029cfd6b7
|
838 |
extern struct ata_port_operations ata_dummy_port_ops; |
21b0ad4fb
|
839 |
extern const struct ata_port_info ata_dummy_port_info; |
dd5b06c49
|
840 |
|
e9c839142
|
841 842 843 844 845 846 847 848 |
static inline const unsigned long * sata_ehc_deb_timing(struct ata_eh_context *ehc) { if (ehc->i.flags & ATA_EHI_HOTPLUGGED) return sata_deb_timing_hotplug; else return sata_deb_timing_normal; } |
d7bb4cc75
|
849 |
|
dd5b06c49
|
850 851 852 853 |
static inline int ata_port_is_dummy(struct ata_port *ap) { return ap->ops == &ata_dummy_port_ops; } |
1da177e4c
|
854 |
extern void ata_port_probe(struct ata_port *); |
936fd7328
|
855 |
extern int sata_set_spd(struct ata_link *link); |
0aa1113d5
|
856 |
extern int ata_std_prereset(struct ata_link *link, unsigned long deadline); |
aa2731ad9
|
857 858 |
extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline, int (*check_ready)(struct ata_link *link)); |
936fd7328
|
859 860 861 862 |
extern int sata_link_debounce(struct ata_link *link, const unsigned long *params, unsigned long deadline); extern int sata_link_resume(struct ata_link *link, const unsigned long *params, unsigned long deadline); |
cc0680a58
|
863 |
extern int sata_link_hardreset(struct ata_link *link, |
9dadd45b2
|
864 865 |
const unsigned long *timing, unsigned long deadline, bool *online, int (*check_ready)(struct ata_link *)); |
57c9efdfb
|
866 867 |
extern int sata_std_hardreset(struct ata_link *link, unsigned int *class, unsigned long deadline); |
203c75b82
|
868 |
extern void ata_std_postreset(struct ata_link *link, unsigned int *classes); |
1da177e4c
|
869 |
extern void ata_port_disable(struct ata_port *); |
2855568b1
|
870 |
|
f31871951
|
871 |
extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports); |
f5cda2572
|
872 873 |
extern struct ata_host *ata_host_alloc_pinfo(struct device *dev, const struct ata_port_info * const * ppi, int n_ports); |
b1c72916a
|
874 |
extern int ata_slave_link_init(struct ata_port *ap); |
ecef72532
|
875 |
extern int ata_host_start(struct ata_host *host); |
f31871951
|
876 877 |
extern int ata_host_register(struct ata_host *host, struct scsi_host_template *sht); |
f5cda2572
|
878 879 880 |
extern int ata_host_activate(struct ata_host *host, int irq, irq_handler_t irq_handler, unsigned long irq_flags, struct scsi_host_template *sht); |
0529c159d
|
881 |
extern void ata_host_detach(struct ata_host *host); |
cca3974e4
|
882 |
extern void ata_host_init(struct ata_host *, struct device *, |
029cfd6b7
|
883 |
unsigned long, struct ata_port_operations *); |
193515d51
|
884 |
extern int ata_scsi_detect(struct scsi_host_template *sht); |
1da177e4c
|
885 886 |
extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg); extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)); |
80289167f
|
887 |
extern void ata_sas_port_destroy(struct ata_port *); |
cca3974e4
|
888 |
extern struct ata_port *ata_sas_port_alloc(struct ata_host *, |
80289167f
|
889 890 891 892 893 894 895 |
struct ata_port_info *, struct Scsi_Host *); extern int ata_sas_port_init(struct ata_port *); extern int ata_sas_port_start(struct ata_port *ap); extern void ata_sas_port_stop(struct ata_port *ap); extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *); extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), struct ata_port *ap); |
936fd7328
|
896 897 898 899 |
extern int sata_scr_valid(struct ata_link *link); extern int sata_scr_read(struct ata_link *link, int reg, u32 *val); extern int sata_scr_write(struct ata_link *link, int reg, u32 val); extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val); |
b5b3fa386
|
900 901 |
extern bool ata_link_online(struct ata_link *link); extern bool ata_link_offline(struct ata_link *link); |
6ffa01d88
|
902 |
#ifdef CONFIG_PM |
cca3974e4
|
903 904 |
extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg); extern void ata_host_resume(struct ata_host *host); |
6ffa01d88
|
905 |
#endif |
67846b301
|
906 |
extern int ata_ratelimit(void); |
c22daff41
|
907 |
extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val, |
341c2c958
|
908 |
unsigned long interval, unsigned long timeout); |
436d34b36
|
909 |
extern int atapi_cmd_type(u8 opcode); |
9977126c4
|
910 911 |
extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis); |
057ace5e7
|
912 |
extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf); |
7dc951aef
|
913 914 915 916 917 918 919 920 921 922 |
extern unsigned long ata_pack_xfermask(unsigned long pio_mask, unsigned long mwdma_mask, unsigned long udma_mask); extern void ata_unpack_xfermask(unsigned long xfer_mask, unsigned long *pio_mask, unsigned long *mwdma_mask, unsigned long *udma_mask); extern u8 ata_xfer_mask2mode(unsigned long xfer_mask); extern unsigned long ata_xfer_mode2mask(u8 xfer_mode); extern int ata_xfer_mode2shift(unsigned long xfer_mode); extern const char *ata_mode_string(unsigned long xfer_mask); extern unsigned long ata_id_xfermask(const u16 *id); |
2dcb407e6
|
923 |
extern int ata_port_start(struct ata_port *ap); |
31cc23b34
|
924 |
extern int ata_std_qc_defer(struct ata_queued_cmd *qc); |
e46834cd2
|
925 |
extern void ata_noop_qc_prep(struct ata_queued_cmd *qc); |
1da177e4c
|
926 927 |
extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg, unsigned int n_elem); |
057ace5e7
|
928 |
extern unsigned int ata_dev_classify(const struct ata_taskfile *tf); |
10305f0f8
|
929 |
extern void ata_dev_disable(struct ata_device *adev); |
6a62a04d4
|
930 931 932 933 |
extern void ata_id_string(const u16 *id, unsigned char *s, unsigned int ofs, unsigned int len); extern void ata_id_c_string(const u16 *id, unsigned char *s, unsigned int ofs, unsigned int len); |
963e4975c
|
934 935 |
extern unsigned int ata_do_dev_read_id(struct ata_device *dev, struct ata_taskfile *tf, u16 *id); |
f686bcb80
|
936 |
extern void ata_qc_complete(struct ata_queued_cmd *qc); |
79f97dadf
|
937 |
extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active); |
3373efd89
|
938 |
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd, |
1da177e4c
|
939 940 941 942 943 |
void (*done)(struct scsi_cmnd *)); extern int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[]); extern int ata_scsi_slave_config(struct scsi_device *sdev); |
83c47bcb3
|
944 |
extern void ata_scsi_slave_destroy(struct scsi_device *sdev); |
a6e6ce8e8
|
945 946 |
extern int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth); |
3373efd89
|
947 |
extern struct ata_device *ata_dev_pair(struct ata_device *adev); |
0260731f0
|
948 |
extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev); |
1da177e4c
|
949 |
|
be0d18dff
|
950 951 952 |
extern int ata_cable_40wire(struct ata_port *ap); extern int ata_cable_80wire(struct ata_port *ap); extern int ata_cable_sata(struct ata_port *ap); |
c88f90c37
|
953 |
extern int ata_cable_ignore(struct ata_port *ap); |
be0d18dff
|
954 |
extern int ata_cable_unknown(struct ata_port *ap); |
624d5c514
|
955 |
/* Timing helpers */ |
1bc4ccfff
|
956 |
extern unsigned int ata_pio_need_iordy(const struct ata_device *); |
6357357ca
|
957 |
extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode); |
452503f99
|
958 959 960 961 962 |
extern int ata_timing_compute(struct ata_device *, unsigned short, struct ata_timing *, int, int); extern void ata_timing_merge(const struct ata_timing *, const struct ata_timing *, struct ata_timing *, unsigned int); |
a0f79b929
|
963 |
extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle); |
452503f99
|
964 |
|
624d5c514
|
965 966 967 968 969 970 971 972 973 |
/* PCI */ #ifdef CONFIG_PCI struct pci_dev; struct pci_bits { unsigned int reg; /* PCI config register to read */ unsigned int width; /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */ unsigned long mask; unsigned long val; |
452503f99
|
974 |
}; |
624d5c514
|
975 976 977 978 979 980 981 982 983 984 985 986 987 988 |
extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits); extern void ata_pci_remove_one(struct pci_dev *pdev); #ifdef CONFIG_PM extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg); extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev); extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg); extern int ata_pci_device_resume(struct pci_dev *pdev); #endif /* CONFIG_PM */ #endif /* CONFIG_PCI */ /* * ACPI - drivers/ata/libata-acpi.c */ |
e1ddb4b6a
|
989 |
#ifdef CONFIG_ATA_ACPI |
c05e6ff03
|
990 991 992 993 994 995 |
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap) { if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID) return &ap->__acpi_init_gtm; return NULL; } |
0d02f0b22
|
996 997 |
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm); int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm); |
7c77fa4d5
|
998 999 |
unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev, const struct ata_acpi_gtm *gtm); |
021ee9a6d
|
1000 |
int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm); |
e1ddb4b6a
|
1001 |
#else |
c05e6ff03
|
1002 1003 1004 1005 |
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap) { return NULL; } |
7c77fa4d5
|
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 |
static inline int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm) { return -ENOSYS; } static inline int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *stm) { return -ENOSYS; } static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev, const struct ata_acpi_gtm *gtm) { return 0; } |
021ee9a6d
|
1024 1025 1026 1027 1028 1029 |
static inline int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm) { return 0; } |
e1ddb4b6a
|
1030 |
#endif |
1da177e4c
|
1031 |
|
ece1d6361
|
1032 |
/* |
624d5c514
|
1033 |
* EH - drivers/ata/libata-eh.c |
ece1d6361
|
1034 |
*/ |
7b70fc039
|
1035 |
extern void ata_port_schedule_eh(struct ata_port *ap); |
dbd826168
|
1036 |
extern int ata_link_abort(struct ata_link *link); |
7b70fc039
|
1037 |
extern int ata_port_abort(struct ata_port *ap); |
e31804994
|
1038 |
extern int ata_port_freeze(struct ata_port *ap); |
7d77b2470
|
1039 |
extern int sata_async_notification(struct ata_port *ap); |
e31804994
|
1040 1041 1042 |
extern void ata_eh_freeze_port(struct ata_port *ap); extern void ata_eh_thaw_port(struct ata_port *ap); |
7b70fc039
|
1043 |
|
ece1d6361
|
1044 1045 |
extern void ata_eh_qc_complete(struct ata_queued_cmd *qc); extern void ata_eh_qc_retry(struct ata_queued_cmd *qc); |
10acf3b0d
|
1046 |
extern void ata_eh_analyze_ncq_error(struct ata_link *link); |
ece1d6361
|
1047 |
|
f5914a461
|
1048 1049 1050 |
extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset, ata_reset_fn_t softreset, ata_reset_fn_t hardreset, ata_postreset_fn_t postreset); |
a1efdaba2
|
1051 |
extern void ata_std_error_handler(struct ata_port *ap); |
022bdb075
|
1052 |
|
61440db61
|
1053 |
/* |
68d1d07b5
|
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 |
* Base operations to inherit from and initializers for sht * * Operations * * base : Common to all libata drivers. * sata : SATA controllers w/ native interface. * pmp : SATA controllers w/ PMP support. * sff : SFF ATA controllers w/o BMDMA support. * bmdma : SFF ATA controllers w/ BMDMA support. * * sht initializers * * BASE : Common to all libata drivers. The user must set * sg_tablesize and dma_boundary. * PIO : SFF ATA controllers w/ only PIO support. * BMDMA : SFF ATA controllers w/ BMDMA support. sg_tablesize and * dma_boundary are set to BMDMA limits. * NCQ : SATA controllers supporting NCQ. The user must set * sg_tablesize, dma_boundary and can_queue. */ extern const struct ata_port_operations ata_base_port_ops; extern const struct ata_port_operations sata_port_ops; |
45fabbb77
|
1076 |
extern struct device_attribute *ata_common_sdev_attrs[]; |
68d1d07b5
|
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 |
#define ATA_BASE_SHT(drv_name) \ .module = THIS_MODULE, \ .name = drv_name, \ .ioctl = ata_scsi_ioctl, \ .queuecommand = ata_scsi_queuecmd, \ .can_queue = ATA_DEF_QUEUE, \ .this_id = ATA_SHT_THIS_ID, \ .cmd_per_lun = ATA_SHT_CMD_PER_LUN, \ .emulated = ATA_SHT_EMULATED, \ .use_clustering = ATA_SHT_USE_CLUSTERING, \ .proc_name = drv_name, \ .slave_configure = ata_scsi_slave_config, \ .slave_destroy = ata_scsi_slave_destroy, \ |
45fabbb77
|
1091 1092 |
.bios_param = ata_std_bios_param, \ .sdev_attrs = ata_common_sdev_attrs |
68d1d07b5
|
1093 |
|
68d1d07b5
|
1094 1095 1096 1097 1098 |
#define ATA_NCQ_SHT(drv_name) \ ATA_BASE_SHT(drv_name), \ .change_queue_depth = ata_scsi_change_queue_depth /* |
071f44b1d
|
1099 1100 |
* PMP helpers */ |
88fcd5627
|
1101 |
#ifdef CONFIG_SATA_PMP |
071f44b1d
|
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 |
static inline bool sata_pmp_supported(struct ata_port *ap) { return ap->flags & ATA_FLAG_PMP; } static inline bool sata_pmp_attached(struct ata_port *ap) { return ap->nr_pmp_links != 0; } static inline int ata_is_host_link(const struct ata_link *link) { |
b1c72916a
|
1114 |
return link == &link->ap->link || link == link->ap->slave_link; |
071f44b1d
|
1115 |
} |
88fcd5627
|
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 |
#else /* CONFIG_SATA_PMP */ static inline bool sata_pmp_supported(struct ata_port *ap) { return false; } static inline bool sata_pmp_attached(struct ata_port *ap) { return false; } static inline int ata_is_host_link(const struct ata_link *link) { return 1; } #endif /* CONFIG_SATA_PMP */ |
071f44b1d
|
1132 1133 1134 1135 1136 1137 1138 1139 1140 |
static inline int sata_srst_pmp(struct ata_link *link) { if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) return SATA_PMP_CTRL_PORT; return link->pmp; } /* |
61440db61
|
1141 1142 1143 |
* printk helpers */ #define ata_port_printk(ap, lv, fmt, args...) \ |
c2e366a10
|
1144 |
printk("%sata%u: "fmt, lv, (ap)->print_id , ##args) |
61440db61
|
1145 |
|
8989805d6
|
1146 |
#define ata_link_printk(link, lv, fmt, args...) do { \ |
b1c72916a
|
1147 |
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \ |
c2e366a10
|
1148 |
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \ |
8989805d6
|
1149 1150 |
(link)->pmp , ##args); \ else \ |
c2e366a10
|
1151 |
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \ |
8989805d6
|
1152 |
} while(0) |
9af5c9c97
|
1153 |
|
61440db61
|
1154 |
#define ata_dev_printk(dev, lv, fmt, args...) \ |
c2e366a10
|
1155 |
printk("%sata%u.%02u: "fmt, lv, (dev)->link->ap->print_id, \ |
8989805d6
|
1156 |
(dev)->link->pmp + (dev)->devno , ##args) |
1da177e4c
|
1157 |
|
61440db61
|
1158 |
/* |
f3e81b19a
|
1159 1160 |
* ata_eh_info helpers */ |
cb94c1cf5
|
1161 1162 1163 1164 |
extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...) __attribute__ ((format (printf, 2, 3))); extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...) __attribute__ ((format (printf, 2, 3))); |
b64bbc39f
|
1165 |
extern void ata_ehi_clear_desc(struct ata_eh_info *ehi); |
f3e81b19a
|
1166 |
|
c0b6c0377
|
1167 1168 |
static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi) { |
b558edddb
|
1169 |
ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1; |
f8f1e1cc0
|
1170 |
ehi->flags |= ATA_EHI_HOTPLUGGED; |
b558edddb
|
1171 |
ehi->action |= ATA_EH_RESET | ATA_EH_ENABLE_LINK; |
c0b6c0377
|
1172 1173 |
ehi->err_mask |= AC_ERR_ATA_BUS; } |
f3e81b19a
|
1174 |
/* |
cbcdd8759
|
1175 1176 1177 1178 1179 1180 1181 1182 |
* port description helpers */ extern void ata_port_desc(struct ata_port *ap, const char *fmt, ...) __attribute__ ((format (printf, 2, 3))); #ifdef CONFIG_PCI extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset, const char *name); #endif |
1da177e4c
|
1183 1184 1185 1186 |
static inline unsigned int ata_tag_valid(unsigned int tag) { return (tag < ATA_MAX_QUEUE) ? 1 : 0; } |
2ab7db1ff
|
1187 1188 |
static inline unsigned int ata_tag_internal(unsigned int tag) { |
83c063dd7
|
1189 |
return tag == ATA_TAG_INTERNAL; |
2ab7db1ff
|
1190 |
} |
5806db22c
|
1191 1192 1193 |
/* * device helpers */ |
e1211e3fa
|
1194 |
static inline unsigned int ata_class_enabled(unsigned int class) |
597afd214
|
1195 |
{ |
e0a717526
|
1196 1197 |
return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI || class == ATA_DEV_PMP || class == ATA_DEV_SEMB; |
597afd214
|
1198 |
} |
e1211e3fa
|
1199 |
static inline unsigned int ata_class_disabled(unsigned int class) |
1da177e4c
|
1200 |
{ |
e0a717526
|
1201 1202 |
return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP || class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP; |
e1211e3fa
|
1203 |
} |
002c8054f
|
1204 1205 1206 1207 |
static inline unsigned int ata_class_absent(unsigned int class) { return !ata_class_enabled(class) && !ata_class_disabled(class); } |
e1211e3fa
|
1208 1209 1210 1211 1212 1213 1214 1215 |
static inline unsigned int ata_dev_enabled(const struct ata_device *dev) { return ata_class_enabled(dev->class); } static inline unsigned int ata_dev_disabled(const struct ata_device *dev) { return ata_class_disabled(dev->class); |
1da177e4c
|
1216 |
} |
002c8054f
|
1217 1218 1219 1220 |
static inline unsigned int ata_dev_absent(const struct ata_device *dev) { return ata_class_absent(dev->class); } |
5806db22c
|
1221 |
/* |
f58229f80
|
1222 |
* link helpers |
5806db22c
|
1223 |
*/ |
f58229f80
|
1224 |
static inline int ata_link_max_devices(const struct ata_link *link) |
5806db22c
|
1225 |
{ |
8989805d6
|
1226 |
if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS) |
5806db22c
|
1227 1228 1229 |
return 2; return 1; } |
da917d69d
|
1230 1231 1232 1233 |
static inline int ata_link_active(struct ata_link *link) { return ata_tag_valid(link->active_tag) || link->sactive; } |
1eca4365b
|
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 |
/* * Iterators * * ATA_LITER_* constants are used to select link iteration mode and * ATA_DITER_* device iteration mode. * * For a custom iteration directly using ata_{link|dev}_next(), if * @link or @dev, respectively, is NULL, the first element is * returned. @dev and @link can be any valid device or link and the * next element according to the iteration mode will be returned. * After the last element, NULL is returned. */ enum ata_link_iter_mode { ATA_LITER_EDGE, /* if present, PMP links only; otherwise, * host link. no slave link */ ATA_LITER_HOST_FIRST, /* host link followed by PMP or slave links */ ATA_LITER_PMP_FIRST, /* PMP links followed by host link, * slave link still comes after host link */ }; enum ata_dev_iter_mode { ATA_DITER_ENABLED, ATA_DITER_ENABLED_REVERSE, ATA_DITER_ALL, ATA_DITER_ALL_REVERSE, }; extern struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap, enum ata_link_iter_mode mode); extern struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link, enum ata_dev_iter_mode mode); /* * Shortcut notation for iterations * * ata_for_each_link() iterates over each link of @ap according to * @mode. @link points to the current link in the loop. @link is * NULL after loop termination. ata_for_each_dev() works the same way * except that it iterates over each device of @link. * * Note that the mode prefixes ATA_{L|D}ITER_ shouldn't need to be * specified when using the following shorthand notations. Only the * mode itself (EDGE, HOST_FIRST, ENABLED, etc...) should be * specified. This not only increases brevity but also makes it * impossible to use ATA_LITER_* for device iteration or vice-versa. */ #define ata_for_each_link(link, ap, mode) \ for ((link) = ata_link_next(NULL, (ap), ATA_LITER_##mode); (link); \ (link) = ata_link_next((link), (ap), ATA_LITER_##mode)) #define ata_for_each_dev(dev, link, mode) \ for ((dev) = ata_dev_next(NULL, (link), ATA_DITER_##mode); (dev); \ (dev) = ata_dev_next((dev), (link), ATA_DITER_##mode)) |
5806db22c
|
1290 |
|
6d1245bf2
|
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 |
/** * ata_ncq_enabled - Test whether NCQ is enabled * @dev: ATA device to test for * * LOCKING: * spin_lock_irqsave(host lock) * * RETURNS: * 1 if NCQ is enabled for @dev, 0 otherwise. */ static inline int ata_ncq_enabled(struct ata_device *dev) { return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF | ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ; } |
0baab86b0
|
1306 |
|
1da177e4c
|
1307 1308 1309 1310 |
static inline void ata_qc_set_polling(struct ata_queued_cmd *qc) { qc->tf.ctl |= ATA_NIEN; } |
f69499f42
|
1311 1312 |
static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap, unsigned int tag) |
1da177e4c
|
1313 1314 1315 1316 1317 |
{ if (likely(ata_tag_valid(tag))) return &ap->qcmd[tag]; return NULL; } |
f69499f42
|
1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 |
static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap, unsigned int tag) { struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); if (unlikely(!qc) || !ap->ops->error_handler) return qc; if ((qc->flags & (ATA_QCFLAG_ACTIVE | ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE) return qc; return NULL; } |
aacda3753
|
1332 1333 1334 1335 |
static inline unsigned int ata_qc_raw_nbytes(struct ata_queued_cmd *qc) { return qc->nbytes - min(qc->extrabytes, qc->nbytes); } |
3373efd89
|
1336 |
static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf) |
1da177e4c
|
1337 1338 |
{ memset(tf, 0, sizeof(*tf)); |
9af5c9c97
|
1339 |
tf->ctl = dev->link->ap->ctl; |
3373efd89
|
1340 |
if (dev->devno == 0) |
1da177e4c
|
1341 1342 1343 1344 |
tf->device = ATA_DEVICE_OBS; else tf->device = ATA_DEVICE_OBS | ATA_DEV1; } |
2c13b7cee
|
1345 1346 |
static inline void ata_qc_reinit(struct ata_queued_cmd *qc) { |
501e0c500
|
1347 |
qc->dma_dir = DMA_NONE; |
ff2aeb1eb
|
1348 |
qc->sg = NULL; |
2c13b7cee
|
1349 |
qc->flags = 0; |
872602162
|
1350 1351 |
qc->cursg = NULL; qc->cursg_ofs = 0; |
aacda3753
|
1352 |
qc->nbytes = qc->extrabytes = qc->curbytes = 0; |
7a801184f
|
1353 |
qc->n_elem = 0; |
a22e2eb07
|
1354 |
qc->err_mask = 0; |
5a5dbd18a
|
1355 |
qc->sect_size = ATA_SECT_SIZE; |
2c13b7cee
|
1356 |
|
3373efd89
|
1357 |
ata_tf_init(qc->dev, &qc->tf); |
e61e06722
|
1358 1359 1360 1361 |
/* init result_tf such that it indicates normal completion */ qc->result_tf.command = ATA_DRDY; qc->result_tf.feature = 0; |
2c13b7cee
|
1362 |
} |
057ace5e7
|
1363 |
static inline int ata_try_flush_cache(const struct ata_device *dev) |
1da177e4c
|
1364 1365 1366 1367 1368 |
{ return ata_id_wcache_enabled(dev->id) || ata_id_has_flush(dev->id) || ata_id_has_flush_ext(dev->id); } |
a7dac447b
|
1369 1370 |
static inline unsigned int ac_err_mask(u8 status) { |
3655d1d32
|
1371 |
if (status & (ATA_BUSY | ATA_DRQ)) |
11a56d243
|
1372 |
return AC_ERR_HSM; |
a7dac447b
|
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 |
if (status & (ATA_ERR | ATA_DF)) return AC_ERR_DEV; return 0; } static inline unsigned int __ac_err_mask(u8 status) { unsigned int mask = ac_err_mask(status); if (mask == 0) return AC_ERR_OTHER; return mask; } |
35bb94b11
|
1385 1386 |
static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host) { |
4911487a3
|
1387 |
return *(struct ata_port **)&host->hostdata[0]; |
35bb94b11
|
1388 |
} |
78ab88f04
|
1389 1390 |
static inline int ata_check_ready(u8 status) { |
005b1f749
|
1391 1392 |
if (!(status & ATA_BUSY)) return 1; |
78ab88f04
|
1393 1394 1395 1396 |
/* 0xff indicates either no device or device not ready */ if (status == 0xff) return -ENODEV; |
005b1f749
|
1397 |
return 0; |
78ab88f04
|
1398 |
} |
341c2c958
|
1399 1400 1401 1402 1403 |
static inline unsigned long ata_deadline(unsigned long from_jiffies, unsigned long timeout_msecs) { return from_jiffies + msecs_to_jiffies(timeout_msecs); } |
b15b3ebae
|
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 |
/* Don't open code these in drivers as there are traps. Firstly the range may change in future hardware and specs, secondly 0xFF means 'no DMA' but is > UDMA_0. Dyma ddreigiau */ static inline int ata_using_mwdma(struct ata_device *adev) { if (adev->dma_mode >= XFER_MW_DMA_0 && adev->dma_mode <= XFER_MW_DMA_4) return 1; return 0; } static inline int ata_using_udma(struct ata_device *adev) { if (adev->dma_mode >= XFER_UDMA_0 && adev->dma_mode <= XFER_UDMA_7) return 1; return 0; } static inline int ata_dma_enabled(struct ata_device *adev) { return (adev->dma_mode == 0xFF ? 0 : 1); } |
48515f6c0
|
1426 1427 1428 1429 |
/************************************************************************** * PMP - drivers/ata/libata-pmp.c */ |
88fcd5627
|
1430 |
#ifdef CONFIG_SATA_PMP |
48515f6c0
|
1431 1432 1433 1434 |
extern const struct ata_port_operations sata_pmp_port_ops; extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc); extern void sata_pmp_error_handler(struct ata_port *ap); |
88fcd5627
|
1435 1436 1437 1438 1439 1440 1441 |
#else /* CONFIG_SATA_PMP */ #define sata_pmp_port_ops sata_port_ops #define sata_pmp_qc_defer_cmd_switch ata_std_qc_defer #define sata_pmp_error_handler ata_std_error_handler #endif /* CONFIG_SATA_PMP */ |
48515f6c0
|
1442 |
|
624d5c514
|
1443 1444 1445 |
/************************************************************************** * SFF - drivers/ata/libata-sff.c */ |
127102aea
|
1446 |
#ifdef CONFIG_ATA_SFF |
624d5c514
|
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 |
extern const struct ata_port_operations ata_sff_port_ops; extern const struct ata_port_operations ata_bmdma_port_ops; /* PIO only, sg_tablesize and dma_boundary limits can be removed */ #define ATA_PIO_SHT(drv_name) \ ATA_BASE_SHT(drv_name), \ .sg_tablesize = LIBATA_MAX_PRD, \ .dma_boundary = ATA_DMA_BOUNDARY #define ATA_BMDMA_SHT(drv_name) \ ATA_BASE_SHT(drv_name), \ .sg_tablesize = LIBATA_MAX_PRD, \ .dma_boundary = ATA_DMA_BOUNDARY |
9363c3825
|
1460 1461 1462 1463 |
extern void ata_sff_qc_prep(struct ata_queued_cmd *qc); extern void ata_sff_dumb_qc_prep(struct ata_queued_cmd *qc); extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device); extern u8 ata_sff_check_status(struct ata_port *ap); |
a57c1bade
|
1464 1465 |
extern void ata_sff_pause(struct ata_port *ap); extern void ata_sff_dma_pause(struct ata_port *ap); |
9363c3825
|
1466 1467 |
extern int ata_sff_busy_sleep(struct ata_port *ap, unsigned long timeout_pat, unsigned long timeout); |
705e76beb
|
1468 |
extern int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline); |
9363c3825
|
1469 1470 1471 1472 1473 |
extern void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf); extern void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf); extern void ata_sff_exec_command(struct ata_port *ap, const struct ata_taskfile *tf); extern unsigned int ata_sff_data_xfer(struct ata_device *dev, |
624d5c514
|
1474 |
unsigned char *buf, unsigned int buflen, int rw); |
9363c3825
|
1475 |
extern unsigned int ata_sff_data_xfer_noirq(struct ata_device *dev, |
624d5c514
|
1476 |
unsigned char *buf, unsigned int buflen, int rw); |
9363c3825
|
1477 1478 1479 1480 1481 |
extern u8 ata_sff_irq_on(struct ata_port *ap); extern void ata_sff_irq_clear(struct ata_port *ap); extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc, u8 status, int in_wq); extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc); |
22183bf56
|
1482 |
extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc); |
9363c3825
|
1483 1484 1485 1486 1487 1488 1489 1490 |
extern unsigned int ata_sff_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc); extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance); extern void ata_sff_freeze(struct ata_port *ap); extern void ata_sff_thaw(struct ata_port *ap); extern int ata_sff_prereset(struct ata_link *link, unsigned long deadline); extern unsigned int ata_sff_dev_classify(struct ata_device *dev, int present, u8 *r_err); |
705e76beb
|
1491 1492 |
extern int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask, unsigned long deadline); |
9363c3825
|
1493 |
extern int ata_sff_softreset(struct ata_link *link, unsigned int *classes, |
624d5c514
|
1494 |
unsigned long deadline); |
9363c3825
|
1495 1496 1497 1498 1499 |
extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class, unsigned long deadline); extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes); extern void ata_sff_error_handler(struct ata_port *ap); extern void ata_sff_post_internal_cmd(struct ata_queued_cmd *qc); |
624d5c514
|
1500 |
extern int ata_sff_port_start(struct ata_port *ap); |
9363c3825
|
1501 1502 1503 |
extern void ata_sff_std_ports(struct ata_ioports *ioaddr); extern unsigned long ata_bmdma_mode_filter(struct ata_device *dev, unsigned long xfer_mask); |
624d5c514
|
1504 1505 1506 1507 1508 1509 1510 |
extern void ata_bmdma_setup(struct ata_queued_cmd *qc); extern void ata_bmdma_start(struct ata_queued_cmd *qc); extern void ata_bmdma_stop(struct ata_queued_cmd *qc); extern u8 ata_bmdma_status(struct ata_port *ap); extern void ata_bus_reset(struct ata_port *ap); #ifdef CONFIG_PCI |
9363c3825
|
1511 1512 1513 1514 |
extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev); extern int ata_pci_bmdma_init(struct ata_host *host); extern int ata_pci_sff_init_host(struct ata_host *host); extern int ata_pci_sff_prepare_host(struct pci_dev *pdev, |
624d5c514
|
1515 1516 |
const struct ata_port_info * const * ppi, struct ata_host **r_host); |
9363c3825
|
1517 |
extern int ata_pci_sff_activate_host(struct ata_host *host, |
624d5c514
|
1518 1519 |
irq_handler_t irq_handler, struct scsi_host_template *sht); |
9363c3825
|
1520 1521 1522 |
extern int ata_pci_sff_init_one(struct pci_dev *pdev, const struct ata_port_info * const * ppi, struct scsi_host_template *sht, void *host_priv); |
624d5c514
|
1523 |
#endif /* CONFIG_PCI */ |
624d5c514
|
1524 |
/** |
9363c3825
|
1525 |
* ata_sff_busy_wait - Wait for a port status register |
624d5c514
|
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 |
* @ap: Port to wait for. * @bits: bits that must be clear * @max: number of 10uS waits to perform * * Waits up to max*10 microseconds for the selected bits in the port's * status register to be cleared. * Returns final value of status register. * * LOCKING: * Inherited from caller. */ |
9363c3825
|
1537 1538 |
static inline u8 ata_sff_busy_wait(struct ata_port *ap, unsigned int bits, unsigned int max) |
624d5c514
|
1539 1540 1541 1542 1543 |
{ u8 status; do { udelay(10); |
5682ed33a
|
1544 |
status = ap->ops->sff_check_status(ap); |
624d5c514
|
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 |
max--; } while (status != 0xff && (status & bits) && (max > 0)); return status; } /** * ata_wait_idle - Wait for a port to be idle. * @ap: Port to wait for. * * Waits up to 10ms for port's BUSY and DRQ signals to clear. * Returns final value of status register. * * LOCKING: * Inherited from caller. */ static inline u8 ata_wait_idle(struct ata_port *ap) { |
9363c3825
|
1563 |
u8 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000); |
624d5c514
|
1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 |
#ifdef ATA_DEBUG if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ))) ata_port_printk(ap, KERN_DEBUG, "abnormal Status 0x%X ", status); #endif return status; } |
127102aea
|
1574 |
#endif /* CONFIG_ATA_SFF */ |
624d5c514
|
1575 |
|
1da177e4c
|
1576 |
#endif /* __LINUX_LIBATA_H__ */ |