OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [include/] [linux/] [libata.h] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*
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
 
26
#ifndef __LINUX_LIBATA_H__
27
#define __LINUX_LIBATA_H__
28
 
29
#include <linux/delay.h>
30
#include <linux/interrupt.h>
31
#include <linux/dma-mapping.h>
32
#include <linux/scatterlist.h>
33
#include <linux/io.h>
34
#include <linux/ata.h>
35
#include <linux/workqueue.h>
36
#include <scsi/scsi_host.h>
37
#include <linux/acpi.h>
38
 
39
/*
40
 * Define if arch has non-standard setup.  This is a _PCI_ standard
41
 * not a legacy or ISA standard.
42
 */
43
#ifdef CONFIG_ATA_NONSTANDARD
44
#include <asm/libata-portmap.h>
45
#else
46
#include <asm-generic/libata-portmap.h>
47
#endif
48
 
49
/*
50
 * compile-time options: to be removed as soon as all the drivers are
51
 * converted to the new debugging mechanism
52
 */
53
#undef ATA_DEBUG                /* debugging output */
54
#undef ATA_VERBOSE_DEBUG        /* yet more debugging output */
55
#undef ATA_IRQ_TRAP             /* define to ack screaming irqs */
56
#undef ATA_NDEBUG               /* define to disable quick runtime checks */
57
 
58
 
59
/* note: prints function name for you */
60
#ifdef ATA_DEBUG
61
#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
62
#ifdef ATA_VERBOSE_DEBUG
63
#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
64
#else
65
#define VPRINTK(fmt, args...)
66
#endif  /* ATA_VERBOSE_DEBUG */
67
#else
68
#define DPRINTK(fmt, args...)
69
#define VPRINTK(fmt, args...)
70
#endif  /* ATA_DEBUG */
71
 
72
#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
73
 
74
/* NEW: debug levels */
75
#define HAVE_LIBATA_MSG 1
76
 
77
enum {
78
        ATA_MSG_DRV     = 0x0001,
79
        ATA_MSG_INFO    = 0x0002,
80
        ATA_MSG_PROBE   = 0x0004,
81
        ATA_MSG_WARN    = 0x0008,
82
        ATA_MSG_MALLOC  = 0x0010,
83
        ATA_MSG_CTL     = 0x0020,
84
        ATA_MSG_INTR    = 0x0040,
85
        ATA_MSG_ERR     = 0x0080,
86
};
87
 
88
#define ata_msg_drv(p)    ((p)->msg_enable & ATA_MSG_DRV)
89
#define ata_msg_info(p)   ((p)->msg_enable & ATA_MSG_INFO)
90
#define ata_msg_probe(p)  ((p)->msg_enable & ATA_MSG_PROBE)
91
#define ata_msg_warn(p)   ((p)->msg_enable & ATA_MSG_WARN)
92
#define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC)
93
#define ata_msg_ctl(p)    ((p)->msg_enable & ATA_MSG_CTL)
94
#define ata_msg_intr(p)   ((p)->msg_enable & ATA_MSG_INTR)
95
#define ata_msg_err(p)    ((p)->msg_enable & ATA_MSG_ERR)
96
 
97
static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
98
{
99
        if (dval < 0 || dval >= (sizeof(u32) * 8))
100
                return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */
101
        if (!dval)
102
                return 0;
103
        return (1 << dval) - 1;
104
}
105
 
106
/* defines only for the constants which don't work well as enums */
107
#define ATA_TAG_POISON          0xfafbfcfdU
108
 
109
enum {
110
        /* various global constants */
111
        LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
112
        LIBATA_DUMB_MAX_PRD     = ATA_MAX_PRD / 4,      /* Worst case */
113
        ATA_MAX_PORTS           = 8,
114
        ATA_DEF_QUEUE           = 1,
115
        /* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
116
        ATA_MAX_QUEUE           = 32,
117
        ATA_TAG_INTERNAL        = ATA_MAX_QUEUE - 1,
118
        ATA_MAX_BUS             = 2,
119
        ATA_DEF_BUSY_WAIT       = 10000,
120
        ATA_SHORT_PAUSE         = (HZ >> 6) + 1,
121
 
122
        ATAPI_MAX_DRAIN         = 16 << 10,
123
 
124
        ATA_SHT_EMULATED        = 1,
125
        ATA_SHT_CMD_PER_LUN     = 1,
126
        ATA_SHT_THIS_ID         = -1,
127
        ATA_SHT_USE_CLUSTERING  = 1,
128
 
129
        /* struct ata_device stuff */
130
        ATA_DFLAG_LBA           = (1 << 0), /* device supports LBA */
131
        ATA_DFLAG_LBA48         = (1 << 1), /* device supports LBA48 */
132
        ATA_DFLAG_CDB_INTR      = (1 << 2), /* device asserts INTRQ when ready for CDB */
133
        ATA_DFLAG_NCQ           = (1 << 3), /* device supports NCQ */
134
        ATA_DFLAG_FLUSH_EXT     = (1 << 4), /* do FLUSH_EXT instead of FLUSH */
135
        ATA_DFLAG_ACPI_PENDING  = (1 << 5), /* ACPI resume action pending */
136
        ATA_DFLAG_ACPI_FAILED   = (1 << 6), /* ACPI on devcfg has failed */
137
        ATA_DFLAG_AN            = (1 << 7), /* AN configured */
138
        ATA_DFLAG_HIPM          = (1 << 8), /* device supports HIPM */
139
        ATA_DFLAG_DIPM          = (1 << 9), /* device supports DIPM */
140
        ATA_DFLAG_CFG_MASK      = (1 << 12) - 1,
141
 
142
        ATA_DFLAG_PIO           = (1 << 12), /* device limited to PIO mode */
143
        ATA_DFLAG_NCQ_OFF       = (1 << 13), /* device limited to non-NCQ mode */
144
        ATA_DFLAG_SPUNDOWN      = (1 << 14), /* XXX: for spindown_compat */
145
        ATA_DFLAG_SLEEPING      = (1 << 15), /* device is sleeping */
146
        ATA_DFLAG_INIT_MASK     = (1 << 16) - 1,
147
 
148
        ATA_DFLAG_DETACH        = (1 << 16),
149
        ATA_DFLAG_DETACHED      = (1 << 17),
150
 
151
        ATA_DEV_UNKNOWN         = 0,     /* unknown device */
152
        ATA_DEV_ATA             = 1,    /* ATA device */
153
        ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
154
        ATA_DEV_ATAPI           = 3,    /* ATAPI device */
155
        ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
156
        ATA_DEV_PMP             = 5,    /* SATA port multiplier */
157
        ATA_DEV_PMP_UNSUP       = 6,    /* SATA port multiplier (unsupported) */
158
        ATA_DEV_SEMB            = 7,    /* SEMB */
159
        ATA_DEV_SEMB_UNSUP      = 8,    /* SEMB (unsupported) */
160
        ATA_DEV_NONE            = 9,    /* no device */
161
 
162
        /* struct ata_link flags */
163
        ATA_LFLAG_HRST_TO_RESUME = (1 << 0), /* hardreset to resume link */
164
        ATA_LFLAG_SKIP_D2H_BSY  = (1 << 1), /* can't wait for the first D2H
165
                                             * Register FIS clearing BSY */
166
        ATA_LFLAG_NO_SRST       = (1 << 2), /* avoid softreset */
167
        ATA_LFLAG_ASSUME_ATA    = (1 << 3), /* assume ATA class */
168
        ATA_LFLAG_ASSUME_SEMB   = (1 << 4), /* assume SEMB class */
169
        ATA_LFLAG_ASSUME_CLASS  = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
170
        ATA_LFLAG_NO_RETRY      = (1 << 5), /* don't retry this link */
171
        ATA_LFLAG_DISABLED      = (1 << 6), /* link is disabled */
172
 
173
        /* struct ata_port flags */
174
        ATA_FLAG_SLAVE_POSS     = (1 << 0), /* host supports slave dev */
175
                                            /* (doesn't imply presence) */
176
        ATA_FLAG_SATA           = (1 << 1),
177
        ATA_FLAG_NO_LEGACY      = (1 << 2), /* no legacy mode check */
178
        ATA_FLAG_MMIO           = (1 << 3), /* use MMIO, not PIO */
179
        ATA_FLAG_SRST           = (1 << 4), /* (obsolete) use ATA SRST, not E.D.D. */
180
        ATA_FLAG_SATA_RESET     = (1 << 5), /* (obsolete) use COMRESET */
181
        ATA_FLAG_NO_ATAPI       = (1 << 6), /* No ATAPI support */
182
        ATA_FLAG_PIO_DMA        = (1 << 7), /* PIO cmds via DMA */
183
        ATA_FLAG_PIO_LBA48      = (1 << 8), /* Host DMA engine is LBA28 only */
184
        ATA_FLAG_PIO_POLLING    = (1 << 9), /* use polling PIO if LLD
185
                                             * doesn't handle PIO interrupts */
186
        ATA_FLAG_NCQ            = (1 << 10), /* host supports NCQ */
187
        ATA_FLAG_DEBUGMSG       = (1 << 13),
188
        ATA_FLAG_IGN_SIMPLEX    = (1 << 15), /* ignore SIMPLEX */
189
        ATA_FLAG_NO_IORDY       = (1 << 16), /* controller lacks iordy */
190
        ATA_FLAG_ACPI_SATA      = (1 << 17), /* need native SATA ACPI layout */
191
        ATA_FLAG_AN             = (1 << 18), /* controller supports AN */
192
        ATA_FLAG_PMP            = (1 << 19), /* controller supports PMP */
193
        ATA_FLAG_IPM            = (1 << 20), /* driver can handle IPM */
194
 
195
        /* The following flag belongs to ap->pflags but is kept in
196
         * ap->flags because it's referenced in many LLDs and will be
197
         * removed in not-too-distant future.
198
         */
199
        ATA_FLAG_DISABLED       = (1 << 23), /* port is disabled, ignore it */
200
 
201
        /* bits 24:31 of ap->flags are reserved for LLD specific flags */
202
 
203
        /* struct ata_port pflags */
204
        ATA_PFLAG_EH_PENDING    = (1 << 0), /* EH pending */
205
        ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
206
        ATA_PFLAG_FROZEN        = (1 << 2), /* port is frozen */
207
        ATA_PFLAG_RECOVERED     = (1 << 3), /* recovery action performed */
208
        ATA_PFLAG_LOADING       = (1 << 4), /* boot/loading probe */
209
        ATA_PFLAG_UNLOADING     = (1 << 5), /* module is unloading */
210
        ATA_PFLAG_SCSI_HOTPLUG  = (1 << 6), /* SCSI hotplug scheduled */
211
        ATA_PFLAG_INITIALIZING  = (1 << 7), /* being initialized, don't touch */
212
        ATA_PFLAG_RESETTING     = (1 << 8), /* reset in progress */
213
 
214
        ATA_PFLAG_SUSPENDED     = (1 << 17), /* port is suspended (power) */
215
        ATA_PFLAG_PM_PENDING    = (1 << 18), /* PM operation pending */
216
        ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
217
 
218
        /* struct ata_queued_cmd flags */
219
        ATA_QCFLAG_ACTIVE       = (1 << 0), /* cmd not yet ack'd to scsi lyer */
220
        ATA_QCFLAG_SG           = (1 << 1), /* have s/g table? */
221
        ATA_QCFLAG_SINGLE       = (1 << 2), /* no s/g, just a single buffer */
222
        ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
223
        ATA_QCFLAG_IO           = (1 << 3), /* standard IO command */
224
        ATA_QCFLAG_RESULT_TF    = (1 << 4), /* result TF requested */
225
        ATA_QCFLAG_CLEAR_EXCL   = (1 << 5), /* clear excl_link on completion */
226
        ATA_QCFLAG_QUIET        = (1 << 6), /* don't report device error */
227
 
228
        ATA_QCFLAG_FAILED       = (1 << 16), /* cmd failed and is owned by EH */
229
        ATA_QCFLAG_SENSE_VALID  = (1 << 17), /* sense data valid */
230
        ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */
231
 
232
        /* host set flags */
233
        ATA_HOST_SIMPLEX        = (1 << 0),      /* Host is simplex, one DMA channel per host only */
234
        ATA_HOST_STARTED        = (1 << 1),     /* Host started */
235
 
236
        /* bits 24:31 of host->flags are reserved for LLD specific flags */
237
 
238
        /* various lengths of time */
239
        ATA_TMOUT_BOOT          = 30 * HZ,      /* heuristic */
240
        ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* heuristic */
241
        ATA_TMOUT_INTERNAL      = 30 * HZ,
242
        ATA_TMOUT_INTERNAL_QUICK = 5 * HZ,
243
 
244
        /* FIXME: GoVault needs 2s but we can't afford that without
245
         * parallel probing.  800ms is enough for iVDR disk
246
         * HHD424020F7SV00.  Increase to 2secs when parallel probing
247
         * is in place.
248
         */
249
        ATA_TMOUT_FF_WAIT       = 4 * HZ / 5,
250
 
251
        /* ATA bus states */
252
        BUS_UNKNOWN             = 0,
253
        BUS_DMA                 = 1,
254
        BUS_IDLE                = 2,
255
        BUS_NOINTR              = 3,
256
        BUS_NODATA              = 4,
257
        BUS_TIMER               = 5,
258
        BUS_PIO                 = 6,
259
        BUS_EDD                 = 7,
260
        BUS_IDENTIFY            = 8,
261
        BUS_PACKET              = 9,
262
 
263
        /* SATA port states */
264
        PORT_UNKNOWN            = 0,
265
        PORT_ENABLED            = 1,
266
        PORT_DISABLED           = 2,
267
 
268
        /* encoding various smaller bitmaps into a single
269
         * unsigned int bitmap
270
         */
271
        ATA_BITS_PIO            = 7,
272
        ATA_BITS_MWDMA          = 5,
273
        ATA_BITS_UDMA           = 8,
274
 
275
        ATA_SHIFT_PIO           = 0,
276
        ATA_SHIFT_MWDMA         = ATA_SHIFT_PIO + ATA_BITS_PIO,
277
        ATA_SHIFT_UDMA          = ATA_SHIFT_MWDMA + ATA_BITS_MWDMA,
278
 
279
        ATA_MASK_PIO            = ((1 << ATA_BITS_PIO) - 1) << ATA_SHIFT_PIO,
280
        ATA_MASK_MWDMA          = ((1 << ATA_BITS_MWDMA) - 1) << ATA_SHIFT_MWDMA,
281
        ATA_MASK_UDMA           = ((1 << ATA_BITS_UDMA) - 1) << ATA_SHIFT_UDMA,
282
 
283
        /* size of buffer to pad xfers ending on unaligned boundaries */
284
        ATA_DMA_PAD_SZ          = 4,
285
        ATA_DMA_PAD_BUF_SZ      = ATA_DMA_PAD_SZ * ATA_MAX_QUEUE,
286
 
287
        /* ering size */
288
        ATA_ERING_SIZE          = 32,
289
 
290
        /* return values for ->qc_defer */
291
        ATA_DEFER_LINK          = 1,
292
        ATA_DEFER_PORT          = 2,
293
 
294
        /* desc_len for ata_eh_info and context */
295
        ATA_EH_DESC_LEN         = 80,
296
 
297
        /* reset / recovery action types */
298
        ATA_EH_REVALIDATE       = (1 << 0),
299
        ATA_EH_SOFTRESET        = (1 << 1),
300
        ATA_EH_HARDRESET        = (1 << 2),
301
        ATA_EH_ENABLE_LINK      = (1 << 3),
302
 
303
        ATA_EH_RESET_MASK       = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
304
        ATA_EH_PERDEV_MASK      = ATA_EH_REVALIDATE,
305
 
306
        /* ata_eh_info->flags */
307
        ATA_EHI_HOTPLUGGED      = (1 << 0),  /* could have been hotplugged */
308
        ATA_EHI_RESUME_LINK     = (1 << 1),  /* resume link (reset modifier) */
309
        ATA_EHI_NO_AUTOPSY      = (1 << 2),  /* no autopsy */
310
        ATA_EHI_QUIET           = (1 << 3),  /* be quiet */
311
        ATA_EHI_LPM             = (1 << 4),  /* link power management action */
312
 
313
        ATA_EHI_DID_SOFTRESET   = (1 << 16), /* already soft-reset this port */
314
        ATA_EHI_DID_HARDRESET   = (1 << 17), /* already soft-reset this port */
315
        ATA_EHI_PRINTINFO       = (1 << 18), /* print configuration info */
316
        ATA_EHI_SETMODE         = (1 << 19), /* configure transfer mode */
317
        ATA_EHI_POST_SETMODE    = (1 << 20), /* revaildating after setmode */
318
 
319
        ATA_EHI_DID_RESET       = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
320
        ATA_EHI_RESET_MODIFIER_MASK = ATA_EHI_RESUME_LINK,
321
 
322
        /* max tries if error condition is still set after ->error_handler */
323
        ATA_EH_MAX_TRIES        = 5,
324
 
325
        /* how hard are we gonna try to probe/recover devices */
326
        ATA_PROBE_MAX_TRIES     = 3,
327
        ATA_EH_DEV_TRIES        = 3,
328
        ATA_EH_PMP_TRIES        = 5,
329
        ATA_EH_PMP_LINK_TRIES   = 3,
330
 
331
        SATA_PMP_SCR_TIMEOUT    = 250,
332
 
333
        /* Horkage types. May be set by libata or controller on drives
334
           (some horkage may be drive/controller pair dependant */
335
 
336
        ATA_HORKAGE_DIAGNOSTIC  = (1 << 0),      /* Failed boot diag */
337
        ATA_HORKAGE_NODMA       = (1 << 1),     /* DMA problems */
338
        ATA_HORKAGE_NONCQ       = (1 << 2),     /* Don't use NCQ */
339
        ATA_HORKAGE_MAX_SEC_128 = (1 << 3),     /* Limit max sects to 128 */
340
        ATA_HORKAGE_BROKEN_HPA  = (1 << 4),     /* Broken HPA */
341
        ATA_HORKAGE_SKIP_PM     = (1 << 5),     /* Skip PM operations */
342
        ATA_HORKAGE_HPA_SIZE    = (1 << 6),     /* native size off by one */
343
        ATA_HORKAGE_IPM         = (1 << 7),     /* Link PM problems */
344
        ATA_HORKAGE_IVB         = (1 << 8),     /* cbl det validity bit bugs */
345
        ATA_HORKAGE_STUCK_ERR   = (1 << 9),     /* stuck ERR on next PACKET */
346
 
347
         /* DMA mask for user DMA control: User visible values; DO NOT
348
            renumber */
349
        ATA_DMA_MASK_ATA        = (1 << 0),      /* DMA on ATA Disk */
350
        ATA_DMA_MASK_ATAPI      = (1 << 1),     /* DMA on ATAPI */
351
        ATA_DMA_MASK_CFA        = (1 << 2),     /* DMA on CF Card */
352
};
353
 
354
enum hsm_task_states {
355
        HSM_ST_IDLE,            /* no command on going */
356
        HSM_ST_FIRST,           /* (waiting the device to)
357
                                   write CDB or first data block */
358
        HSM_ST,                 /* (waiting the device to) transfer data */
359
        HSM_ST_LAST,            /* (waiting the device to) complete command */
360
        HSM_ST_ERR,             /* error */
361
};
362
 
363
enum ata_completion_errors {
364
        AC_ERR_DEV              = (1 << 0), /* device reported error */
365
        AC_ERR_HSM              = (1 << 1), /* host state machine violation */
366
        AC_ERR_TIMEOUT          = (1 << 2), /* timeout */
367
        AC_ERR_MEDIA            = (1 << 3), /* media error */
368
        AC_ERR_ATA_BUS          = (1 << 4), /* ATA bus error */
369
        AC_ERR_HOST_BUS         = (1 << 5), /* host bus error */
370
        AC_ERR_SYSTEM           = (1 << 6), /* system error */
371
        AC_ERR_INVALID          = (1 << 7), /* invalid argument */
372
        AC_ERR_OTHER            = (1 << 8), /* unknown */
373
        AC_ERR_NODEV_HINT       = (1 << 9), /* polling device detection hint */
374
        AC_ERR_NCQ              = (1 << 10), /* marker for offending NCQ qc */
375
};
376
 
377
/* forward declarations */
378
struct scsi_device;
379
struct ata_port_operations;
380
struct ata_port;
381
struct ata_link;
382
struct ata_queued_cmd;
383
 
384
/* typedefs */
385
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
386
typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);
387
typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
388
                              unsigned long deadline);
389
typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
390
 
391
/*
392
 * host pm policy: If you alter this, you also need to alter libata-scsi.c
393
 * (for the ascii descriptions)
394
 */
395
enum link_pm {
396
        NOT_AVAILABLE,
397
        MIN_POWER,
398
        MAX_PERFORMANCE,
399
        MEDIUM_POWER,
400
};
401
extern struct class_device_attribute class_device_attr_link_power_management_policy;
402
 
403
struct ata_ioports {
404
        void __iomem            *cmd_addr;
405
        void __iomem            *data_addr;
406
        void __iomem            *error_addr;
407
        void __iomem            *feature_addr;
408
        void __iomem            *nsect_addr;
409
        void __iomem            *lbal_addr;
410
        void __iomem            *lbam_addr;
411
        void __iomem            *lbah_addr;
412
        void __iomem            *device_addr;
413
        void __iomem            *status_addr;
414
        void __iomem            *command_addr;
415
        void __iomem            *altstatus_addr;
416
        void __iomem            *ctl_addr;
417
        void __iomem            *bmdma_addr;
418
        void __iomem            *scr_addr;
419
};
420
 
421
struct ata_host {
422
        spinlock_t              lock;
423
        struct device           *dev;
424
        void __iomem * const    *iomap;
425
        unsigned int            n_ports;
426
        void                    *private_data;
427
        const struct ata_port_operations *ops;
428
        unsigned long           flags;
429
#ifdef CONFIG_ATA_ACPI
430
        acpi_handle             acpi_handle;
431
#endif
432
        struct ata_port         *simplex_claimed;       /* channel owning the DMA */
433
        struct ata_port         *ports[0];
434
};
435
 
436
struct ata_queued_cmd {
437
        struct ata_port         *ap;
438
        struct ata_device       *dev;
439
 
440
        struct scsi_cmnd        *scsicmd;
441
        void                    (*scsidone)(struct scsi_cmnd *);
442
 
443
        struct ata_taskfile     tf;
444
        u8                      cdb[ATAPI_CDB_LEN];
445
 
446
        unsigned long           flags;          /* ATA_QCFLAG_xxx */
447
        unsigned int            tag;
448
        unsigned int            n_elem;
449
        unsigned int            n_iter;
450
        unsigned int            orig_n_elem;
451
 
452
        int                     dma_dir;
453
 
454
        unsigned int            pad_len;
455
        unsigned int            sect_size;
456
 
457
        unsigned int            nbytes;
458
        unsigned int            curbytes;
459
 
460
        struct scatterlist      *cursg;
461
        unsigned int            cursg_ofs;
462
 
463
        struct scatterlist      sgent;
464
        struct scatterlist      pad_sgent;
465
        void                    *buf_virt;
466
 
467
        /* DO NOT iterate over __sg manually, use ata_for_each_sg() */
468
        struct scatterlist      *__sg;
469
 
470
        unsigned int            err_mask;
471
        struct ata_taskfile     result_tf;
472
        ata_qc_cb_t             complete_fn;
473
 
474
        void                    *private_data;
475
        void                    *lldd_task;
476
};
477
 
478
struct ata_port_stats {
479
        unsigned long           unhandled_irq;
480
        unsigned long           idle_irq;
481
        unsigned long           rw_reqbuf;
482
};
483
 
484
struct ata_ering_entry {
485
        int                     is_io;
486
        unsigned int            err_mask;
487
        u64                     timestamp;
488
};
489
 
490
struct ata_ering {
491
        int                     cursor;
492
        struct ata_ering_entry  ring[ATA_ERING_SIZE];
493
};
494
 
495
struct ata_device {
496
        struct ata_link         *link;
497
        unsigned int            devno;          /* 0 or 1 */
498
        unsigned long           flags;          /* ATA_DFLAG_xxx */
499
        unsigned int            horkage;        /* List of broken features */
500
        struct scsi_device      *sdev;          /* attached SCSI device */
501
#ifdef CONFIG_ATA_ACPI
502
        acpi_handle             acpi_handle;
503
        union acpi_object       *gtf_cache;
504
#endif
505
        /* n_sector is used as CLEAR_OFFSET, read comment above CLEAR_OFFSET */
506
        u64                     n_sectors;      /* size of device, if ATA */
507
        unsigned int            class;          /* ATA_DEV_xxx */
508
 
509
        union {
510
                u16             id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
511
                u32             gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
512
        };
513
 
514
        u8                      pio_mode;
515
        u8                      dma_mode;
516
        u8                      xfer_mode;
517
        unsigned int            xfer_shift;     /* ATA_SHIFT_xxx */
518
 
519
        unsigned int            multi_count;    /* sectors count for
520
                                                   READ/WRITE MULTIPLE */
521
        unsigned int            max_sectors;    /* per-device max sectors */
522
        unsigned int            cdb_len;
523
 
524
        /* per-dev xfer mask */
525
        unsigned int            pio_mask;
526
        unsigned int            mwdma_mask;
527
        unsigned int            udma_mask;
528
 
529
        /* for CHS addressing */
530
        u16                     cylinders;      /* Number of cylinders */
531
        u16                     heads;          /* Number of heads */
532
        u16                     sectors;        /* Number of sectors per track */
533
 
534
        /* error history */
535
        struct ata_ering        ering;
536
        int                     spdn_cnt;
537
};
538
 
539
/* Offset into struct ata_device.  Fields above it are maintained
540
 * acress device init.  Fields below are zeroed.
541
 */
542
#define ATA_DEVICE_CLEAR_OFFSET         offsetof(struct ata_device, n_sectors)
543
 
544
struct ata_eh_info {
545
        struct ata_device       *dev;           /* offending device */
546
        u32                     serror;         /* SError from LLDD */
547
        unsigned int            err_mask;       /* port-wide err_mask */
548
        unsigned int            action;         /* ATA_EH_* action mask */
549
        unsigned int            dev_action[ATA_MAX_DEVICES]; /* dev EH action */
550
        unsigned int            flags;          /* ATA_EHI_* flags */
551
 
552
        unsigned int            probe_mask;
553
 
554
        char                    desc[ATA_EH_DESC_LEN];
555
        int                     desc_len;
556
};
557
 
558
struct ata_eh_context {
559
        struct ata_eh_info      i;
560
        int                     tries[ATA_MAX_DEVICES];
561
        unsigned int            classes[ATA_MAX_DEVICES];
562
        unsigned int            did_probe_mask;
563
};
564
 
565
struct ata_acpi_drive
566
{
567
        u32 pio;
568
        u32 dma;
569
} __packed;
570
 
571
struct ata_acpi_gtm {
572
        struct ata_acpi_drive drive[2];
573
        u32 flags;
574
} __packed;
575
 
576
struct ata_link {
577
        struct ata_port         *ap;
578
        int                     pmp;            /* port multiplier port # */
579
 
580
        unsigned int            active_tag;     /* active tag on this link */
581
        u32                     sactive;        /* active NCQ commands */
582
 
583
        unsigned int            flags;          /* ATA_LFLAG_xxx */
584
 
585
        unsigned int            hw_sata_spd_limit;
586
        unsigned int            sata_spd_limit;
587
        unsigned int            sata_spd;       /* current SATA PHY speed */
588
 
589
        /* record runtime error info, protected by host_set lock */
590
        struct ata_eh_info      eh_info;
591
        /* EH context */
592
        struct ata_eh_context   eh_context;
593
 
594
        struct ata_device       device[ATA_MAX_DEVICES];
595
};
596
 
597
struct ata_port {
598
        struct Scsi_Host        *scsi_host; /* our co-allocated scsi host */
599
        const struct ata_port_operations *ops;
600
        spinlock_t              *lock;
601
        unsigned long           flags;  /* ATA_FLAG_xxx */
602
        unsigned int            pflags; /* ATA_PFLAG_xxx */
603
        unsigned int            print_id; /* user visible unique port ID */
604
        unsigned int            port_no; /* 0 based port no. inside the host */
605
 
606
        struct ata_prd          *prd;    /* our SG list */
607
        dma_addr_t              prd_dma; /* and its DMA mapping */
608
 
609
        void                    *pad;   /* array of DMA pad buffers */
610
        dma_addr_t              pad_dma;
611
 
612
        struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
613
 
614
        u8                      ctl;    /* cache of ATA control register */
615
        u8                      last_ctl;       /* Cache last written value */
616
        unsigned int            pio_mask;
617
        unsigned int            mwdma_mask;
618
        unsigned int            udma_mask;
619
        unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
620
 
621
        struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
622
        unsigned long           qc_allocated;
623
        unsigned int            qc_active;
624
        int                     nr_active_links; /* #links with active qcs */
625
 
626
        struct ata_link         link;   /* host default link */
627
 
628
        int                     nr_pmp_links;   /* nr of available PMP links */
629
        struct ata_link         *pmp_link;      /* array of PMP links */
630
        struct ata_link         *excl_link;     /* for PMP qc exclusion */
631
 
632
        struct ata_port_stats   stats;
633
        struct ata_host         *host;
634
        struct device           *dev;
635
 
636
        void                    *port_task_data;
637
        struct delayed_work     port_task;
638
        struct delayed_work     hotplug_task;
639
        struct work_struct      scsi_rescan_task;
640
 
641
        unsigned int            hsm_task_state;
642
 
643
        u32                     msg_enable;
644
        struct list_head        eh_done_q;
645
        wait_queue_head_t       eh_wait_q;
646
        int                     eh_tries;
647
 
648
        pm_message_t            pm_mesg;
649
        int                     *pm_result;
650
        enum link_pm            pm_policy;
651
 
652
        struct timer_list       fastdrain_timer;
653
        unsigned long           fastdrain_cnt;
654
 
655
        void                    *private_data;
656
 
657
#ifdef CONFIG_ATA_ACPI
658
        acpi_handle             acpi_handle;
659
        struct ata_acpi_gtm     __acpi_init_gtm; /* use ata_acpi_init_gtm() */
660
#endif
661
        u8                      sector_buf[ATA_SECT_SIZE]; /* owned by EH */
662
};
663
 
664
struct ata_port_operations {
665
        void (*dev_config) (struct ata_device *);
666
 
667
        void (*set_piomode) (struct ata_port *, struct ata_device *);
668
        void (*set_dmamode) (struct ata_port *, struct ata_device *);
669
        unsigned long (*mode_filter) (struct ata_device *, unsigned long);
670
 
671
        void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
672
        void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
673
 
674
        void (*exec_command)(struct ata_port *ap, const struct ata_taskfile *tf);
675
        u8   (*check_status)(struct ata_port *ap);
676
        u8   (*check_altstatus)(struct ata_port *ap);
677
        void (*dev_select)(struct ata_port *ap, unsigned int device);
678
 
679
        void (*phy_reset) (struct ata_port *ap); /* obsolete */
680
        int  (*set_mode) (struct ata_link *link, struct ata_device **r_failed_dev);
681
 
682
        int (*cable_detect) (struct ata_port *ap);
683
 
684
        int  (*check_atapi_dma) (struct ata_queued_cmd *qc);
685
 
686
        void (*bmdma_setup) (struct ata_queued_cmd *qc);
687
        void (*bmdma_start) (struct ata_queued_cmd *qc);
688
 
689
        void (*data_xfer) (struct ata_device *, unsigned char *, unsigned int, int);
690
 
691
        int (*qc_defer) (struct ata_queued_cmd *qc);
692
        void (*qc_prep) (struct ata_queued_cmd *qc);
693
        unsigned int (*qc_issue) (struct ata_queued_cmd *qc);
694
 
695
        /* port multiplier */
696
        void (*pmp_attach) (struct ata_port *ap);
697
        void (*pmp_detach) (struct ata_port *ap);
698
 
699
        /* Error handlers.  ->error_handler overrides ->eng_timeout and
700
         * indicates that new-style EH is in place.
701
         */
702
        void (*eng_timeout) (struct ata_port *ap); /* obsolete */
703
 
704
        void (*freeze) (struct ata_port *ap);
705
        void (*thaw) (struct ata_port *ap);
706
        void (*error_handler) (struct ata_port *ap);
707
        void (*post_internal_cmd) (struct ata_queued_cmd *qc);
708
 
709
        irq_handler_t irq_handler;
710
        void (*irq_clear) (struct ata_port *);
711
        u8 (*irq_on) (struct ata_port *);
712
 
713
        int (*scr_read) (struct ata_port *ap, unsigned int sc_reg, u32 *val);
714
        int (*scr_write) (struct ata_port *ap, unsigned int sc_reg, u32 val);
715
 
716
        int (*port_suspend) (struct ata_port *ap, pm_message_t mesg);
717
        int (*port_resume) (struct ata_port *ap);
718
        int (*enable_pm) (struct ata_port *ap, enum link_pm policy);
719
        void (*disable_pm) (struct ata_port *ap);
720
        int (*port_start) (struct ata_port *ap);
721
        void (*port_stop) (struct ata_port *ap);
722
 
723
        void (*host_stop) (struct ata_host *host);
724
 
725
        void (*bmdma_stop) (struct ata_queued_cmd *qc);
726
        u8   (*bmdma_status) (struct ata_port *ap);
727
};
728
 
729
struct ata_port_info {
730
        struct scsi_host_template       *sht;
731
        unsigned long           flags;
732
        unsigned long           link_flags;
733
        unsigned long           pio_mask;
734
        unsigned long           mwdma_mask;
735
        unsigned long           udma_mask;
736
        const struct ata_port_operations *port_ops;
737
        irq_handler_t           irq_handler;
738
        void                    *private_data;
739
};
740
 
741
struct ata_timing {
742
        unsigned short mode;            /* ATA mode */
743
        unsigned short setup;           /* t1 */
744
        unsigned short act8b;           /* t2 for 8-bit I/O */
745
        unsigned short rec8b;           /* t2i for 8-bit I/O */
746
        unsigned short cyc8b;           /* t0 for 8-bit I/O */
747
        unsigned short active;          /* t2 or tD */
748
        unsigned short recover;         /* t2i or tK */
749
        unsigned short cycle;           /* t0 */
750
        unsigned short udma;            /* t2CYCTYP/2 */
751
};
752
 
753
#define FIT(v, vmin, vmax)      max_t(short, min_t(short, v, vmax), vmin)
754
 
755
extern const unsigned long sata_deb_timing_normal[];
756
extern const unsigned long sata_deb_timing_hotplug[];
757
extern const unsigned long sata_deb_timing_long[];
758
 
759
extern const struct ata_port_operations ata_dummy_port_ops;
760
extern const struct ata_port_info ata_dummy_port_info;
761
 
762
static inline const unsigned long *
763
sata_ehc_deb_timing(struct ata_eh_context *ehc)
764
{
765
        if (ehc->i.flags & ATA_EHI_HOTPLUGGED)
766
                return sata_deb_timing_hotplug;
767
        else
768
                return sata_deb_timing_normal;
769
}
770
 
771
static inline int ata_port_is_dummy(struct ata_port *ap)
772
{
773
        return ap->ops == &ata_dummy_port_ops;
774
}
775
 
776
extern void sata_print_link_status(struct ata_link *link);
777
extern void ata_port_probe(struct ata_port *);
778
extern void ata_bus_reset(struct ata_port *ap);
779
extern int sata_set_spd(struct ata_link *link);
780
extern int sata_link_debounce(struct ata_link *link,
781
                        const unsigned long *params, unsigned long deadline);
782
extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
783
                            unsigned long deadline);
784
extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
785
extern int ata_std_softreset(struct ata_link *link, unsigned int *classes,
786
                             unsigned long deadline);
787
extern int sata_link_hardreset(struct ata_link *link,
788
                        const unsigned long *timing, unsigned long deadline);
789
extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
790
                              unsigned long deadline);
791
extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
792
extern void ata_port_disable(struct ata_port *);
793
extern void ata_std_ports(struct ata_ioports *ioaddr);
794
 
795
extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
796
extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
797
                        const struct ata_port_info * const * ppi, int n_ports);
798
extern int ata_host_start(struct ata_host *host);
799
extern int ata_host_register(struct ata_host *host,
800
                             struct scsi_host_template *sht);
801
extern int ata_host_activate(struct ata_host *host, int irq,
802
                             irq_handler_t irq_handler, unsigned long irq_flags,
803
                             struct scsi_host_template *sht);
804
extern void ata_host_detach(struct ata_host *host);
805
extern void ata_host_init(struct ata_host *, struct device *,
806
                          unsigned long, const struct ata_port_operations *);
807
extern int ata_scsi_detect(struct scsi_host_template *sht);
808
extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
809
extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
810
extern void ata_sas_port_destroy(struct ata_port *);
811
extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
812
                                           struct ata_port_info *, struct Scsi_Host *);
813
extern int ata_sas_port_init(struct ata_port *);
814
extern int ata_sas_port_start(struct ata_port *ap);
815
extern void ata_sas_port_stop(struct ata_port *ap);
816
extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
817
extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
818
                            struct ata_port *ap);
819
extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
820
extern int sata_scr_valid(struct ata_link *link);
821
extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);
822
extern int sata_scr_write(struct ata_link *link, int reg, u32 val);
823
extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);
824
extern int ata_link_online(struct ata_link *link);
825
extern int ata_link_offline(struct ata_link *link);
826
#ifdef CONFIG_PM
827
extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
828
extern void ata_host_resume(struct ata_host *host);
829
#endif
830
extern int ata_ratelimit(void);
831
extern int ata_busy_sleep(struct ata_port *ap,
832
                          unsigned long timeout_pat, unsigned long timeout);
833
extern void ata_wait_after_reset(struct ata_port *ap, unsigned long deadline);
834
extern int ata_wait_ready(struct ata_port *ap, unsigned long deadline);
835
extern void ata_port_queue_task(struct ata_port *ap, work_func_t fn,
836
                                void *data, unsigned long delay);
837
extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
838
                             unsigned long interval_msec,
839
                             unsigned long timeout_msec);
840
extern unsigned int ata_dev_try_classify(struct ata_device *dev, int present,
841
                                         u8 *r_err);
842
 
843
/*
844
 * Default driver ops implementations
845
 */
846
extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
847
extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
848
extern void ata_tf_to_fis(const struct ata_taskfile *tf,
849
                          u8 pmp, int is_cmd, u8 *fis);
850
extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
851
extern void ata_noop_dev_select(struct ata_port *ap, unsigned int device);
852
extern void ata_std_dev_select(struct ata_port *ap, unsigned int device);
853
extern u8 ata_check_status(struct ata_port *ap);
854
extern u8 ata_altstatus(struct ata_port *ap);
855
extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
856
extern int ata_port_start(struct ata_port *ap);
857
extern int ata_sff_port_start(struct ata_port *ap);
858
extern irqreturn_t ata_interrupt(int irq, void *dev_instance);
859
extern void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
860
                          unsigned int buflen, int write_data);
861
extern void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
862
                                unsigned int buflen, int write_data);
863
extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
864
extern void ata_dumb_qc_prep(struct ata_queued_cmd *qc);
865
extern void ata_qc_prep(struct ata_queued_cmd *qc);
866
extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
867
extern unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc);
868
extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
869
                unsigned int buflen);
870
extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
871
                 unsigned int n_elem);
872
extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
873
extern void ata_dev_disable(struct ata_device *adev);
874
extern void ata_id_string(const u16 *id, unsigned char *s,
875
                          unsigned int ofs, unsigned int len);
876
extern void ata_id_c_string(const u16 *id, unsigned char *s,
877
                            unsigned int ofs, unsigned int len);
878
extern void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown);
879
extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
880
extern void ata_bmdma_start(struct ata_queued_cmd *qc);
881
extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
882
extern u8   ata_bmdma_status(struct ata_port *ap);
883
extern void ata_bmdma_irq_clear(struct ata_port *ap);
884
extern void ata_bmdma_freeze(struct ata_port *ap);
885
extern void ata_bmdma_thaw(struct ata_port *ap);
886
extern void ata_bmdma_drive_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
887
                               ata_reset_fn_t softreset,
888
                               ata_reset_fn_t hardreset,
889
                               ata_postreset_fn_t postreset);
890
extern void ata_bmdma_error_handler(struct ata_port *ap);
891
extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
892
extern int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
893
                        u8 status, int in_wq);
894
extern void ata_qc_complete(struct ata_queued_cmd *qc);
895
extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
896
                                    void (*finish_qc)(struct ata_queued_cmd *));
897
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
898
                              void (*done)(struct scsi_cmnd *));
899
extern int ata_std_bios_param(struct scsi_device *sdev,
900
                              struct block_device *bdev,
901
                              sector_t capacity, int geom[]);
902
extern int ata_scsi_slave_config(struct scsi_device *sdev);
903
extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
904
extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
905
                                       int queue_depth);
906
extern struct ata_device *ata_dev_pair(struct ata_device *adev);
907
extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
908
extern u8 ata_irq_on(struct ata_port *ap);
909
 
910
extern int ata_cable_40wire(struct ata_port *ap);
911
extern int ata_cable_80wire(struct ata_port *ap);
912
extern int ata_cable_sata(struct ata_port *ap);
913
extern int ata_cable_unknown(struct ata_port *ap);
914
 
915
/*
916
 * Timing helpers
917
 */
918
 
919
extern unsigned int ata_pio_need_iordy(const struct ata_device *);
920
extern int ata_timing_compute(struct ata_device *, unsigned short,
921
                              struct ata_timing *, int, int);
922
extern void ata_timing_merge(const struct ata_timing *,
923
                             const struct ata_timing *, struct ata_timing *,
924
                             unsigned int);
925
 
926
enum {
927
        ATA_TIMING_SETUP        = (1 << 0),
928
        ATA_TIMING_ACT8B        = (1 << 1),
929
        ATA_TIMING_REC8B        = (1 << 2),
930
        ATA_TIMING_CYC8B        = (1 << 3),
931
        ATA_TIMING_8BIT         = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
932
                                  ATA_TIMING_CYC8B,
933
        ATA_TIMING_ACTIVE       = (1 << 4),
934
        ATA_TIMING_RECOVER      = (1 << 5),
935
        ATA_TIMING_CYCLE        = (1 << 6),
936
        ATA_TIMING_UDMA         = (1 << 7),
937
        ATA_TIMING_ALL          = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
938
                                  ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
939
                                  ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
940
                                  ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
941
};
942
 
943
/* libata-acpi.c */
944
#ifdef CONFIG_ATA_ACPI
945
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
946
{
947
        if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID)
948
                return &ap->__acpi_init_gtm;
949
        return NULL;
950
}
951
extern int ata_acpi_cbl_80wire(struct ata_port *ap);
952
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);
953
int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);
954
#else
955
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
956
{
957
        return NULL;
958
}
959
static inline int ata_acpi_cbl_80wire(struct ata_port *ap) { return 0; }
960
#endif
961
 
962
#ifdef CONFIG_PCI
963
struct pci_dev;
964
 
965
extern int ata_pci_init_one(struct pci_dev *pdev,
966
                             const struct ata_port_info * const * ppi);
967
extern void ata_pci_remove_one(struct pci_dev *pdev);
968
#ifdef CONFIG_PM
969
extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
970
extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
971
extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
972
extern int ata_pci_device_resume(struct pci_dev *pdev);
973
#endif
974
extern int ata_pci_clear_simplex(struct pci_dev *pdev);
975
 
976
struct pci_bits {
977
        unsigned int            reg;    /* PCI config register to read */
978
        unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
979
        unsigned long           mask;
980
        unsigned long           val;
981
};
982
 
983
extern int ata_pci_init_sff_host(struct ata_host *host);
984
extern int ata_pci_init_bmdma(struct ata_host *host);
985
extern int ata_pci_prepare_sff_host(struct pci_dev *pdev,
986
                                    const struct ata_port_info * const * ppi,
987
                                    struct ata_host **r_host);
988
extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
989
extern unsigned long ata_pci_default_filter(struct ata_device *, unsigned long);
990
#endif /* CONFIG_PCI */
991
 
992
/*
993
 * PMP
994
 */
995
extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc);
996
extern int sata_pmp_std_prereset(struct ata_link *link, unsigned long deadline);
997
extern int sata_pmp_std_hardreset(struct ata_link *link, unsigned int *class,
998
                                  unsigned long deadline);
999
extern void sata_pmp_std_postreset(struct ata_link *link, unsigned int *class);
1000
extern void sata_pmp_do_eh(struct ata_port *ap,
1001
                ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
1002
                ata_reset_fn_t hardreset, ata_postreset_fn_t postreset,
1003
                ata_prereset_fn_t pmp_prereset, ata_reset_fn_t pmp_softreset,
1004
                ata_reset_fn_t pmp_hardreset, ata_postreset_fn_t pmp_postreset);
1005
 
1006
/*
1007
 * EH
1008
 */
1009
extern void ata_port_schedule_eh(struct ata_port *ap);
1010
extern int ata_link_abort(struct ata_link *link);
1011
extern int ata_port_abort(struct ata_port *ap);
1012
extern int ata_port_freeze(struct ata_port *ap);
1013
extern int sata_async_notification(struct ata_port *ap);
1014
 
1015
extern void ata_eh_freeze_port(struct ata_port *ap);
1016
extern void ata_eh_thaw_port(struct ata_port *ap);
1017
 
1018
extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
1019
extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
1020
 
1021
extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
1022
                      ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
1023
                      ata_postreset_fn_t postreset);
1024
 
1025
/*
1026
 * printk helpers
1027
 */
1028
#define ata_port_printk(ap, lv, fmt, args...) \
1029
        printk("%sata%u: "fmt, lv, (ap)->print_id , ##args)
1030
 
1031
#define ata_link_printk(link, lv, fmt, args...) do { \
1032
        if ((link)->ap->nr_pmp_links) \
1033
                printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id,   \
1034
                       (link)->pmp , ##args); \
1035
        else \
1036
                printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
1037
        } while(0)
1038
 
1039
#define ata_dev_printk(dev, lv, fmt, args...) \
1040
        printk("%sata%u.%02u: "fmt, lv, (dev)->link->ap->print_id,      \
1041
               (dev)->link->pmp + (dev)->devno , ##args)
1042
 
1043
/*
1044
 * ata_eh_info helpers
1045
 */
1046
extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
1047
        __attribute__ ((format (printf, 2, 3)));
1048
extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
1049
        __attribute__ ((format (printf, 2, 3)));
1050
extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
1051
 
1052
static inline void ata_ehi_schedule_probe(struct ata_eh_info *ehi)
1053
{
1054
        ehi->flags |= ATA_EHI_RESUME_LINK;
1055
        ehi->action |= ATA_EH_SOFTRESET;
1056
        ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
1057
}
1058
 
1059
static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
1060
{
1061
        ata_ehi_schedule_probe(ehi);
1062
        ehi->flags |= ATA_EHI_HOTPLUGGED;
1063
        ehi->action |= ATA_EH_ENABLE_LINK;
1064
        ehi->err_mask |= AC_ERR_ATA_BUS;
1065
}
1066
 
1067
/*
1068
 * port description helpers
1069
 */
1070
extern void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
1071
        __attribute__ ((format (printf, 2, 3)));
1072
#ifdef CONFIG_PCI
1073
extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
1074
                               const char *name);
1075
#endif
1076
 
1077
/*
1078
 * qc helpers
1079
 */
1080
static inline struct scatterlist *
1081
ata_qc_first_sg(struct ata_queued_cmd *qc)
1082
{
1083
        qc->n_iter = 0;
1084
        if (qc->n_elem)
1085
                return qc->__sg;
1086
        if (qc->pad_len)
1087
                return &qc->pad_sgent;
1088
        return NULL;
1089
}
1090
 
1091
static inline struct scatterlist *
1092
ata_qc_next_sg(struct scatterlist *sg, struct ata_queued_cmd *qc)
1093
{
1094
        if (sg == &qc->pad_sgent)
1095
                return NULL;
1096
        if (++qc->n_iter < qc->n_elem)
1097
                return sg_next(sg);
1098
        if (qc->pad_len)
1099
                return &qc->pad_sgent;
1100
        return NULL;
1101
}
1102
 
1103
#define ata_for_each_sg(sg, qc) \
1104
        for (sg = ata_qc_first_sg(qc); sg; sg = ata_qc_next_sg(sg, qc))
1105
 
1106
static inline unsigned int ata_tag_valid(unsigned int tag)
1107
{
1108
        return (tag < ATA_MAX_QUEUE) ? 1 : 0;
1109
}
1110
 
1111
static inline unsigned int ata_tag_internal(unsigned int tag)
1112
{
1113
        return tag == ATA_MAX_QUEUE - 1;
1114
}
1115
 
1116
/*
1117
 * device helpers
1118
 */
1119
static inline unsigned int ata_class_enabled(unsigned int class)
1120
{
1121
        return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
1122
                class == ATA_DEV_PMP || class == ATA_DEV_SEMB;
1123
}
1124
 
1125
static inline unsigned int ata_class_disabled(unsigned int class)
1126
{
1127
        return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP ||
1128
                class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP;
1129
}
1130
 
1131
static inline unsigned int ata_class_absent(unsigned int class)
1132
{
1133
        return !ata_class_enabled(class) && !ata_class_disabled(class);
1134
}
1135
 
1136
static inline unsigned int ata_dev_enabled(const struct ata_device *dev)
1137
{
1138
        return ata_class_enabled(dev->class);
1139
}
1140
 
1141
static inline unsigned int ata_dev_disabled(const struct ata_device *dev)
1142
{
1143
        return ata_class_disabled(dev->class);
1144
}
1145
 
1146
static inline unsigned int ata_dev_absent(const struct ata_device *dev)
1147
{
1148
        return ata_class_absent(dev->class);
1149
}
1150
 
1151
/*
1152
 * link helpers
1153
 */
1154
static inline int ata_is_host_link(const struct ata_link *link)
1155
{
1156
        return link == &link->ap->link;
1157
}
1158
 
1159
static inline int ata_link_max_devices(const struct ata_link *link)
1160
{
1161
        if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
1162
                return 2;
1163
        return 1;
1164
}
1165
 
1166
static inline int ata_link_active(struct ata_link *link)
1167
{
1168
        return ata_tag_valid(link->active_tag) || link->sactive;
1169
}
1170
 
1171
static inline struct ata_link *ata_port_first_link(struct ata_port *ap)
1172
{
1173
        if (ap->nr_pmp_links)
1174
                return ap->pmp_link;
1175
        return &ap->link;
1176
}
1177
 
1178
static inline struct ata_link *ata_port_next_link(struct ata_link *link)
1179
{
1180
        struct ata_port *ap = link->ap;
1181
 
1182
        if (link == &ap->link) {
1183
                if (!ap->nr_pmp_links)
1184
                        return NULL;
1185
                return ap->pmp_link;
1186
        }
1187
 
1188
        if (++link - ap->pmp_link < ap->nr_pmp_links)
1189
                return link;
1190
        return NULL;
1191
}
1192
 
1193
#define __ata_port_for_each_link(lk, ap) \
1194
        for ((lk) = &(ap)->link; (lk); (lk) = ata_port_next_link(lk))
1195
 
1196
#define ata_port_for_each_link(link, ap) \
1197
        for ((link) = ata_port_first_link(ap); (link); \
1198
             (link) = ata_port_next_link(link))
1199
 
1200
#define ata_link_for_each_dev(dev, link) \
1201
        for ((dev) = (link)->device; \
1202
             (dev) < (link)->device + ata_link_max_devices(link) || ((dev) = NULL); \
1203
             (dev)++)
1204
 
1205
#define ata_link_for_each_dev_reverse(dev, link) \
1206
        for ((dev) = (link)->device + ata_link_max_devices(link) - 1; \
1207
             (dev) >= (link)->device || ((dev) = NULL); (dev)--)
1208
 
1209
static inline u8 ata_chk_status(struct ata_port *ap)
1210
{
1211
        return ap->ops->check_status(ap);
1212
}
1213
 
1214
/**
1215
 *      ata_ncq_enabled - Test whether NCQ is enabled
1216
 *      @dev: ATA device to test for
1217
 *
1218
 *      LOCKING:
1219
 *      spin_lock_irqsave(host lock)
1220
 *
1221
 *      RETURNS:
1222
 *      1 if NCQ is enabled for @dev, 0 otherwise.
1223
 */
1224
static inline int ata_ncq_enabled(struct ata_device *dev)
1225
{
1226
        return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
1227
                              ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;
1228
}
1229
 
1230
/**
1231
 *      ata_pause - Flush writes and pause 400 nanoseconds.
1232
 *      @ap: Port to wait for.
1233
 *
1234
 *      LOCKING:
1235
 *      Inherited from caller.
1236
 */
1237
 
1238
static inline void ata_pause(struct ata_port *ap)
1239
{
1240
        ata_altstatus(ap);
1241
        ndelay(400);
1242
}
1243
 
1244
 
1245
/**
1246
 *      ata_busy_wait - Wait for a port status register
1247
 *      @ap: Port to wait for.
1248
 *      @bits: bits that must be clear
1249
 *      @max: number of 10uS waits to perform
1250
 *
1251
 *      Waits up to max*10 microseconds for the selected bits in the port's
1252
 *      status register to be cleared.
1253
 *      Returns final value of status register.
1254
 *
1255
 *      LOCKING:
1256
 *      Inherited from caller.
1257
 */
1258
 
1259
static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
1260
                               unsigned int max)
1261
{
1262
        u8 status;
1263
 
1264
        do {
1265
                udelay(10);
1266
                status = ata_chk_status(ap);
1267
                max--;
1268
        } while (status != 0xff && (status & bits) && (max > 0));
1269
 
1270
        return status;
1271
}
1272
 
1273
 
1274
/**
1275
 *      ata_wait_idle - Wait for a port to be idle.
1276
 *      @ap: Port to wait for.
1277
 *
1278
 *      Waits up to 10ms for port's BUSY and DRQ signals to clear.
1279
 *      Returns final value of status register.
1280
 *
1281
 *      LOCKING:
1282
 *      Inherited from caller.
1283
 */
1284
 
1285
static inline u8 ata_wait_idle(struct ata_port *ap)
1286
{
1287
        u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
1288
 
1289
#ifdef ATA_DEBUG
1290
        if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ)))
1291
                ata_port_printk(ap, KERN_DEBUG, "abnormal Status 0x%X\n",
1292
                                status);
1293
#endif
1294
 
1295
        return status;
1296
}
1297
 
1298
static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
1299
{
1300
        qc->tf.ctl |= ATA_NIEN;
1301
}
1302
 
1303
static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
1304
                                                       unsigned int tag)
1305
{
1306
        if (likely(ata_tag_valid(tag)))
1307
                return &ap->qcmd[tag];
1308
        return NULL;
1309
}
1310
 
1311
static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
1312
                                                     unsigned int tag)
1313
{
1314
        struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1315
 
1316
        if (unlikely(!qc) || !ap->ops->error_handler)
1317
                return qc;
1318
 
1319
        if ((qc->flags & (ATA_QCFLAG_ACTIVE |
1320
                          ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE)
1321
                return qc;
1322
 
1323
        return NULL;
1324
}
1325
 
1326
static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
1327
{
1328
        memset(tf, 0, sizeof(*tf));
1329
 
1330
        tf->ctl = dev->link->ap->ctl;
1331
        if (dev->devno == 0)
1332
                tf->device = ATA_DEVICE_OBS;
1333
        else
1334
                tf->device = ATA_DEVICE_OBS | ATA_DEV1;
1335
}
1336
 
1337
static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
1338
{
1339
        qc->dma_dir = DMA_NONE;
1340
        qc->__sg = NULL;
1341
        qc->flags = 0;
1342
        qc->cursg = NULL;
1343
        qc->cursg_ofs = 0;
1344
        qc->nbytes = qc->curbytes = 0;
1345
        qc->n_elem = 0;
1346
        qc->n_iter = 0;
1347
        qc->err_mask = 0;
1348
        qc->pad_len = 0;
1349
        qc->sect_size = ATA_SECT_SIZE;
1350
 
1351
        ata_tf_init(qc->dev, &qc->tf);
1352
 
1353
        /* init result_tf such that it indicates normal completion */
1354
        qc->result_tf.command = ATA_DRDY;
1355
        qc->result_tf.feature = 0;
1356
}
1357
 
1358
static inline int ata_try_flush_cache(const struct ata_device *dev)
1359
{
1360
        return ata_id_wcache_enabled(dev->id) ||
1361
               ata_id_has_flush(dev->id) ||
1362
               ata_id_has_flush_ext(dev->id);
1363
}
1364
 
1365
static inline unsigned int ac_err_mask(u8 status)
1366
{
1367
        if (status & (ATA_BUSY | ATA_DRQ))
1368
                return AC_ERR_HSM;
1369
        if (status & (ATA_ERR | ATA_DF))
1370
                return AC_ERR_DEV;
1371
        return 0;
1372
}
1373
 
1374
static inline unsigned int __ac_err_mask(u8 status)
1375
{
1376
        unsigned int mask = ac_err_mask(status);
1377
        if (mask == 0)
1378
                return AC_ERR_OTHER;
1379
        return mask;
1380
}
1381
 
1382
static inline int ata_pad_alloc(struct ata_port *ap, struct device *dev)
1383
{
1384
        ap->pad_dma = 0;
1385
        ap->pad = dmam_alloc_coherent(dev, ATA_DMA_PAD_BUF_SZ,
1386
                                      &ap->pad_dma, GFP_KERNEL);
1387
        return (ap->pad == NULL) ? -ENOMEM : 0;
1388
}
1389
 
1390
static inline void ata_pad_free(struct ata_port *ap, struct device *dev)
1391
{
1392
        dmam_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
1393
}
1394
 
1395
static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host)
1396
{
1397
        return *(struct ata_port **)&host->hostdata[0];
1398
}
1399
 
1400
#endif /* __LINUX_LIBATA_H__ */

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.