← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/drivers/block/sata_dwc.h

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

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