diff options
Diffstat (limited to 'drivers/ide/ide-io-std.c')
-rw-r--r-- | drivers/ide/ide-io-std.c | 316 |
1 files changed, 316 insertions, 0 deletions
diff --git a/drivers/ide/ide-io-std.c b/drivers/ide/ide-io-std.c new file mode 100644 index 000000000000..45b43dd49cda --- /dev/null +++ b/drivers/ide/ide-io-std.c | |||
@@ -0,0 +1,316 @@ | |||
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 | }; | ||