aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/ide/ide-iops.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/ide/ide-iops.c')
-rw-r--r--drivers/ide/ide-iops.c740
1 files changed, 29 insertions, 711 deletions
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index 753b92ebe0a..317c5dadd7c 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -27,35 +27,7 @@
27#include <asm/uaccess.h> 27#include <asm/uaccess.h>
28#include <asm/io.h> 28#include <asm/io.h>
29 29
30/* 30void SELECT_DRIVE(ide_drive_t *drive)
31 * Conventional PIO operations for ATA devices
32 */
33
34static u8 ide_inb (unsigned long port)
35{
36 return (u8) inb(port);
37}
38
39static void ide_outb (u8 val, unsigned long port)
40{
41 outb(val, port);
42}
43
44/*
45 * MMIO operations, typically used for SATA controllers
46 */
47
48static u8 ide_mm_inb (unsigned long port)
49{
50 return (u8) readb((void __iomem *) port);
51}
52
53static void ide_mm_outb (u8 value, unsigned long port)
54{
55 writeb(value, (void __iomem *) port);
56}
57
58void SELECT_DRIVE (ide_drive_t *drive)
59{ 31{
60 ide_hwif_t *hwif = drive->hwif; 32 ide_hwif_t *hwif = drive->hwif;
61 const struct ide_port_ops *port_ops = hwif->port_ops; 33 const struct ide_port_ops *port_ops = hwif->port_ops;
@@ -78,275 +50,6 @@ void SELECT_MASK(ide_drive_t *drive, int mask)
78 port_ops->maskproc(drive, mask); 50 port_ops->maskproc(drive, mask);
79} 51}
80 52
81void ide_exec_command(ide_hwif_t *hwif, u8 cmd)
82{
83 if (hwif->host_flags & IDE_HFLAG_MMIO)
84 writeb(cmd, (void __iomem *)hwif->io_ports.command_addr);
85 else
86 outb(cmd, hwif->io_ports.command_addr);
87}
88EXPORT_SYMBOL_GPL(ide_exec_command);
89
90u8 ide_read_status(ide_hwif_t *hwif)
91{
92 if (hwif->host_flags & IDE_HFLAG_MMIO)
93 return readb((void __iomem *)hwif->io_ports.status_addr);
94 else
95 return inb(hwif->io_ports.status_addr);
96}
97EXPORT_SYMBOL_GPL(ide_read_status);
98
99u8 ide_read_altstatus(ide_hwif_t *hwif)
100{
101 if (hwif->host_flags & IDE_HFLAG_MMIO)
102 return readb((void __iomem *)hwif->io_ports.ctl_addr);
103 else
104 return inb(hwif->io_ports.ctl_addr);
105}
106EXPORT_SYMBOL_GPL(ide_read_altstatus);
107
108void ide_set_irq(ide_hwif_t *hwif, int on)
109{
110 u8 ctl = ATA_DEVCTL_OBS;
111
112 if (on == 4) { /* hack for SRST */
113 ctl |= 4;
114 on &= ~4;
115 }
116
117 ctl |= on ? 0 : 2;
118
119 if (hwif->host_flags & IDE_HFLAG_MMIO)
120 writeb(ctl, (void __iomem *)hwif->io_ports.ctl_addr);
121 else
122 outb(ctl, hwif->io_ports.ctl_addr);
123}
124EXPORT_SYMBOL_GPL(ide_set_irq);
125
126void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
127{
128 ide_hwif_t *hwif = drive->hwif;
129 struct ide_io_ports *io_ports = &hwif->io_ports;
130 struct ide_taskfile *tf = &task->tf;
131 void (*tf_outb)(u8 addr, unsigned long port);
132 u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
133 u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
134
135 if (mmio)
136 tf_outb = ide_mm_outb;
137 else
138 tf_outb = ide_outb;
139
140 if (task->tf_flags & IDE_TFLAG_FLAGGED)
141 HIHI = 0xFF;
142
143 if (task->tf_flags & IDE_TFLAG_OUT_DATA) {
144 u16 data = (tf->hob_data << 8) | tf->data;
145
146 if (mmio)
147 writew(data, (void __iomem *)io_ports->data_addr);
148 else
149 outw(data, io_ports->data_addr);
150 }
151
152 if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
153 tf_outb(tf->hob_feature, io_ports->feature_addr);
154 if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
155 tf_outb(tf->hob_nsect, io_ports->nsect_addr);
156 if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
157 tf_outb(tf->hob_lbal, io_ports->lbal_addr);
158 if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
159 tf_outb(tf->hob_lbam, io_ports->lbam_addr);
160 if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
161 tf_outb(tf->hob_lbah, io_ports->lbah_addr);
162
163 if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
164 tf_outb(tf->feature, io_ports->feature_addr);
165 if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
166 tf_outb(tf->nsect, io_ports->nsect_addr);
167 if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
168 tf_outb(tf->lbal, io_ports->lbal_addr);
169 if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
170 tf_outb(tf->lbam, io_ports->lbam_addr);
171 if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
172 tf_outb(tf->lbah, io_ports->lbah_addr);
173
174 if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
175 tf_outb((tf->device & HIHI) | drive->select,
176 io_ports->device_addr);
177}
178EXPORT_SYMBOL_GPL(ide_tf_load);
179
180void ide_tf_read(ide_drive_t *drive, ide_task_t *task)
181{
182 ide_hwif_t *hwif = drive->hwif;
183 struct ide_io_ports *io_ports = &hwif->io_ports;
184 struct ide_taskfile *tf = &task->tf;
185 void (*tf_outb)(u8 addr, unsigned long port);
186 u8 (*tf_inb)(unsigned long port);
187 u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
188
189 if (mmio) {
190 tf_outb = ide_mm_outb;
191 tf_inb = ide_mm_inb;
192 } else {
193 tf_outb = ide_outb;
194 tf_inb = ide_inb;
195 }
196
197 if (task->tf_flags & IDE_TFLAG_IN_DATA) {
198 u16 data;
199
200 if (mmio)
201 data = readw((void __iomem *)io_ports->data_addr);
202 else
203 data = inw(io_ports->data_addr);
204
205 tf->data = data & 0xff;
206 tf->hob_data = (data >> 8) & 0xff;
207 }
208
209 /* be sure we're looking at the low order bits */
210 tf_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
211
212 if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
213 tf->feature = tf_inb(io_ports->feature_addr);
214 if (task->tf_flags & IDE_TFLAG_IN_NSECT)
215 tf->nsect = tf_inb(io_ports->nsect_addr);
216 if (task->tf_flags & IDE_TFLAG_IN_LBAL)
217 tf->lbal = tf_inb(io_ports->lbal_addr);
218 if (task->tf_flags & IDE_TFLAG_IN_LBAM)
219 tf->lbam = tf_inb(io_ports->lbam_addr);
220 if (task->tf_flags & IDE_TFLAG_IN_LBAH)
221 tf->lbah = tf_inb(io_ports->lbah_addr);
222 if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
223 tf->device = tf_inb(io_ports->device_addr);
224
225 if (task->tf_flags & IDE_TFLAG_LBA48) {
226 tf_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
227
228 if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
229 tf->hob_feature = tf_inb(io_ports->feature_addr);
230 if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
231 tf->hob_nsect = tf_inb(io_ports->nsect_addr);
232 if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
233 tf->hob_lbal = tf_inb(io_ports->lbal_addr);
234 if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
235 tf->hob_lbam = tf_inb(io_ports->lbam_addr);
236 if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
237 tf->hob_lbah = tf_inb(io_ports->lbah_addr);
238 }
239}
240EXPORT_SYMBOL_GPL(ide_tf_read);
241
242/*
243 * Some localbus EIDE interfaces require a special access sequence
244 * when using 32-bit I/O instructions to transfer data. We call this
245 * the "vlb_sync" sequence, which consists of three successive reads
246 * of the sector count register location, with interrupts disabled
247 * to ensure that the reads all happen together.
248 */
249static void ata_vlb_sync(unsigned long port)
250{
251 (void)inb(port);
252 (void)inb(port);
253 (void)inb(port);
254}
255
256/*
257 * This is used for most PIO data transfers *from* the IDE interface
258 *
259 * These routines will round up any request for an odd number of bytes,
260 * so if an odd len is specified, be sure that there's at least one
261 * extra byte allocated for the buffer.
262 */
263void ide_input_data(ide_drive_t *drive, struct request *rq, void *buf,
264 unsigned int len)
265{
266 ide_hwif_t *hwif = drive->hwif;
267 struct ide_io_ports *io_ports = &hwif->io_ports;
268 unsigned long data_addr = io_ports->data_addr;
269 u8 io_32bit = drive->io_32bit;
270 u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
271
272 len++;
273
274 if (io_32bit) {
275 unsigned long uninitialized_var(flags);
276
277 if ((io_32bit & 2) && !mmio) {
278 local_irq_save(flags);
279 ata_vlb_sync(io_ports->nsect_addr);
280 }
281
282 if (mmio)
283 __ide_mm_insl((void __iomem *)data_addr, buf, len / 4);
284 else
285 insl(data_addr, buf, len / 4);
286
287 if ((io_32bit & 2) && !mmio)
288 local_irq_restore(flags);
289
290 if ((len & 3) >= 2) {
291 if (mmio)
292 __ide_mm_insw((void __iomem *)data_addr,
293 (u8 *)buf + (len & ~3), 1);
294 else
295 insw(data_addr, (u8 *)buf + (len & ~3), 1);
296 }
297 } else {
298 if (mmio)
299 __ide_mm_insw((void __iomem *)data_addr, buf, len / 2);
300 else
301 insw(data_addr, buf, len / 2);
302 }
303}
304EXPORT_SYMBOL_GPL(ide_input_data);
305
306/*
307 * This is used for most PIO data transfers *to* the IDE interface
308 */
309void ide_output_data(ide_drive_t *drive, struct request *rq, void *buf,
310 unsigned int len)
311{
312 ide_hwif_t *hwif = drive->hwif;
313 struct ide_io_ports *io_ports = &hwif->io_ports;
314 unsigned long data_addr = io_ports->data_addr;
315 u8 io_32bit = drive->io_32bit;
316 u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
317
318 if (io_32bit) {
319 unsigned long uninitialized_var(flags);
320
321 if ((io_32bit & 2) && !mmio) {
322 local_irq_save(flags);
323 ata_vlb_sync(io_ports->nsect_addr);
324 }
325
326 if (mmio)
327 __ide_mm_outsl((void __iomem *)data_addr, buf, len / 4);
328 else
329 outsl(data_addr, buf, len / 4);
330
331 if ((io_32bit & 2) && !mmio)
332 local_irq_restore(flags);
333
334 if ((len & 3) >= 2) {
335 if (mmio)
336 __ide_mm_outsw((void __iomem *)data_addr,
337 (u8 *)buf + (len & ~3), 1);
338 else
339 outsw(data_addr, (u8 *)buf + (len & ~3), 1);
340 }
341 } else {
342 if (mmio)
343 __ide_mm_outsw((void __iomem *)data_addr, buf, len / 2);
344 else
345 outsw(data_addr, buf, len / 2);
346 }
347}
348EXPORT_SYMBOL_GPL(ide_output_data);
349
350u8 ide_read_error(ide_drive_t *drive) 53u8 ide_read_error(ide_drive_t *drive)
351{ 54{
352 ide_task_t task; 55 ide_task_t task;
@@ -360,35 +63,6 @@ u8 ide_read_error(ide_drive_t *drive)
360} 63}
361EXPORT_SYMBOL_GPL(ide_read_error); 64EXPORT_SYMBOL_GPL(ide_read_error);
362 65
363void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
364{
365 ide_task_t task;
366
367 memset(&task, 0, sizeof(task));
368 task.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |
369 IDE_TFLAG_IN_NSECT;
370
371 drive->hwif->tp_ops->tf_read(drive, &task);
372
373 *bcount = (task.tf.lbah << 8) | task.tf.lbam;
374 *ireason = task.tf.nsect & 3;
375}
376EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
377
378const struct ide_tp_ops default_tp_ops = {
379 .exec_command = ide_exec_command,
380 .read_status = ide_read_status,
381 .read_altstatus = ide_read_altstatus,
382
383 .set_irq = ide_set_irq,
384
385 .tf_load = ide_tf_load,
386 .tf_read = ide_tf_read,
387
388 .input_data = ide_input_data,
389 .output_data = ide_output_data,
390};
391
392void ide_fix_driveid(u16 *id) 66void ide_fix_driveid(u16 *id)
393{ 67{
394#ifndef __LITTLE_ENDIAN 68#ifndef __LITTLE_ENDIAN
@@ -410,7 +84,7 @@ void ide_fix_driveid(u16 *id)
410 * returned by the ATA_CMD_ID_ATA[PI] commands. 84 * returned by the ATA_CMD_ID_ATA[PI] commands.
411 */ 85 */
412 86
413void ide_fixstring (u8 *s, const int bytecount, const int byteswap) 87void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
414{ 88{
415 u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */ 89 u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
416 90
@@ -433,44 +107,9 @@ void ide_fixstring (u8 *s, const int bytecount, const int byteswap)
433 while (p != end) 107 while (p != end)
434 *p++ = '\0'; 108 *p++ = '\0';
435} 109}
436
437EXPORT_SYMBOL(ide_fixstring); 110EXPORT_SYMBOL(ide_fixstring);
438 111
439/* 112/*
440 * Needed for PCI irq sharing
441 */
442int drive_is_ready (ide_drive_t *drive)
443{
444 ide_hwif_t *hwif = drive->hwif;
445 u8 stat = 0;
446
447 if (drive->waiting_for_dma)
448 return hwif->dma_ops->dma_test_irq(drive);
449
450 /*
451 * We do a passive status test under shared PCI interrupts on
452 * cards that truly share the ATA side interrupt, but may also share
453 * an interrupt with another pci card/device. We make no assumptions
454 * about possible isa-pnp and pci-pnp issues yet.
455 */
456 if (hwif->io_ports.ctl_addr &&
457 (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0)
458 stat = hwif->tp_ops->read_altstatus(hwif);
459 else
460 /* Note: this may clear a pending IRQ!! */
461 stat = hwif->tp_ops->read_status(hwif);
462
463 if (stat & ATA_BUSY)
464 /* drive busy: definitely not interrupting */
465 return 0;
466
467 /* drive ready: *might* be interrupting */
468 return 1;
469}
470
471EXPORT_SYMBOL(drive_is_ready);
472
473/*
474 * This routine busy-waits for the drive status to be not "busy". 113 * This routine busy-waits for the drive status to be not "busy".
475 * It then checks the status for all of the "good" bits and none 114 * It then checks the status for all of the "good" bits and none
476 * of the "bad" bits, and if all is okay it returns 0. All other 115 * of the "bad" bits, and if all is okay it returns 0. All other
@@ -481,7 +120,8 @@ EXPORT_SYMBOL(drive_is_ready);
481 * setting a timer to wake up at half second intervals thereafter, 120 * setting a timer to wake up at half second intervals thereafter,
482 * until timeout is achieved, before timing out. 121 * until timeout is achieved, before timing out.
483 */ 122 */
484static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long timeout, u8 *rstat) 123static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
124 unsigned long timeout, u8 *rstat)
485{ 125{
486 ide_hwif_t *hwif = drive->hwif; 126 ide_hwif_t *hwif = drive->hwif;
487 const struct ide_tp_ops *tp_ops = hwif->tp_ops; 127 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
@@ -539,7 +179,8 @@ static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long ti
539 * The caller should return the updated value of "startstop" in this case, 179 * The caller should return the updated value of "startstop" in this case,
540 * "startstop" is unchanged when the function returns 0. 180 * "startstop" is unchanged when the function returns 0.
541 */ 181 */
542int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good, u8 bad, unsigned long timeout) 182int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
183 u8 bad, unsigned long timeout)
543{ 184{
544 int err; 185 int err;
545 u8 stat; 186 u8 stat;
@@ -559,7 +200,6 @@ int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good, u8 ba
559 200
560 return err; 201 return err;
561} 202}
562
563EXPORT_SYMBOL(ide_wait_stat); 203EXPORT_SYMBOL(ide_wait_stat);
564 204
565/** 205/**
@@ -580,7 +220,6 @@ int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
580 return 1; 220 return 1;
581 return 0; 221 return 0;
582} 222}
583
584EXPORT_SYMBOL_GPL(ide_in_drive_list); 223EXPORT_SYMBOL_GPL(ide_in_drive_list);
585 224
586/* 225/*
@@ -605,7 +244,7 @@ static const struct drive_list_entry ivb_list[] = {
605 * All hosts that use the 80c ribbon must use! 244 * All hosts that use the 80c ribbon must use!
606 * The name is derived from upper byte of word 93 and the 80c ribbon. 245 * The name is derived from upper byte of word 93 and the 80c ribbon.
607 */ 246 */
608u8 eighty_ninty_three (ide_drive_t *drive) 247u8 eighty_ninty_three(ide_drive_t *drive)
609{ 248{
610 ide_hwif_t *hwif = drive->hwif; 249 ide_hwif_t *hwif = drive->hwif;
611 u16 *id = drive->id; 250 u16 *id = drive->id;
@@ -650,47 +289,19 @@ no_80w:
650 289
651int ide_driveid_update(ide_drive_t *drive) 290int ide_driveid_update(ide_drive_t *drive)
652{ 291{
653 ide_hwif_t *hwif = drive->hwif;
654 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
655 u16 *id; 292 u16 *id;
656 unsigned long flags; 293 int rc;
657 u8 stat;
658
659 /*
660 * Re-read drive->id for possible DMA mode
661 * change (copied from ide-probe.c)
662 */
663 294
664 SELECT_MASK(drive, 1); 295 id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
665 tp_ops->set_irq(hwif, 0); 296 if (id == NULL)
666 msleep(50);
667 tp_ops->exec_command(hwif, ATA_CMD_ID_ATA);
668
669 if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 1)) {
670 SELECT_MASK(drive, 0);
671 return 0; 297 return 0;
672 }
673
674 msleep(50); /* wait for IRQ and ATA_DRQ */
675 stat = tp_ops->read_status(hwif);
676 298
677 if (!OK_STAT(stat, ATA_DRQ, BAD_R_STAT)) { 299 SELECT_MASK(drive, 1);
678 SELECT_MASK(drive, 0); 300 rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id);
679 printk("%s: CHECK for good STATUS\n", drive->name);
680 return 0;
681 }
682 local_irq_save(flags);
683 SELECT_MASK(drive, 0); 301 SELECT_MASK(drive, 0);
684 id = kmalloc(SECTOR_SIZE, GFP_ATOMIC); 302
685 if (!id) { 303 if (rc)
686 local_irq_restore(flags); 304 goto out_err;
687 return 0;
688 }
689 tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
690 (void)tp_ops->read_status(hwif); /* clear drive IRQ */
691 local_irq_enable();
692 local_irq_restore(flags);
693 ide_fix_driveid(id);
694 305
695 drive->id[ATA_ID_UDMA_MODES] = id[ATA_ID_UDMA_MODES]; 306 drive->id[ATA_ID_UDMA_MODES] = id[ATA_ID_UDMA_MODES];
696 drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES]; 307 drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
@@ -703,6 +314,12 @@ int ide_driveid_update(ide_drive_t *drive)
703 ide_dma_off(drive); 314 ide_dma_off(drive);
704 315
705 return 1; 316 return 1;
317out_err:
318 SELECT_MASK(drive, 0);
319 if (rc == 2)
320 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
321 kfree(id);
322 return 0;
706} 323}
707 324
708int ide_config_drive_speed(ide_drive_t *drive, u8 speed) 325int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
@@ -729,18 +346,15 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
729 * but for some reason these don't work at 346 * but for some reason these don't work at
730 * this point (lost interrupt). 347 * this point (lost interrupt).
731 */ 348 */
732 /* 349
733 * Select the drive, and issue the SETFEATURES command
734 */
735 disable_irq_nosync(hwif->irq);
736
737 /* 350 /*
738 * FIXME: we race against the running IRQ here if 351 * FIXME: we race against the running IRQ here if
739 * this is called from non IRQ context. If we use 352 * this is called from non IRQ context. If we use
740 * disable_irq() we hang on the error path. Work 353 * disable_irq() we hang on the error path. Work
741 * is needed. 354 * is needed.
742 */ 355 */
743 356 disable_irq_nosync(hwif->irq);
357
744 udelay(1); 358 udelay(1);
745 SELECT_DRIVE(drive); 359 SELECT_DRIVE(drive);
746 SELECT_MASK(drive, 1); 360 SELECT_MASK(drive, 1);
@@ -810,8 +424,8 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
810 * 424 *
811 * See also ide_execute_command 425 * See also ide_execute_command
812 */ 426 */
813static void __ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, 427void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
814 unsigned int timeout, ide_expiry_t *expiry) 428 unsigned int timeout, ide_expiry_t *expiry)
815{ 429{
816 ide_hwif_t *hwif = drive->hwif; 430 ide_hwif_t *hwif = drive->hwif;
817 431
@@ -833,9 +447,8 @@ void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
833 __ide_set_handler(drive, handler, timeout, expiry); 447 __ide_set_handler(drive, handler, timeout, expiry);
834 spin_unlock_irqrestore(&hwif->lock, flags); 448 spin_unlock_irqrestore(&hwif->lock, flags);
835} 449}
836
837EXPORT_SYMBOL(ide_set_handler); 450EXPORT_SYMBOL(ide_set_handler);
838 451
839/** 452/**
840 * ide_execute_command - execute an IDE command 453 * ide_execute_command - execute an IDE command
841 * @drive: IDE drive to issue the command against 454 * @drive: IDE drive to issue the command against
@@ -845,7 +458,7 @@ EXPORT_SYMBOL(ide_set_handler);
845 * @expiry: handler to run on timeout 458 * @expiry: handler to run on timeout
846 * 459 *
847 * Helper function to issue an IDE command. This handles the 460 * Helper function to issue an IDE command. This handles the
848 * atomicity requirements, command timing and ensures that the 461 * atomicity requirements, command timing and ensures that the
849 * handler and IRQ setup do not race. All IDE command kick off 462 * handler and IRQ setup do not race. All IDE command kick off
850 * should go via this function or do equivalent locking. 463 * should go via this function or do equivalent locking.
851 */ 464 */
@@ -882,301 +495,6 @@ void ide_execute_pkt_cmd(ide_drive_t *drive)
882} 495}
883EXPORT_SYMBOL_GPL(ide_execute_pkt_cmd); 496EXPORT_SYMBOL_GPL(ide_execute_pkt_cmd);
884 497
885static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
886{
887 struct request *rq = drive->hwif->rq;
888
889 if (rq && blk_special_request(rq) && rq->cmd[0] == REQ_DRIVE_RESET)
890 ide_end_request(drive, err ? err : 1, 0);
891}
892
893/* needed below */
894static ide_startstop_t do_reset1 (ide_drive_t *, int);
895
896/*
897 * atapi_reset_pollfunc() gets invoked to poll the interface for completion every 50ms
898 * during an atapi drive reset operation. If the drive has not yet responded,
899 * and we have not yet hit our maximum waiting time, then the timer is restarted
900 * for another 50ms.
901 */
902static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
903{
904 ide_hwif_t *hwif = drive->hwif;
905 u8 stat;
906
907 SELECT_DRIVE(drive);
908 udelay (10);
909 stat = hwif->tp_ops->read_status(hwif);
910
911 if (OK_STAT(stat, 0, ATA_BUSY))
912 printk("%s: ATAPI reset complete\n", drive->name);
913 else {
914 if (time_before(jiffies, hwif->poll_timeout)) {
915 ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
916 /* continue polling */
917 return ide_started;
918 }
919 /* end of polling */
920 hwif->polling = 0;
921 printk("%s: ATAPI reset timed-out, status=0x%02x\n",
922 drive->name, stat);
923 /* do it the old fashioned way */
924 return do_reset1(drive, 1);
925 }
926 /* done polling */
927 hwif->polling = 0;
928 ide_complete_drive_reset(drive, 0);
929 return ide_stopped;
930}
931
932static void ide_reset_report_error(ide_hwif_t *hwif, u8 err)
933{
934 static const char *err_master_vals[] =
935 { NULL, "passed", "formatter device error",
936 "sector buffer error", "ECC circuitry error",
937 "controlling MPU error" };
938
939 u8 err_master = err & 0x7f;
940
941 printk(KERN_ERR "%s: reset: master: ", hwif->name);
942 if (err_master && err_master < 6)
943 printk(KERN_CONT "%s", err_master_vals[err_master]);
944 else
945 printk(KERN_CONT "error (0x%02x?)", err);
946 if (err & 0x80)
947 printk(KERN_CONT "; slave: failed");
948 printk(KERN_CONT "\n");
949}
950
951/*
952 * reset_pollfunc() gets invoked to poll the interface for completion every 50ms
953 * during an ide reset operation. If the drives have not yet responded,
954 * and we have not yet hit our maximum waiting time, then the timer is restarted
955 * for another 50ms.
956 */
957static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
958{
959 ide_hwif_t *hwif = drive->hwif;
960 const struct ide_port_ops *port_ops = hwif->port_ops;
961 u8 tmp;
962 int err = 0;
963
964 if (port_ops && port_ops->reset_poll) {
965 err = port_ops->reset_poll(drive);
966 if (err) {
967 printk(KERN_ERR "%s: host reset_poll failure for %s.\n",
968 hwif->name, drive->name);
969 goto out;
970 }
971 }
972
973 tmp = hwif->tp_ops->read_status(hwif);
974
975 if (!OK_STAT(tmp, 0, ATA_BUSY)) {
976 if (time_before(jiffies, hwif->poll_timeout)) {
977 ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
978 /* continue polling */
979 return ide_started;
980 }
981 printk("%s: reset timed-out, status=0x%02x\n", hwif->name, tmp);
982 drive->failures++;
983 err = -EIO;
984 } else {
985 tmp = ide_read_error(drive);
986
987 if (tmp == 1) {
988 printk(KERN_INFO "%s: reset: success\n", hwif->name);
989 drive->failures = 0;
990 } else {
991 ide_reset_report_error(hwif, tmp);
992 drive->failures++;
993 err = -EIO;
994 }
995 }
996out:
997 hwif->polling = 0; /* done polling */
998 ide_complete_drive_reset(drive, err);
999 return ide_stopped;
1000}
1001
1002static void ide_disk_pre_reset(ide_drive_t *drive)
1003{
1004 int legacy = (drive->id[ATA_ID_CFS_ENABLE_2] & 0x0400) ? 0 : 1;
1005
1006 drive->special.all = 0;
1007 drive->special.b.set_geometry = legacy;
1008 drive->special.b.recalibrate = legacy;
1009
1010 drive->mult_count = 0;
1011 drive->dev_flags &= ~IDE_DFLAG_PARKED;
1012
1013 if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0 &&
1014 (drive->dev_flags & IDE_DFLAG_USING_DMA) == 0)
1015 drive->mult_req = 0;
1016
1017 if (drive->mult_req != drive->mult_count)
1018 drive->special.b.set_multmode = 1;
1019}
1020
1021static void pre_reset(ide_drive_t *drive)
1022{
1023 const struct ide_port_ops *port_ops = drive->hwif->port_ops;
1024
1025 if (drive->media == ide_disk)
1026 ide_disk_pre_reset(drive);
1027 else
1028 drive->dev_flags |= IDE_DFLAG_POST_RESET;
1029
1030 if (drive->dev_flags & IDE_DFLAG_USING_DMA) {
1031 if (drive->crc_count)
1032 ide_check_dma_crc(drive);
1033 else
1034 ide_dma_off(drive);
1035 }
1036
1037 if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0) {
1038 if ((drive->dev_flags & IDE_DFLAG_USING_DMA) == 0) {
1039 drive->dev_flags &= ~IDE_DFLAG_UNMASK;
1040 drive->io_32bit = 0;
1041 }
1042 return;
1043 }
1044
1045 if (port_ops && port_ops->pre_reset)
1046 port_ops->pre_reset(drive);
1047
1048 if (drive->current_speed != 0xff)
1049 drive->desired_speed = drive->current_speed;
1050 drive->current_speed = 0xff;
1051}
1052
1053/*
1054 * do_reset1() attempts to recover a confused drive by resetting it.
1055 * Unfortunately, resetting a disk drive actually resets all devices on
1056 * the same interface, so it can really be thought of as resetting the
1057 * interface rather than resetting the drive.
1058 *
1059 * ATAPI devices have their own reset mechanism which allows them to be
1060 * individually reset without clobbering other devices on the same interface.
1061 *
1062 * Unfortunately, the IDE interface does not generate an interrupt to let
1063 * us know when the reset operation has finished, so we must poll for this.
1064 * Equally poor, though, is the fact that this may a very long time to complete,
1065 * (up to 30 seconds worstcase). So, instead of busy-waiting here for it,
1066 * we set a timer to poll at 50ms intervals.
1067 */
1068static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
1069{
1070 ide_hwif_t *hwif = drive->hwif;
1071 struct ide_io_ports *io_ports = &hwif->io_ports;
1072 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
1073 const struct ide_port_ops *port_ops;
1074 ide_drive_t *tdrive;
1075 unsigned long flags, timeout;
1076 int i;
1077 DEFINE_WAIT(wait);
1078
1079 spin_lock_irqsave(&hwif->lock, flags);
1080
1081 /* We must not reset with running handlers */
1082 BUG_ON(hwif->handler != NULL);
1083
1084 /* For an ATAPI device, first try an ATAPI SRST. */
1085 if (drive->media != ide_disk && !do_not_try_atapi) {
1086 pre_reset(drive);
1087 SELECT_DRIVE(drive);
1088 udelay (20);
1089 tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
1090 ndelay(400);
1091 hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
1092 hwif->polling = 1;
1093 __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
1094 spin_unlock_irqrestore(&hwif->lock, flags);
1095 return ide_started;
1096 }
1097
1098 /* We must not disturb devices in the IDE_DFLAG_PARKED state. */
1099 do {
1100 unsigned long now;
1101
1102 prepare_to_wait(&ide_park_wq, &wait, TASK_UNINTERRUPTIBLE);
1103 timeout = jiffies;
1104 ide_port_for_each_dev(i, tdrive, hwif) {
1105 if (tdrive->dev_flags & IDE_DFLAG_PRESENT &&
1106 tdrive->dev_flags & IDE_DFLAG_PARKED &&
1107 time_after(tdrive->sleep, timeout))
1108 timeout = tdrive->sleep;
1109 }
1110
1111 now = jiffies;
1112 if (time_before_eq(timeout, now))
1113 break;
1114
1115 spin_unlock_irqrestore(&hwif->lock, flags);
1116 timeout = schedule_timeout_uninterruptible(timeout - now);
1117 spin_lock_irqsave(&hwif->lock, flags);
1118 } while (timeout);
1119 finish_wait(&ide_park_wq, &wait);
1120
1121 /*
1122 * First, reset any device state data we were maintaining
1123 * for any of the drives on this interface.
1124 */
1125 ide_port_for_each_dev(i, tdrive, hwif)
1126 pre_reset(tdrive);
1127
1128 if (io_ports->ctl_addr == 0) {
1129 spin_unlock_irqrestore(&hwif->lock, flags);
1130 ide_complete_drive_reset(drive, -ENXIO);
1131 return ide_stopped;
1132 }
1133
1134 /*
1135 * Note that we also set nIEN while resetting the device,
1136 * to mask unwanted interrupts from the interface during the reset.
1137 * However, due to the design of PC hardware, this will cause an
1138 * immediate interrupt due to the edge transition it produces.
1139 * This single interrupt gives us a "fast poll" for drives that
1140 * recover from reset very quickly, saving us the first 50ms wait time.
1141 *
1142 * TODO: add ->softreset method and stop abusing ->set_irq
1143 */
1144 /* set SRST and nIEN */
1145 tp_ops->set_irq(hwif, 4);
1146 /* more than enough time */
1147 udelay(10);
1148 /* clear SRST, leave nIEN (unless device is on the quirk list) */
1149 tp_ops->set_irq(hwif, drive->quirk_list == 2);
1150 /* more than enough time */
1151 udelay(10);
1152 hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
1153 hwif->polling = 1;
1154 __ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
1155
1156 /*
1157 * Some weird controller like resetting themselves to a strange
1158 * state when the disks are reset this way. At least, the Winbond
1159 * 553 documentation says that
1160 */
1161 port_ops = hwif->port_ops;
1162 if (port_ops && port_ops->resetproc)
1163 port_ops->resetproc(drive);
1164
1165 spin_unlock_irqrestore(&hwif->lock, flags);
1166 return ide_started;
1167}
1168
1169/*
1170 * ide_do_reset() is the entry point to the drive/interface reset code.
1171 */
1172
1173ide_startstop_t ide_do_reset (ide_drive_t *drive)
1174{
1175 return do_reset1(drive, 0);
1176}
1177
1178EXPORT_SYMBOL(ide_do_reset);
1179
1180/* 498/*
1181 * ide_wait_not_busy() waits for the currently selected device on the hwif 499 * ide_wait_not_busy() waits for the currently selected device on the hwif
1182 * to report a non-busy status, see comments in ide_probe_port(). 500 * to report a non-busy status, see comments in ide_probe_port().
@@ -1185,7 +503,7 @@ int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
1185{ 503{
1186 u8 stat = 0; 504 u8 stat = 0;
1187 505
1188 while(timeout--) { 506 while (timeout--) {
1189 /* 507 /*
1190 * Turn this into a schedule() sleep once I'm sure 508 * Turn this into a schedule() sleep once I'm sure
1191 * about locking issues (2.5 work ?). 509 * about locking issues (2.5 work ?).
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-08 18:42:21 -0500