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