← Back to branch summary

~ubuntu-branches/ubuntu/maverick/u-boot-omap3/maverick

« back to all changes in this revision

Viewing changes to drivers/block/sata_dwc.h

  • Committer: Bazaar Package Importer
  • Author(s): Oliver Grawert
  • Date: 2010-03-22 15:06:23 UTC
  • Revision ID: james.westby@ubuntu.com-20100322150623-i21g8rgiyl5dohag
Tags: upstream-2010.3git20100315
Import upstream version 2010.3git20100315

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/block/sata_dwc.h
 
1
/*
 
2
 * sata_dwc.h
 
3
 *
 
4
 * Synopsys DesignWare Cores (DWC) SATA host driver
 
5
 *
 
6
 * Author: Mark Miesfeld <mmiesfeld@amcc.com>
 
7
 *
 
8
 * Ported from 2.6.19.2 to 2.6.25/26 by Stefan Roese <sr@denx.de>
 
9
 * Copyright 2008 DENX Software Engineering
 
10
 *
 
11
 * Based on versions provided by AMCC and Synopsys which are:
 
12
 *          Copyright 2006 Applied Micro Circuits Corporation
 
13
 *          COPYRIGHT (C) 2005  SYNOPSYS, INC.  ALL RIGHTS RESERVED
 
14
 *
 
15
 * This program is free software; you can redistribute
 
16
 * it and/or modify it under  the terms of  the GNU
 
17
 * General  Public License as published by the
 
18
 * Free Software Foundation;  either version 2 of the  License,
 
19
 * or (at your option) any later version.
 
20
 *
 
21
 */
 
22
/*
 
23
 * SATA support based on the chip canyonlands.
 
24
 *
 
25
 * 04-17-2009
 
26
 *              The local version of this driver for the canyonlands board
 
27
 *              does not use interrupts but polls the chip instead.
 
28
 */
 
29
 
 
30
 
 
31
#ifndef _SATA_DWC_H_
 
32
#define _SATA_DWC_H_
 
33
 
 
34
#define __U_BOOT__
 
35
 
 
36
#define HZ 100
 
37
#define READ 0
 
38
#define WRITE 1
 
39
 
 
40
enum {
 
41
        ATA_READID_POSTRESET    = (1 << 0),
 
42
 
 
43
        ATA_DNXFER_PIO          = 0,
 
44
        ATA_DNXFER_DMA          = 1,
 
45
        ATA_DNXFER_40C          = 2,
 
46
        ATA_DNXFER_FORCE_PIO    = 3,
 
47
        ATA_DNXFER_FORCE_PIO0   = 4,
 
48
 
 
49
        ATA_DNXFER_QUIET        = (1 << 31),
 
50
};
 
51
 
 
52
enum hsm_task_states {
 
53
        HSM_ST_IDLE,
 
54
        HSM_ST_FIRST,
 
55
        HSM_ST,
 
56
        HSM_ST_LAST,
 
57
        HSM_ST_ERR,
 
58
};
 
59
 
 
60
#define ATA_SHORT_PAUSE         ((HZ >> 6) + 1)
 
61
 
 
62
struct ata_queued_cmd {
 
63
        struct ata_port         *ap;
 
64
        struct ata_device       *dev;
 
65
 
 
66
        struct ata_taskfile     tf;
 
67
        u8                      cdb[ATAPI_CDB_LEN];
 
68
        unsigned long           flags;
 
69
        unsigned int            tag;
 
70
        unsigned int            n_elem;
 
71
 
 
72
        int                     dma_dir;
 
73
        unsigned int            sect_size;
 
74
 
 
75
        unsigned int            nbytes;
 
76
        unsigned int            extrabytes;
 
77
        unsigned int            curbytes;
 
78
 
 
79
        unsigned int            err_mask;
 
80
        struct ata_taskfile     result_tf;
 
81
 
 
82
        void                    *private_data;
 
83
#ifndef __U_BOOT__
 
84
        void                    *lldd_task;
 
85
#endif
 
86
        unsigned char           *pdata;
 
87
};
 
88
 
 
89
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
 
90
 
 
91
#define ATA_TAG_POISON  0xfafbfcfdU
 
92
 
 
93
enum {
 
94
        LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
 
95
        LIBATA_DUMB_MAX_PRD     = ATA_MAX_PRD / 4,
 
96
        ATA_MAX_PORTS           = 8,
 
97
        ATA_DEF_QUEUE           = 1,
 
98
        ATA_MAX_QUEUE           = 32,
 
99
        ATA_TAG_INTERNAL        = ATA_MAX_QUEUE - 1,
 
100
        ATA_MAX_BUS             = 2,
 
101
        ATA_DEF_BUSY_WAIT       = 10000,
 
102
 
 
103
        ATAPI_MAX_DRAIN         = 16 << 10,
 
104
 
 
105
        ATA_SHT_EMULATED        = 1,
 
106
        ATA_SHT_CMD_PER_LUN     = 1,
 
107
        ATA_SHT_THIS_ID         = -1,
 
108
        ATA_SHT_USE_CLUSTERING  = 1,
 
109
 
 
110
        ATA_DFLAG_LBA           = (1 << 0),
 
111
        ATA_DFLAG_LBA48         = (1 << 1),
 
112
        ATA_DFLAG_CDB_INTR      = (1 << 2),
 
113
        ATA_DFLAG_NCQ           = (1 << 3),
 
114
        ATA_DFLAG_FLUSH_EXT     = (1 << 4),
 
115
        ATA_DFLAG_ACPI_PENDING  = (1 << 5),
 
116
        ATA_DFLAG_ACPI_FAILED   = (1 << 6),
 
117
        ATA_DFLAG_AN            = (1 << 7),
 
118
        ATA_DFLAG_HIPM          = (1 << 8),
 
119
        ATA_DFLAG_DIPM          = (1 << 9),
 
120
        ATA_DFLAG_DMADIR        = (1 << 10),
 
121
        ATA_DFLAG_CFG_MASK      = (1 << 12) - 1,
 
122
 
 
123
        ATA_DFLAG_PIO           = (1 << 12),
 
124
        ATA_DFLAG_NCQ_OFF       = (1 << 13),
 
125
        ATA_DFLAG_SPUNDOWN      = (1 << 14),
 
126
        ATA_DFLAG_SLEEPING      = (1 << 15),
 
127
        ATA_DFLAG_DUBIOUS_XFER  = (1 << 16),
 
128
        ATA_DFLAG_INIT_MASK     = (1 << 24) - 1,
 
129
 
 
130
        ATA_DFLAG_DETACH        = (1 << 24),
 
131
        ATA_DFLAG_DETACHED      = (1 << 25),
 
132
 
 
133
        ATA_LFLAG_HRST_TO_RESUME        = (1 << 0),
 
134
        ATA_LFLAG_SKIP_D2H_BSY          = (1 << 1),
 
135
        ATA_LFLAG_NO_SRST               = (1 << 2),
 
136
        ATA_LFLAG_ASSUME_ATA            = (1 << 3),
 
137
        ATA_LFLAG_ASSUME_SEMB           = (1 << 4),
 
138
        ATA_LFLAG_ASSUME_CLASS = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
 
139
        ATA_LFLAG_NO_RETRY              = (1 << 5),
 
140
        ATA_LFLAG_DISABLED              = (1 << 6),
 
141
 
 
142
        ATA_FLAG_SLAVE_POSS     = (1 << 0),
 
143
        ATA_FLAG_SATA           = (1 << 1),
 
144
        ATA_FLAG_NO_LEGACY      = (1 << 2),
 
145
        ATA_FLAG_MMIO           = (1 << 3),
 
146
        ATA_FLAG_SRST           = (1 << 4),
 
147
        ATA_FLAG_SATA_RESET     = (1 << 5),
 
148
        ATA_FLAG_NO_ATAPI       = (1 << 6),
 
149
        ATA_FLAG_PIO_DMA        = (1 << 7),
 
150
        ATA_FLAG_PIO_LBA48      = (1 << 8),
 
151
        ATA_FLAG_PIO_POLLING    = (1 << 9),
 
152
        ATA_FLAG_NCQ            = (1 << 10),
 
153
        ATA_FLAG_DEBUGMSG       = (1 << 13),
 
154
        ATA_FLAG_IGN_SIMPLEX    = (1 << 15),
 
155
        ATA_FLAG_NO_IORDY       = (1 << 16),
 
156
        ATA_FLAG_ACPI_SATA      = (1 << 17),
 
157
        ATA_FLAG_AN             = (1 << 18),
 
158
        ATA_FLAG_PMP            = (1 << 19),
 
159
        ATA_FLAG_IPM            = (1 << 20),
 
160
 
 
161
        ATA_FLAG_DISABLED       = (1 << 23),
 
162
 
 
163
        ATA_PFLAG_EH_PENDING            = (1 << 0),
 
164
        ATA_PFLAG_EH_IN_PROGRESS        = (1 << 1),
 
165
        ATA_PFLAG_FROZEN                = (1 << 2),
 
166
        ATA_PFLAG_RECOVERED             = (1 << 3),
 
167
        ATA_PFLAG_LOADING               = (1 << 4),
 
168
        ATA_PFLAG_UNLOADING             = (1 << 5),
 
169
        ATA_PFLAG_SCSI_HOTPLUG          = (1 << 6),
 
170
        ATA_PFLAG_INITIALIZING          = (1 << 7),
 
171
        ATA_PFLAG_RESETTING             = (1 << 8),
 
172
        ATA_PFLAG_SUSPENDED             = (1 << 17),
 
173
        ATA_PFLAG_PM_PENDING            = (1 << 18),
 
174
 
 
175
        ATA_QCFLAG_ACTIVE       = (1 << 0),
 
176
        ATA_QCFLAG_DMAMAP       = (1 << 1),
 
177
        ATA_QCFLAG_IO           = (1 << 3),
 
178
        ATA_QCFLAG_RESULT_TF    = (1 << 4),
 
179
        ATA_QCFLAG_CLEAR_EXCL   = (1 << 5),
 
180
        ATA_QCFLAG_QUIET        = (1 << 6),
 
181
 
 
182
        ATA_QCFLAG_FAILED       = (1 << 16),
 
183
        ATA_QCFLAG_SENSE_VALID  = (1 << 17),
 
184
        ATA_QCFLAG_EH_SCHEDULED = (1 << 18),
 
185
 
 
186
        ATA_HOST_SIMPLEX        = (1 << 0),
 
187
        ATA_HOST_STARTED        = (1 << 1),
 
188
 
 
189
        ATA_TMOUT_BOOT                  = 30 * 100,
 
190
        ATA_TMOUT_BOOT_QUICK            = 7 * 100,
 
191
        ATA_TMOUT_INTERNAL              = 30 * 100,
 
192
        ATA_TMOUT_INTERNAL_QUICK        = 5 * 100,
 
193
 
 
194
        /* FIXME: GoVault needs 2s but we can't afford that without
 
195
         * parallel probing.  800ms is enough for iVDR disk
 
196
         * HHD424020F7SV00.  Increase to 2secs when parallel probing
 
197
         * is in place.
 
198
         */
 
199
        ATA_TMOUT_FF_WAIT       = 4 * 100 / 5,
 
200
 
 
201
        BUS_UNKNOWN             = 0,
 
202
        BUS_DMA                 = 1,
 
203
        BUS_IDLE                = 2,
 
204
        BUS_NOINTR              = 3,
 
205
        BUS_NODATA              = 4,
 
206
        BUS_TIMER               = 5,
 
207
        BUS_PIO                 = 6,
 
208
        BUS_EDD                 = 7,
 
209
        BUS_IDENTIFY            = 8,
 
210
        BUS_PACKET              = 9,
 
211
 
 
212
        PORT_UNKNOWN            = 0,
 
213
        PORT_ENABLED            = 1,
 
214
        PORT_DISABLED           = 2,
 
215
 
 
216
        /* encoding various smaller bitmaps into a single
 
217
         * unsigned long bitmap
 
218
         */
 
219
        ATA_NR_PIO_MODES        = 7,
 
220
        ATA_NR_MWDMA_MODES      = 5,
 
221
        ATA_NR_UDMA_MODES       = 8,
 
222
 
 
223
        ATA_SHIFT_PIO           = 0,
 
224
        ATA_SHIFT_MWDMA         = ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
 
225
        ATA_SHIFT_UDMA          = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,
 
226
 
 
227
        ATA_DMA_PAD_SZ          = 4,
 
228
 
 
229
        ATA_ERING_SIZE          = 32,
 
230
 
 
231
        ATA_DEFER_LINK          = 1,
 
232
        ATA_DEFER_PORT          = 2,
 
233
 
 
234
        ATA_EH_DESC_LEN         = 80,
 
235
 
 
236
        ATA_EH_REVALIDATE       = (1 << 0),
 
237
        ATA_EH_SOFTRESET        = (1 << 1),
 
238
        ATA_EH_HARDRESET        = (1 << 2),
 
239
        ATA_EH_ENABLE_LINK      = (1 << 3),
 
240
        ATA_EH_LPM              = (1 << 4),
 
241
 
 
242
        ATA_EH_RESET_MASK       = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
 
243
        ATA_EH_PERDEV_MASK      = ATA_EH_REVALIDATE,
 
244
 
 
245
        ATA_EHI_HOTPLUGGED      = (1 << 0),
 
246
        ATA_EHI_RESUME_LINK     = (1 << 1),
 
247
        ATA_EHI_NO_AUTOPSY      = (1 << 2),
 
248
        ATA_EHI_QUIET           = (1 << 3),
 
249
 
 
250
        ATA_EHI_DID_SOFTRESET   = (1 << 16),
 
251
        ATA_EHI_DID_HARDRESET   = (1 << 17),
 
252
        ATA_EHI_PRINTINFO       = (1 << 18),
 
253
        ATA_EHI_SETMODE         = (1 << 19),
 
254
        ATA_EHI_POST_SETMODE    = (1 << 20),
 
255
 
 
256
        ATA_EHI_DID_RESET = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
 
257
        ATA_EHI_RESET_MODIFIER_MASK = ATA_EHI_RESUME_LINK,
 
258
 
 
259
        ATA_EH_MAX_TRIES        = 5,
 
260
 
 
261
        ATA_PROBE_MAX_TRIES     = 3,
 
262
        ATA_EH_DEV_TRIES        = 3,
 
263
        ATA_EH_PMP_TRIES        = 5,
 
264
        ATA_EH_PMP_LINK_TRIES   = 3,
 
265
 
 
266
        SATA_PMP_SCR_TIMEOUT    = 250,
 
267
 
 
268
        /* Horkage types. May be set by libata or controller on drives
 
269
        (some horkage may be drive/controller pair dependant */
 
270
 
 
271
        ATA_HORKAGE_DIAGNOSTIC  = (1 << 0),
 
272
        ATA_HORKAGE_NODMA       = (1 << 1),
 
273
        ATA_HORKAGE_NONCQ       = (1 << 2),
 
274
        ATA_HORKAGE_MAX_SEC_128 = (1 << 3),
 
275
        ATA_HORKAGE_BROKEN_HPA  = (1 << 4),
 
276
        ATA_HORKAGE_SKIP_PM     = (1 << 5),
 
277
        ATA_HORKAGE_HPA_SIZE    = (1 << 6),
 
278
        ATA_HORKAGE_IPM         = (1 << 7),
 
279
        ATA_HORKAGE_IVB         = (1 << 8),
 
280
        ATA_HORKAGE_STUCK_ERR   = (1 << 9),
 
281
 
 
282
        ATA_DMA_MASK_ATA        = (1 << 0),
 
283
        ATA_DMA_MASK_ATAPI      = (1 << 1),
 
284
        ATA_DMA_MASK_CFA        = (1 << 2),
 
285
 
 
286
        ATAPI_READ              = 0,
 
287
        ATAPI_WRITE             = 1,
 
288
        ATAPI_READ_CD           = 2,
 
289
        ATAPI_PASS_THRU         = 3,
 
290
        ATAPI_MISC              = 4,
 
291
};
 
292
 
 
293
enum ata_completion_errors {
 
294
        AC_ERR_DEV              = (1 << 0),
 
295
        AC_ERR_HSM              = (1 << 1),
 
296
        AC_ERR_TIMEOUT          = (1 << 2),
 
297
        AC_ERR_MEDIA            = (1 << 3),
 
298
        AC_ERR_ATA_BUS          = (1 << 4),
 
299
        AC_ERR_HOST_BUS         = (1 << 5),
 
300
        AC_ERR_SYSTEM           = (1 << 6),
 
301
        AC_ERR_INVALID          = (1 << 7),
 
302
        AC_ERR_OTHER            = (1 << 8),
 
303
        AC_ERR_NODEV_HINT       = (1 << 9),
 
304
        AC_ERR_NCQ              = (1 << 10),
 
305
};
 
306
 
 
307
enum ata_xfer_mask {
 
308
        ATA_MASK_PIO    = ((1LU << ATA_NR_PIO_MODES) - 1) << ATA_SHIFT_PIO,
 
309
        ATA_MASK_MWDMA  = ((1LU << ATA_NR_MWDMA_MODES) - 1) << ATA_SHIFT_MWDMA,
 
310
        ATA_MASK_UDMA   = ((1LU << ATA_NR_UDMA_MODES) - 1) << ATA_SHIFT_UDMA,
 
311
};
 
312
 
 
313
struct ata_port_info {
 
314
#ifndef __U_BOOT__
 
315
        struct scsi_host_template       *sht;
 
316
#endif
 
317
        unsigned long                   flags;
 
318
        unsigned long                   link_flags;
 
319
        unsigned long                   pio_mask;
 
320
        unsigned long                   mwdma_mask;
 
321
        unsigned long                   udma_mask;
 
322
#ifndef __U_BOOT__
 
323
        const struct ata_port_operations *port_ops;
 
324
        void                            *private_data;
 
325
#endif
 
326
};
 
327
 
 
328
struct ata_ioports {
 
329
        void __iomem            *cmd_addr;
 
330
        void __iomem            *data_addr;
 
331
        void __iomem            *error_addr;
 
332
        void __iomem            *feature_addr;
 
333
        void __iomem            *nsect_addr;
 
334
        void __iomem            *lbal_addr;
 
335
        void __iomem            *lbam_addr;
 
336
        void __iomem            *lbah_addr;
 
337
        void __iomem            *device_addr;
 
338
        void __iomem            *status_addr;
 
339
        void __iomem            *command_addr;
 
340
        void __iomem            *altstatus_addr;
 
341
        void __iomem            *ctl_addr;
 
342
#ifndef __U_BOOT__
 
343
        void __iomem            *bmdma_addr;
 
344
#endif
 
345
        void __iomem            *scr_addr;
 
346
};
 
347
 
 
348
struct ata_host {
 
349
#ifndef __U_BOOT__
 
350
        void __iomem * const    *iomap;
 
351
        void                    *private_data;
 
352
        const struct ata_port_operations *ops;
 
353
        unsigned long           flags;
 
354
        struct ata_port         *simplex_claimed;
 
355
#endif
 
356
        unsigned int            n_ports;
 
357
        struct ata_port         *ports[0];
 
358
};
 
359
 
 
360
#ifndef __U_BOOT__
 
361
struct ata_port_stats {
 
362
        unsigned long           unhandled_irq;
 
363
        unsigned long           idle_irq;
 
364
        unsigned long           rw_reqbuf;
 
365
};
 
366
#endif
 
367
 
 
368
struct ata_device {
 
369
        struct ata_link         *link;
 
370
        unsigned int            devno;
 
371
        unsigned long           flags;
 
372
        unsigned int            horkage;
 
373
#ifndef __U_BOOT__
 
374
        struct scsi_device      *sdev;
 
375
#ifdef CONFIG_ATA_ACPI
 
376
        acpi_handle             acpi_handle;
 
377
        union acpi_object       *gtf_cache;
 
378
#endif
 
379
#endif
 
380
        u64                     n_sectors;
 
381
        unsigned int            class;
 
382
 
 
383
        union {
 
384
                u16             id[ATA_ID_WORDS];
 
385
                u32             gscr[SATA_PMP_GSCR_DWORDS];
 
386
        };
 
387
#ifndef __U_BOOT__
 
388
        u8                      pio_mode;
 
389
        u8                      dma_mode;
 
390
        u8                      xfer_mode;
 
391
        unsigned int            xfer_shift;
 
392
#endif
 
393
        unsigned int            multi_count;
 
394
        unsigned int            max_sectors;
 
395
        unsigned int            cdb_len;
 
396
#ifndef __U_BOOT__
 
397
        unsigned long           pio_mask;
 
398
        unsigned long           mwdma_mask;
 
399
#endif
 
400
        unsigned long           udma_mask;
 
401
        u16                     cylinders;
 
402
        u16                     heads;
 
403
        u16                     sectors;
 
404
#ifndef __U_BOOT__
 
405
        int                     spdn_cnt;
 
406
#endif
 
407
};
 
408
 
 
409
enum dma_data_direction {
 
410
        DMA_BIDIRECTIONAL = 0,
 
411
        DMA_TO_DEVICE = 1,
 
412
        DMA_FROM_DEVICE = 2,
 
413
        DMA_NONE = 3,
 
414
};
 
415
 
 
416
struct ata_link {
 
417
        struct ata_port         *ap;
 
418
        int                     pmp;
 
419
        unsigned int            active_tag;
 
420
        u32                     sactive;
 
421
        unsigned int            flags;
 
422
        unsigned int            hw_sata_spd_limit;
 
423
#ifndef __U_BOOT__
 
424
        unsigned int            sata_spd_limit;
 
425
        unsigned int            sata_spd;
 
426
        struct ata_device       device[2];
 
427
#endif
 
428
};
 
429
 
 
430
struct ata_port {
 
431
        unsigned long           flags;
 
432
        unsigned int            pflags;
 
433
        unsigned int            print_id;
 
434
        unsigned int            port_no;
 
435
 
 
436
        struct ata_ioports      ioaddr;
 
437
 
 
438
        u8                      ctl;
 
439
        u8                      last_ctl;
 
440
        unsigned int            pio_mask;
 
441
        unsigned int            mwdma_mask;
 
442
        unsigned int            udma_mask;
 
443
        unsigned int            cbl;
 
444
 
 
445
        struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
 
446
        unsigned long           qc_allocated;
 
447
        unsigned int            qc_active;
 
448
        int                     nr_active_links;
 
449
 
 
450
        struct ata_link         link;
 
451
#ifndef __U_BOOT__
 
452
        int                     nr_pmp_links;
 
453
        struct ata_link         *pmp_link;
 
454
#endif
 
455
        struct ata_link         *excl_link;
 
456
        int                     nr_pmp_links;
 
457
#ifndef __U_BOOT__
 
458
        struct ata_port_stats   stats;
 
459
        struct device           *dev;
 
460
        u32                     msg_enable;
 
461
#endif
 
462
        struct ata_host         *host;
 
463
        void                    *port_task_data;
 
464
 
 
465
        unsigned int            hsm_task_state;
 
466
        void                    *private_data;
 
467
        unsigned char           *pdata;
 
468
};
 
469
 
 
470
#ifndef TRUE
 
471
#define TRUE 1
 
472
#endif
 
473
#ifndef FALSE
 
474
#define FALSE 0
 
475
#endif
 
476
 
 
477
#endif