Commit | Line | Data |
---|---|---|
1574cf6c BZ |
1 | |
2 | #include <linux/kernel.h> | |
3 | #include <linux/ide.h> | |
4 | ||
5 | /* | |
6 | * Conventional PIO operations for ATA devices | |
7 | */ | |
8 | ||
9 | static u8 ide_inb(unsigned long port) | |
10 | { | |
11 | return (u8) inb(port); | |
12 | } | |
13 | ||
14 | static void ide_outb(u8 val, unsigned long port) | |
15 | { | |
16 | outb(val, port); | |
17 | } | |
18 | ||
19 | /* | |
20 | * MMIO operations, typically used for SATA controllers | |
21 | */ | |
22 | ||
23 | static u8 ide_mm_inb(unsigned long port) | |
24 | { | |
25 | return (u8) readb((void __iomem *) port); | |
26 | } | |
27 | ||
28 | static void ide_mm_outb(u8 value, unsigned long port) | |
29 | { | |
30 | writeb(value, (void __iomem *) port); | |
31 | } | |
32 | ||
33 | void ide_exec_command(ide_hwif_t *hwif, u8 cmd) | |
34 | { | |
35 | if (hwif->host_flags & IDE_HFLAG_MMIO) | |
36 | writeb(cmd, (void __iomem *)hwif->io_ports.command_addr); | |
37 | else | |
38 | outb(cmd, hwif->io_ports.command_addr); | |
39 | } | |
40 | EXPORT_SYMBOL_GPL(ide_exec_command); | |
41 | ||
42 | u8 ide_read_status(ide_hwif_t *hwif) | |
43 | { | |
44 | if (hwif->host_flags & IDE_HFLAG_MMIO) | |
45 | return readb((void __iomem *)hwif->io_ports.status_addr); | |
46 | else | |
47 | return inb(hwif->io_ports.status_addr); | |
48 | } | |
49 | EXPORT_SYMBOL_GPL(ide_read_status); | |
50 | ||
51 | u8 ide_read_altstatus(ide_hwif_t *hwif) | |
52 | { | |
53 | if (hwif->host_flags & IDE_HFLAG_MMIO) | |
54 | return readb((void __iomem *)hwif->io_ports.ctl_addr); | |
55 | else | |
56 | return inb(hwif->io_ports.ctl_addr); | |
57 | } | |
58 | EXPORT_SYMBOL_GPL(ide_read_altstatus); | |
59 | ||
60 | void ide_set_irq(ide_hwif_t *hwif, int on) | |
61 | { | |
62 | u8 ctl = ATA_DEVCTL_OBS; | |
63 | ||
64 | if (on == 4) { /* hack for SRST */ | |
65 | ctl |= 4; | |
66 | on &= ~4; | |
67 | } | |
68 | ||
69 | ctl |= on ? 0 : 2; | |
70 | ||
71 | if (hwif->host_flags & IDE_HFLAG_MMIO) | |
72 | writeb(ctl, (void __iomem *)hwif->io_ports.ctl_addr); | |
73 | else | |
74 | outb(ctl, hwif->io_ports.ctl_addr); | |
75 | } | |
76 | EXPORT_SYMBOL_GPL(ide_set_irq); | |
77 | ||
78 | void ide_tf_load(ide_drive_t *drive, ide_task_t *task) | |
79 | { | |
80 | ide_hwif_t *hwif = drive->hwif; | |
81 | struct ide_io_ports *io_ports = &hwif->io_ports; | |
82 | struct ide_taskfile *tf = &task->tf; | |
83 | void (*tf_outb)(u8 addr, unsigned long port); | |
84 | u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0; | |
85 | u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF; | |
86 | ||
87 | if (mmio) | |
88 | tf_outb = ide_mm_outb; | |
89 | else | |
90 | tf_outb = ide_outb; | |
91 | ||
92 | if (task->tf_flags & IDE_TFLAG_FLAGGED) | |
93 | HIHI = 0xFF; | |
94 | ||
95 | if (task->tf_flags & IDE_TFLAG_OUT_DATA) { | |
96 | u16 data = (tf->hob_data << 8) | tf->data; | |
97 | ||
98 | if (mmio) | |
99 | writew(data, (void __iomem *)io_ports->data_addr); | |
100 | else | |
101 | outw(data, io_ports->data_addr); | |
102 | } | |
103 | ||
104 | if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE) | |
105 | tf_outb(tf->hob_feature, io_ports->feature_addr); | |
106 | if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT) | |
107 | tf_outb(tf->hob_nsect, io_ports->nsect_addr); | |
108 | if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL) | |
109 | tf_outb(tf->hob_lbal, io_ports->lbal_addr); | |
110 | if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM) | |
111 | tf_outb(tf->hob_lbam, io_ports->lbam_addr); | |
112 | if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH) | |
113 | tf_outb(tf->hob_lbah, io_ports->lbah_addr); | |
114 | ||
115 | if (task->tf_flags & IDE_TFLAG_OUT_FEATURE) | |
116 | tf_outb(tf->feature, io_ports->feature_addr); | |
117 | if (task->tf_flags & IDE_TFLAG_OUT_NSECT) | |
118 | tf_outb(tf->nsect, io_ports->nsect_addr); | |
119 | if (task->tf_flags & IDE_TFLAG_OUT_LBAL) | |
120 | tf_outb(tf->lbal, io_ports->lbal_addr); | |
121 | if (task->tf_flags & IDE_TFLAG_OUT_LBAM) | |
122 | tf_outb(tf->lbam, io_ports->lbam_addr); | |
123 | if (task->tf_flags & IDE_TFLAG_OUT_LBAH) | |
124 | tf_outb(tf->lbah, io_ports->lbah_addr); | |
125 | ||
126 | if (task->tf_flags & IDE_TFLAG_OUT_DEVICE) | |
127 | tf_outb((tf->device & HIHI) | drive->select, | |
128 | io_ports->device_addr); | |
129 | } | |
130 | EXPORT_SYMBOL_GPL(ide_tf_load); | |
131 | ||
132 | void ide_tf_read(ide_drive_t *drive, ide_task_t *task) | |
133 | { | |
134 | ide_hwif_t *hwif = drive->hwif; | |
135 | struct ide_io_ports *io_ports = &hwif->io_ports; | |
136 | struct ide_taskfile *tf = &task->tf; | |
137 | void (*tf_outb)(u8 addr, unsigned long port); | |
138 | u8 (*tf_inb)(unsigned long port); | |
139 | u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0; | |
140 | ||
141 | if (mmio) { | |
142 | tf_outb = ide_mm_outb; | |
143 | tf_inb = ide_mm_inb; | |
144 | } else { | |
145 | tf_outb = ide_outb; | |
146 | tf_inb = ide_inb; | |
147 | } | |
148 | ||
149 | if (task->tf_flags & IDE_TFLAG_IN_DATA) { | |
150 | u16 data; | |
151 | ||
152 | if (mmio) | |
153 | data = readw((void __iomem *)io_ports->data_addr); | |
154 | else | |
155 | data = inw(io_ports->data_addr); | |
156 | ||
157 | tf->data = data & 0xff; | |
158 | tf->hob_data = (data >> 8) & 0xff; | |
159 | } | |
160 | ||
161 | /* be sure we're looking at the low order bits */ | |
162 | tf_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr); | |
163 | ||
164 | if (task->tf_flags & IDE_TFLAG_IN_FEATURE) | |
165 | tf->feature = tf_inb(io_ports->feature_addr); | |
166 | if (task->tf_flags & IDE_TFLAG_IN_NSECT) | |
167 | tf->nsect = tf_inb(io_ports->nsect_addr); | |
168 | if (task->tf_flags & IDE_TFLAG_IN_LBAL) | |
169 | tf->lbal = tf_inb(io_ports->lbal_addr); | |
170 | if (task->tf_flags & IDE_TFLAG_IN_LBAM) | |
171 | tf->lbam = tf_inb(io_ports->lbam_addr); | |
172 | if (task->tf_flags & IDE_TFLAG_IN_LBAH) | |
173 | tf->lbah = tf_inb(io_ports->lbah_addr); | |
174 | if (task->tf_flags & IDE_TFLAG_IN_DEVICE) | |
175 | tf->device = tf_inb(io_ports->device_addr); | |
176 | ||
177 | if (task->tf_flags & IDE_TFLAG_LBA48) { | |
178 | tf_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr); | |
179 | ||
180 | if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE) | |
181 | tf->hob_feature = tf_inb(io_ports->feature_addr); | |
182 | if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT) | |
183 | tf->hob_nsect = tf_inb(io_ports->nsect_addr); | |
184 | if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL) | |
185 | tf->hob_lbal = tf_inb(io_ports->lbal_addr); | |
186 | if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM) | |
187 | tf->hob_lbam = tf_inb(io_ports->lbam_addr); | |
188 | if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH) | |
189 | tf->hob_lbah = tf_inb(io_ports->lbah_addr); | |
190 | } | |
191 | } | |
192 | EXPORT_SYMBOL_GPL(ide_tf_read); | |
193 | ||
194 | /* | |
195 | * Some localbus EIDE interfaces require a special access sequence | |
196 | * when using 32-bit I/O instructions to transfer data. We call this | |
197 | * the "vlb_sync" sequence, which consists of three successive reads | |
198 | * of the sector count register location, with interrupts disabled | |
199 | * to ensure that the reads all happen together. | |
200 | */ | |
201 | static void ata_vlb_sync(unsigned long port) | |
202 | { | |
203 | (void)inb(port); | |
204 | (void)inb(port); | |
205 | (void)inb(port); | |
206 | } | |
207 | ||
208 | /* | |
209 | * This is used for most PIO data transfers *from* the IDE interface | |
210 | * | |
211 | * These routines will round up any request for an odd number of bytes, | |
212 | * so if an odd len is specified, be sure that there's at least one | |
213 | * extra byte allocated for the buffer. | |
214 | */ | |
215 | void ide_input_data(ide_drive_t *drive, struct request *rq, void *buf, | |
216 | unsigned int len) | |
217 | { | |
218 | ide_hwif_t *hwif = drive->hwif; | |
219 | struct ide_io_ports *io_ports = &hwif->io_ports; | |
220 | unsigned long data_addr = io_ports->data_addr; | |
221 | u8 io_32bit = drive->io_32bit; | |
222 | u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0; | |
223 | ||
224 | len++; | |
225 | ||
226 | if (io_32bit) { | |
227 | unsigned long uninitialized_var(flags); | |
228 | ||
229 | if ((io_32bit & 2) && !mmio) { | |
230 | local_irq_save(flags); | |
231 | ata_vlb_sync(io_ports->nsect_addr); | |
232 | } | |
233 | ||
234 | if (mmio) | |
235 | __ide_mm_insl((void __iomem *)data_addr, buf, len / 4); | |
236 | else | |
237 | insl(data_addr, buf, len / 4); | |
238 | ||
239 | if ((io_32bit & 2) && !mmio) | |
240 | local_irq_restore(flags); | |
241 | ||
242 | if ((len & 3) >= 2) { | |
243 | if (mmio) | |
244 | __ide_mm_insw((void __iomem *)data_addr, | |
245 | (u8 *)buf + (len & ~3), 1); | |
246 | else | |
247 | insw(data_addr, (u8 *)buf + (len & ~3), 1); | |
248 | } | |
249 | } else { | |
250 | if (mmio) | |
251 | __ide_mm_insw((void __iomem *)data_addr, buf, len / 2); | |
252 | else | |
253 | insw(data_addr, buf, len / 2); | |
254 | } | |
255 | } | |
256 | EXPORT_SYMBOL_GPL(ide_input_data); | |
257 | ||
258 | /* | |
259 | * This is used for most PIO data transfers *to* the IDE interface | |
260 | */ | |
261 | void ide_output_data(ide_drive_t *drive, struct request *rq, void *buf, | |
262 | unsigned int len) | |
263 | { | |
264 | ide_hwif_t *hwif = drive->hwif; | |
265 | struct ide_io_ports *io_ports = &hwif->io_ports; | |
266 | unsigned long data_addr = io_ports->data_addr; | |
267 | u8 io_32bit = drive->io_32bit; | |
268 | u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0; | |
269 | ||
270 | len++; | |
271 | ||
272 | if (io_32bit) { | |
273 | unsigned long uninitialized_var(flags); | |
274 | ||
275 | if ((io_32bit & 2) && !mmio) { | |
276 | local_irq_save(flags); | |
277 | ata_vlb_sync(io_ports->nsect_addr); | |
278 | } | |
279 | ||
280 | if (mmio) | |
281 | __ide_mm_outsl((void __iomem *)data_addr, buf, len / 4); | |
282 | else | |
283 | outsl(data_addr, buf, len / 4); | |
284 | ||
285 | if ((io_32bit & 2) && !mmio) | |
286 | local_irq_restore(flags); | |
287 | ||
288 | if ((len & 3) >= 2) { | |
289 | if (mmio) | |
290 | __ide_mm_outsw((void __iomem *)data_addr, | |
291 | (u8 *)buf + (len & ~3), 1); | |
292 | else | |
293 | outsw(data_addr, (u8 *)buf + (len & ~3), 1); | |
294 | } | |
295 | } else { | |
296 | if (mmio) | |
297 | __ide_mm_outsw((void __iomem *)data_addr, buf, len / 2); | |
298 | else | |
299 | outsw(data_addr, buf, len / 2); | |
300 | } | |
301 | } | |
302 | EXPORT_SYMBOL_GPL(ide_output_data); | |
303 | ||
304 | const struct ide_tp_ops default_tp_ops = { | |
305 | .exec_command = ide_exec_command, | |
306 | .read_status = ide_read_status, | |
307 | .read_altstatus = ide_read_altstatus, | |
308 | ||
309 | .set_irq = ide_set_irq, | |
310 | ||
311 | .tf_load = ide_tf_load, | |
312 | .tf_read = ide_tf_read, | |
313 | ||
314 | .input_data = ide_input_data, | |
315 | .output_data = ide_output_data, | |
316 | }; |