]> git.sur5r.net Git - u-boot/blob - drivers/block/sata_dwc.h
Convert CONFIG_SCSI to Kconfig
[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