]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/ide/ide-timing.h
5 * Copyright (c) 1999-2001 Vojtech Pavlik
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 * Should you need to contact me, the author, you can do so either by
24 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
25 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
28 #include <linux/kernel.h>
29 #include <linux/hdreg.h>
31 #define XFER_PIO_5 0x0d
32 #define XFER_UDMA_SLOW 0x4f
37 short act8b
; /* t2 for 8-bit io */
38 short rec8b
; /* t2i for 8-bit io */
39 short cyc8b
; /* t0 for 8-bit io */
40 short active
; /* t2 or tD */
41 short recover
; /* t2i or tK */
43 short udma
; /* t2CYCTYP/2 */
47 * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
48 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
49 * for PIO 5, which is a nonstandard extension and UDMA6, which
50 * is currently supported only by Maxtor drives.
53 static struct ide_timing ide_timing
[] = {
55 { XFER_UDMA_6
, 0, 0, 0, 0, 0, 0, 0, 15 },
56 { XFER_UDMA_5
, 0, 0, 0, 0, 0, 0, 0, 20 },
57 { XFER_UDMA_4
, 0, 0, 0, 0, 0, 0, 0, 30 },
58 { XFER_UDMA_3
, 0, 0, 0, 0, 0, 0, 0, 45 },
60 { XFER_UDMA_2
, 0, 0, 0, 0, 0, 0, 0, 60 },
61 { XFER_UDMA_1
, 0, 0, 0, 0, 0, 0, 0, 80 },
62 { XFER_UDMA_0
, 0, 0, 0, 0, 0, 0, 0, 120 },
64 { XFER_UDMA_SLOW
, 0, 0, 0, 0, 0, 0, 0, 150 },
66 { XFER_MW_DMA_2
, 25, 0, 0, 0, 70, 25, 120, 0 },
67 { XFER_MW_DMA_1
, 45, 0, 0, 0, 80, 50, 150, 0 },
68 { XFER_MW_DMA_0
, 60, 0, 0, 0, 215, 215, 480, 0 },
70 { XFER_SW_DMA_2
, 60, 0, 0, 0, 120, 120, 240, 0 },
71 { XFER_SW_DMA_1
, 90, 0, 0, 0, 240, 240, 480, 0 },
72 { XFER_SW_DMA_0
, 120, 0, 0, 0, 480, 480, 960, 0 },
74 { XFER_PIO_5
, 20, 50, 30, 100, 50, 30, 100, 0 },
75 { XFER_PIO_4
, 25, 70, 25, 120, 70, 25, 120, 0 },
76 { XFER_PIO_3
, 30, 80, 70, 180, 80, 70, 180, 0 },
78 { XFER_PIO_2
, 30, 290, 40, 330, 100, 90, 240, 0 },
79 { XFER_PIO_1
, 50, 290, 93, 383, 125, 100, 383, 0 },
80 { XFER_PIO_0
, 70, 290, 240, 600, 165, 150, 600, 0 },
82 { XFER_PIO_SLOW
, 120, 290, 240, 960, 290, 240, 960, 0 },
87 #define IDE_TIMING_SETUP 0x01
88 #define IDE_TIMING_ACT8B 0x02
89 #define IDE_TIMING_REC8B 0x04
90 #define IDE_TIMING_CYC8B 0x08
91 #define IDE_TIMING_8BIT 0x0e
92 #define IDE_TIMING_ACTIVE 0x10
93 #define IDE_TIMING_RECOVER 0x20
94 #define IDE_TIMING_CYCLE 0x40
95 #define IDE_TIMING_UDMA 0x80
96 #define IDE_TIMING_ALL 0xff
98 #define FIT(v,vmin,vmax) max_t(short,min_t(short,v,vmax),vmin)
99 #define ENOUGH(v,unit) (((v)-1)/(unit)+1)
100 #define EZ(v,unit) ((v)?ENOUGH(v,unit):0)
102 #define XFER_MODE 0xf0
103 #define XFER_MWDMA 0x20
104 #define XFER_EPIO 0x01
105 #define XFER_PIO 0x00
107 static void ide_timing_quantize(struct ide_timing
*t
, struct ide_timing
*q
, int T
, int UT
)
109 q
->setup
= EZ(t
->setup
* 1000, T
);
110 q
->act8b
= EZ(t
->act8b
* 1000, T
);
111 q
->rec8b
= EZ(t
->rec8b
* 1000, T
);
112 q
->cyc8b
= EZ(t
->cyc8b
* 1000, T
);
113 q
->active
= EZ(t
->active
* 1000, T
);
114 q
->recover
= EZ(t
->recover
* 1000, T
);
115 q
->cycle
= EZ(t
->cycle
* 1000, T
);
116 q
->udma
= EZ(t
->udma
* 1000, UT
);
119 static void ide_timing_merge(struct ide_timing
*a
, struct ide_timing
*b
, struct ide_timing
*m
, unsigned int what
)
121 if (what
& IDE_TIMING_SETUP
) m
->setup
= max(a
->setup
, b
->setup
);
122 if (what
& IDE_TIMING_ACT8B
) m
->act8b
= max(a
->act8b
, b
->act8b
);
123 if (what
& IDE_TIMING_REC8B
) m
->rec8b
= max(a
->rec8b
, b
->rec8b
);
124 if (what
& IDE_TIMING_CYC8B
) m
->cyc8b
= max(a
->cyc8b
, b
->cyc8b
);
125 if (what
& IDE_TIMING_ACTIVE
) m
->active
= max(a
->active
, b
->active
);
126 if (what
& IDE_TIMING_RECOVER
) m
->recover
= max(a
->recover
, b
->recover
);
127 if (what
& IDE_TIMING_CYCLE
) m
->cycle
= max(a
->cycle
, b
->cycle
);
128 if (what
& IDE_TIMING_UDMA
) m
->udma
= max(a
->udma
, b
->udma
);
131 static struct ide_timing
* ide_timing_find_mode(short speed
)
133 struct ide_timing
*t
;
135 for (t
= ide_timing
; t
->mode
!= speed
; t
++)
141 static int ide_timing_compute(ide_drive_t
*drive
, short speed
, struct ide_timing
*t
, int T
, int UT
)
143 struct hd_driveid
*id
= drive
->id
;
144 struct ide_timing
*s
, p
;
150 if (!(s
= ide_timing_find_mode(speed
)))
154 * Copy the timing from the table.
160 * If the drive is an EIDE drive, it can tell us it needs extended
161 * PIO/MWDMA cycle timing.
164 if (id
&& id
->field_valid
& 2) { /* EIDE drive */
166 memset(&p
, 0, sizeof(p
));
168 switch (speed
& XFER_MODE
) {
171 if (speed
<= XFER_PIO_2
) p
.cycle
= p
.cyc8b
= id
->eide_pio
;
172 else p
.cycle
= p
.cyc8b
= id
->eide_pio_iordy
;
176 p
.cycle
= id
->eide_dma_min
;
180 ide_timing_merge(&p
, t
, t
, IDE_TIMING_CYCLE
| IDE_TIMING_CYC8B
);
184 * Convert the timing to bus clock counts.
187 ide_timing_quantize(t
, t
, T
, UT
);
190 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, S.M.A.R.T
191 * and some other commands. We have to ensure that the DMA cycle timing is
192 * slower/equal than the fastest PIO timing.
195 if ((speed
& XFER_MODE
) != XFER_PIO
) {
196 u8 pio
= ide_get_best_pio_mode(drive
, 255, 5);
197 ide_timing_compute(drive
, XFER_PIO_0
+ pio
, &p
, T
, UT
);
198 ide_timing_merge(&p
, t
, t
, IDE_TIMING_ALL
);
202 * Lengthen active & recovery time so that cycle time is correct.
205 if (t
->act8b
+ t
->rec8b
< t
->cyc8b
) {
206 t
->act8b
+= (t
->cyc8b
- (t
->act8b
+ t
->rec8b
)) / 2;
207 t
->rec8b
= t
->cyc8b
- t
->act8b
;
210 if (t
->active
+ t
->recover
< t
->cycle
) {
211 t
->active
+= (t
->cycle
- (t
->active
+ t
->recover
)) / 2;
212 t
->recover
= t
->cycle
- t
->active
;