85081a1e1b102a76740b1834085d7eee4c198a48
[linux-2.6.git] / drivers / scsi / libata-core.c
1 /*
2  *  libata-core.c - helper library for ATA
3  *
4  *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
5  *                  Please ALWAYS copy linux-ide@vger.kernel.org
6  *                  on emails.
7  *
8  *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
9  *  Copyright 2003-2004 Jeff Garzik
10  *
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2, or (at your option)
15  *  any later version.
16  *
17  *  This program is distributed in the hope that it will be useful,
18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *  GNU General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License
23  *  along with this program; see the file COPYING.  If not, write to
24  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25  *
26  *
27  *  libata documentation is available via 'make {ps|pdf}docs',
28  *  as Documentation/DocBook/libata.*
29  *
30  *  Hardware documentation available from http://www.t13.org/ and
31  *  http://www.sata-io.org/
32  *
33  */
34
35 #include <linux/config.h>
36 #include <linux/kernel.h>
37 #include <linux/module.h>
38 #include <linux/pci.h>
39 #include <linux/init.h>
40 #include <linux/list.h>
41 #include <linux/mm.h>
42 #include <linux/highmem.h>
43 #include <linux/spinlock.h>
44 #include <linux/blkdev.h>
45 #include <linux/delay.h>
46 #include <linux/timer.h>
47 #include <linux/interrupt.h>
48 #include <linux/completion.h>
49 #include <linux/suspend.h>
50 #include <linux/workqueue.h>
51 #include <linux/jiffies.h>
52 #include <linux/scatterlist.h>
53 #include <scsi/scsi.h>
54 #include "scsi.h"
55 #include "scsi_priv.h"
56 #include <scsi/scsi_host.h>
57 #include <linux/libata.h>
58 #include <asm/io.h>
59 #include <asm/semaphore.h>
60 #include <asm/byteorder.h>
61
62 #include "libata.h"
63
64 static unsigned int ata_busy_sleep (struct ata_port *ap,
65                                     unsigned long tmout_pat,
66                                     unsigned long tmout);
67 static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev);
68 static void ata_dev_init_params(struct ata_port *ap, struct ata_device *dev);
69 static void ata_set_mode(struct ata_port *ap);
70 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
71 static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift);
72 static int fgb(u32 bitmap);
73 static int ata_choose_xfer_mode(const struct ata_port *ap,
74                                 u8 *xfer_mode_out,
75                                 unsigned int *xfer_shift_out);
76 static void __ata_qc_complete(struct ata_queued_cmd *qc);
77 static void ata_pio_error(struct ata_port *ap);
78
79 static unsigned int ata_unique_id = 1;
80 static struct workqueue_struct *ata_wq;
81
82 int atapi_enabled = 0;
83 module_param(atapi_enabled, int, 0444);
84 MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
85
86 MODULE_AUTHOR("Jeff Garzik");
87 MODULE_DESCRIPTION("Library module for ATA devices");
88 MODULE_LICENSE("GPL");
89 MODULE_VERSION(DRV_VERSION);
90
91 /**
92  *      ata_tf_load_pio - send taskfile registers to host controller
93  *      @ap: Port to which output is sent
94  *      @tf: ATA taskfile register set
95  *
96  *      Outputs ATA taskfile to standard ATA host controller.
97  *
98  *      LOCKING:
99  *      Inherited from caller.
100  */
101
102 static void ata_tf_load_pio(struct ata_port *ap, const struct ata_taskfile *tf)
103 {
104         struct ata_ioports *ioaddr = &ap->ioaddr;
105         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
106
107         if (tf->ctl != ap->last_ctl) {
108                 outb(tf->ctl, ioaddr->ctl_addr);
109                 ap->last_ctl = tf->ctl;
110                 ata_wait_idle(ap);
111         }
112
113         if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
114                 outb(tf->hob_feature, ioaddr->feature_addr);
115                 outb(tf->hob_nsect, ioaddr->nsect_addr);
116                 outb(tf->hob_lbal, ioaddr->lbal_addr);
117                 outb(tf->hob_lbam, ioaddr->lbam_addr);
118                 outb(tf->hob_lbah, ioaddr->lbah_addr);
119                 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
120                         tf->hob_feature,
121                         tf->hob_nsect,
122                         tf->hob_lbal,
123                         tf->hob_lbam,
124                         tf->hob_lbah);
125         }
126
127         if (is_addr) {
128                 outb(tf->feature, ioaddr->feature_addr);
129                 outb(tf->nsect, ioaddr->nsect_addr);
130                 outb(tf->lbal, ioaddr->lbal_addr);
131                 outb(tf->lbam, ioaddr->lbam_addr);
132                 outb(tf->lbah, ioaddr->lbah_addr);
133                 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
134                         tf->feature,
135                         tf->nsect,
136                         tf->lbal,
137                         tf->lbam,
138                         tf->lbah);
139         }
140
141         if (tf->flags & ATA_TFLAG_DEVICE) {
142                 outb(tf->device, ioaddr->device_addr);
143                 VPRINTK("device 0x%X\n", tf->device);
144         }
145
146         ata_wait_idle(ap);
147 }
148
149 /**
150  *      ata_tf_load_mmio - send taskfile registers to host controller
151  *      @ap: Port to which output is sent
152  *      @tf: ATA taskfile register set
153  *
154  *      Outputs ATA taskfile to standard ATA host controller using MMIO.
155  *
156  *      LOCKING:
157  *      Inherited from caller.
158  */
159
160 static void ata_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
161 {
162         struct ata_ioports *ioaddr = &ap->ioaddr;
163         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
164
165         if (tf->ctl != ap->last_ctl) {
166                 writeb(tf->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
167                 ap->last_ctl = tf->ctl;
168                 ata_wait_idle(ap);
169         }
170
171         if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
172                 writeb(tf->hob_feature, (void __iomem *) ioaddr->feature_addr);
173                 writeb(tf->hob_nsect, (void __iomem *) ioaddr->nsect_addr);
174                 writeb(tf->hob_lbal, (void __iomem *) ioaddr->lbal_addr);
175                 writeb(tf->hob_lbam, (void __iomem *) ioaddr->lbam_addr);
176                 writeb(tf->hob_lbah, (void __iomem *) ioaddr->lbah_addr);
177                 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
178                         tf->hob_feature,
179                         tf->hob_nsect,
180                         tf->hob_lbal,
181                         tf->hob_lbam,
182                         tf->hob_lbah);
183         }
184
185         if (is_addr) {
186                 writeb(tf->feature, (void __iomem *) ioaddr->feature_addr);
187                 writeb(tf->nsect, (void __iomem *) ioaddr->nsect_addr);
188                 writeb(tf->lbal, (void __iomem *) ioaddr->lbal_addr);
189                 writeb(tf->lbam, (void __iomem *) ioaddr->lbam_addr);
190                 writeb(tf->lbah, (void __iomem *) ioaddr->lbah_addr);
191                 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
192                         tf->feature,
193                         tf->nsect,
194                         tf->lbal,
195                         tf->lbam,
196                         tf->lbah);
197         }
198
199         if (tf->flags & ATA_TFLAG_DEVICE) {
200                 writeb(tf->device, (void __iomem *) ioaddr->device_addr);
201                 VPRINTK("device 0x%X\n", tf->device);
202         }
203
204         ata_wait_idle(ap);
205 }
206
207
208 /**
209  *      ata_tf_load - send taskfile registers to host controller
210  *      @ap: Port to which output is sent
211  *      @tf: ATA taskfile register set
212  *
213  *      Outputs ATA taskfile to standard ATA host controller using MMIO
214  *      or PIO as indicated by the ATA_FLAG_MMIO flag.
215  *      Writes the control, feature, nsect, lbal, lbam, and lbah registers.
216  *      Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
217  *      hob_lbal, hob_lbam, and hob_lbah.
218  *
219  *      This function waits for idle (!BUSY and !DRQ) after writing
220  *      registers.  If the control register has a new value, this
221  *      function also waits for idle after writing control and before
222  *      writing the remaining registers.
223  *
224  *      May be used as the tf_load() entry in ata_port_operations.
225  *
226  *      LOCKING:
227  *      Inherited from caller.
228  */
229 void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
230 {
231         if (ap->flags & ATA_FLAG_MMIO)
232                 ata_tf_load_mmio(ap, tf);
233         else
234                 ata_tf_load_pio(ap, tf);
235 }
236
237 /**
238  *      ata_exec_command_pio - issue ATA command to host controller
239  *      @ap: port to which command is being issued
240  *      @tf: ATA taskfile register set
241  *
242  *      Issues PIO write to ATA command register, with proper
243  *      synchronization with interrupt handler / other threads.
244  *
245  *      LOCKING:
246  *      spin_lock_irqsave(host_set lock)
247  */
248
249 static void ata_exec_command_pio(struct ata_port *ap, const struct ata_taskfile *tf)
250 {
251         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
252
253         outb(tf->command, ap->ioaddr.command_addr);
254         ata_pause(ap);
255 }
256
257
258 /**
259  *      ata_exec_command_mmio - issue ATA command to host controller
260  *      @ap: port to which command is being issued
261  *      @tf: ATA taskfile register set
262  *
263  *      Issues MMIO write to ATA command register, with proper
264  *      synchronization with interrupt handler / other threads.
265  *
266  *      LOCKING:
267  *      spin_lock_irqsave(host_set lock)
268  */
269
270 static void ata_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
271 {
272         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
273
274         writeb(tf->command, (void __iomem *) ap->ioaddr.command_addr);
275         ata_pause(ap);
276 }
277
278
279 /**
280  *      ata_exec_command - issue ATA command to host controller
281  *      @ap: port to which command is being issued
282  *      @tf: ATA taskfile register set
283  *
284  *      Issues PIO/MMIO write to ATA command register, with proper
285  *      synchronization with interrupt handler / other threads.
286  *
287  *      LOCKING:
288  *      spin_lock_irqsave(host_set lock)
289  */
290 void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf)
291 {
292         if (ap->flags & ATA_FLAG_MMIO)
293                 ata_exec_command_mmio(ap, tf);
294         else
295                 ata_exec_command_pio(ap, tf);
296 }
297
298 /**
299  *      ata_tf_to_host - issue ATA taskfile to host controller
300  *      @ap: port to which command is being issued
301  *      @tf: ATA taskfile register set
302  *
303  *      Issues ATA taskfile register set to ATA host controller,
304  *      with proper synchronization with interrupt handler and
305  *      other threads.
306  *
307  *      LOCKING:
308  *      spin_lock_irqsave(host_set lock)
309  */
310
311 static inline void ata_tf_to_host(struct ata_port *ap,
312                                   const struct ata_taskfile *tf)
313 {
314         ap->ops->tf_load(ap, tf);
315         ap->ops->exec_command(ap, tf);
316 }
317
318 /**
319  *      ata_tf_read_pio - input device's ATA taskfile shadow registers
320  *      @ap: Port from which input is read
321  *      @tf: ATA taskfile register set for storing input
322  *
323  *      Reads ATA taskfile registers for currently-selected device
324  *      into @tf.
325  *
326  *      LOCKING:
327  *      Inherited from caller.
328  */
329
330 static void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
331 {
332         struct ata_ioports *ioaddr = &ap->ioaddr;
333
334         tf->command = ata_check_status(ap);
335         tf->feature = inb(ioaddr->error_addr);
336         tf->nsect = inb(ioaddr->nsect_addr);
337         tf->lbal = inb(ioaddr->lbal_addr);
338         tf->lbam = inb(ioaddr->lbam_addr);
339         tf->lbah = inb(ioaddr->lbah_addr);
340         tf->device = inb(ioaddr->device_addr);
341
342         if (tf->flags & ATA_TFLAG_LBA48) {
343                 outb(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
344                 tf->hob_feature = inb(ioaddr->error_addr);
345                 tf->hob_nsect = inb(ioaddr->nsect_addr);
346                 tf->hob_lbal = inb(ioaddr->lbal_addr);
347                 tf->hob_lbam = inb(ioaddr->lbam_addr);
348                 tf->hob_lbah = inb(ioaddr->lbah_addr);
349         }
350 }
351
352 /**
353  *      ata_tf_read_mmio - input device's ATA taskfile shadow registers
354  *      @ap: Port from which input is read
355  *      @tf: ATA taskfile register set for storing input
356  *
357  *      Reads ATA taskfile registers for currently-selected device
358  *      into @tf via MMIO.
359  *
360  *      LOCKING:
361  *      Inherited from caller.
362  */
363
364 static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
365 {
366         struct ata_ioports *ioaddr = &ap->ioaddr;
367
368         tf->command = ata_check_status(ap);
369         tf->feature = readb((void __iomem *)ioaddr->error_addr);
370         tf->nsect = readb((void __iomem *)ioaddr->nsect_addr);
371         tf->lbal = readb((void __iomem *)ioaddr->lbal_addr);
372         tf->lbam = readb((void __iomem *)ioaddr->lbam_addr);
373         tf->lbah = readb((void __iomem *)ioaddr->lbah_addr);
374         tf->device = readb((void __iomem *)ioaddr->device_addr);
375
376         if (tf->flags & ATA_TFLAG_LBA48) {
377                 writeb(tf->ctl | ATA_HOB, (void __iomem *) ap->ioaddr.ctl_addr);
378                 tf->hob_feature = readb((void __iomem *)ioaddr->error_addr);
379                 tf->hob_nsect = readb((void __iomem *)ioaddr->nsect_addr);
380                 tf->hob_lbal = readb((void __iomem *)ioaddr->lbal_addr);
381                 tf->hob_lbam = readb((void __iomem *)ioaddr->lbam_addr);
382                 tf->hob_lbah = readb((void __iomem *)ioaddr->lbah_addr);
383         }
384 }
385
386
387 /**
388  *      ata_tf_read - input device's ATA taskfile shadow registers
389  *      @ap: Port from which input is read
390  *      @tf: ATA taskfile register set for storing input
391  *
392  *      Reads ATA taskfile registers for currently-selected device
393  *      into @tf.
394  *
395  *      Reads nsect, lbal, lbam, lbah, and device.  If ATA_TFLAG_LBA48
396  *      is set, also reads the hob registers.
397  *
398  *      May be used as the tf_read() entry in ata_port_operations.
399  *
400  *      LOCKING:
401  *      Inherited from caller.
402  */
403 void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
404 {
405         if (ap->flags & ATA_FLAG_MMIO)
406                 ata_tf_read_mmio(ap, tf);
407         else
408                 ata_tf_read_pio(ap, tf);
409 }
410
411 /**
412  *      ata_check_status_pio - Read device status reg & clear interrupt
413  *      @ap: port where the device is
414  *
415  *      Reads ATA taskfile status register for currently-selected device
416  *      and return its value. This also clears pending interrupts
417  *      from this device
418  *
419  *      LOCKING:
420  *      Inherited from caller.
421  */
422 static u8 ata_check_status_pio(struct ata_port *ap)
423 {
424         return inb(ap->ioaddr.status_addr);
425 }
426
427 /**
428  *      ata_check_status_mmio - Read device status reg & clear interrupt
429  *      @ap: port where the device is
430  *
431  *      Reads ATA taskfile status register for currently-selected device
432  *      via MMIO and return its value. This also clears pending interrupts
433  *      from this device
434  *
435  *      LOCKING:
436  *      Inherited from caller.
437  */
438 static u8 ata_check_status_mmio(struct ata_port *ap)
439 {
440         return readb((void __iomem *) ap->ioaddr.status_addr);
441 }
442
443
444 /**
445  *      ata_check_status - Read device status reg & clear interrupt
446  *      @ap: port where the device is
447  *
448  *      Reads ATA taskfile status register for currently-selected device
449  *      and return its value. This also clears pending interrupts
450  *      from this device
451  *
452  *      May be used as the check_status() entry in ata_port_operations.
453  *
454  *      LOCKING:
455  *      Inherited from caller.
456  */
457 u8 ata_check_status(struct ata_port *ap)
458 {
459         if (ap->flags & ATA_FLAG_MMIO)
460                 return ata_check_status_mmio(ap);
461         return ata_check_status_pio(ap);
462 }
463
464
465 /**
466  *      ata_altstatus - Read device alternate status reg
467  *      @ap: port where the device is
468  *
469  *      Reads ATA taskfile alternate status register for
470  *      currently-selected device and return its value.
471  *
472  *      Note: may NOT be used as the check_altstatus() entry in
473  *      ata_port_operations.
474  *
475  *      LOCKING:
476  *      Inherited from caller.
477  */
478 u8 ata_altstatus(struct ata_port *ap)
479 {
480         if (ap->ops->check_altstatus)
481                 return ap->ops->check_altstatus(ap);
482
483         if (ap->flags & ATA_FLAG_MMIO)
484                 return readb((void __iomem *)ap->ioaddr.altstatus_addr);
485         return inb(ap->ioaddr.altstatus_addr);
486 }
487
488
489 /**
490  *      ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
491  *      @tf: Taskfile to convert
492  *      @fis: Buffer into which data will output
493  *      @pmp: Port multiplier port
494  *
495  *      Converts a standard ATA taskfile to a Serial ATA
496  *      FIS structure (Register - Host to Device).
497  *
498  *      LOCKING:
499  *      Inherited from caller.
500  */
501
502 void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
503 {
504         fis[0] = 0x27;  /* Register - Host to Device FIS */
505         fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
506                                             bit 7 indicates Command FIS */
507         fis[2] = tf->command;
508         fis[3] = tf->feature;
509
510         fis[4] = tf->lbal;
511         fis[5] = tf->lbam;
512         fis[6] = tf->lbah;
513         fis[7] = tf->device;
514
515         fis[8] = tf->hob_lbal;
516         fis[9] = tf->hob_lbam;
517         fis[10] = tf->hob_lbah;
518         fis[11] = tf->hob_feature;
519
520         fis[12] = tf->nsect;
521         fis[13] = tf->hob_nsect;
522         fis[14] = 0;
523         fis[15] = tf->ctl;
524
525         fis[16] = 0;
526         fis[17] = 0;
527         fis[18] = 0;
528         fis[19] = 0;
529 }
530
531 /**
532  *      ata_tf_from_fis - Convert SATA FIS to ATA taskfile
533  *      @fis: Buffer from which data will be input
534  *      @tf: Taskfile to output
535  *
536  *      Converts a standard ATA taskfile to a Serial ATA
537  *      FIS structure (Register - Host to Device).
538  *
539  *      LOCKING:
540  *      Inherited from caller.
541  */
542
543 void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
544 {
545         tf->command     = fis[2];       /* status */
546         tf->feature     = fis[3];       /* error */
547
548         tf->lbal        = fis[4];
549         tf->lbam        = fis[5];
550         tf->lbah        = fis[6];
551         tf->device      = fis[7];
552
553         tf->hob_lbal    = fis[8];
554         tf->hob_lbam    = fis[9];
555         tf->hob_lbah    = fis[10];
556
557         tf->nsect       = fis[12];
558         tf->hob_nsect   = fis[13];
559 }
560
561 static const u8 ata_rw_cmds[] = {
562         /* pio multi */
563         ATA_CMD_READ_MULTI,
564         ATA_CMD_WRITE_MULTI,
565         ATA_CMD_READ_MULTI_EXT,
566         ATA_CMD_WRITE_MULTI_EXT,
567         /* pio */
568         ATA_CMD_PIO_READ,
569         ATA_CMD_PIO_WRITE,
570         ATA_CMD_PIO_READ_EXT,
571         ATA_CMD_PIO_WRITE_EXT,
572         /* dma */
573         ATA_CMD_READ,
574         ATA_CMD_WRITE,
575         ATA_CMD_READ_EXT,
576         ATA_CMD_WRITE_EXT
577 };
578
579 /**
580  *      ata_rwcmd_protocol - set taskfile r/w commands and protocol
581  *      @qc: command to examine and configure
582  *
583  *      Examine the device configuration and tf->flags to calculate 
584  *      the proper read/write commands and protocol to use.
585  *
586  *      LOCKING:
587  *      caller.
588  */
589 void ata_rwcmd_protocol(struct ata_queued_cmd *qc)
590 {
591         struct ata_taskfile *tf = &qc->tf;
592         struct ata_device *dev = qc->dev;
593
594         int index, lba48, write;
595  
596         lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
597         write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
598
599         if (dev->flags & ATA_DFLAG_PIO) {
600                 tf->protocol = ATA_PROT_PIO;
601                 index = dev->multi_count ? 0 : 4;
602         } else {
603                 tf->protocol = ATA_PROT_DMA;
604                 index = 8;
605         }
606
607         tf->command = ata_rw_cmds[index + lba48 + write];
608 }
609
610 static const char * xfer_mode_str[] = {
611         "UDMA/16",
612         "UDMA/25",
613         "UDMA/33",
614         "UDMA/44",
615         "UDMA/66",
616         "UDMA/100",
617         "UDMA/133",
618         "UDMA7",
619         "MWDMA0",
620         "MWDMA1",
621         "MWDMA2",
622         "PIO0",
623         "PIO1",
624         "PIO2",
625         "PIO3",
626         "PIO4",
627 };
628
629 /**
630  *      ata_udma_string - convert UDMA bit offset to string
631  *      @mask: mask of bits supported; only highest bit counts.
632  *
633  *      Determine string which represents the highest speed
634  *      (highest bit in @udma_mask).
635  *
636  *      LOCKING:
637  *      None.
638  *
639  *      RETURNS:
640  *      Constant C string representing highest speed listed in
641  *      @udma_mask, or the constant C string "<n/a>".
642  */
643
644 static const char *ata_mode_string(unsigned int mask)
645 {
646         int i;
647
648         for (i = 7; i >= 0; i--)
649                 if (mask & (1 << i))
650                         goto out;
651         for (i = ATA_SHIFT_MWDMA + 2; i >= ATA_SHIFT_MWDMA; i--)
652                 if (mask & (1 << i))
653                         goto out;
654         for (i = ATA_SHIFT_PIO + 4; i >= ATA_SHIFT_PIO; i--)
655                 if (mask & (1 << i))
656                         goto out;
657
658         return "<n/a>";
659
660 out:
661         return xfer_mode_str[i];
662 }
663
664 /**
665  *      ata_pio_devchk - PATA device presence detection
666  *      @ap: ATA channel to examine
667  *      @device: Device to examine (starting at zero)
668  *
669  *      This technique was originally described in
670  *      Hale Landis's ATADRVR (www.ata-atapi.com), and
671  *      later found its way into the ATA/ATAPI spec.
672  *
673  *      Write a pattern to the ATA shadow registers,
674  *      and if a device is present, it will respond by
675  *      correctly storing and echoing back the
676  *      ATA shadow register contents.
677  *
678  *      LOCKING:
679  *      caller.
680  */
681
682 static unsigned int ata_pio_devchk(struct ata_port *ap,
683                                    unsigned int device)
684 {
685         struct ata_ioports *ioaddr = &ap->ioaddr;
686         u8 nsect, lbal;
687
688         ap->ops->dev_select(ap, device);
689
690         outb(0x55, ioaddr->nsect_addr);
691         outb(0xaa, ioaddr->lbal_addr);
692
693         outb(0xaa, ioaddr->nsect_addr);
694         outb(0x55, ioaddr->lbal_addr);
695
696         outb(0x55, ioaddr->nsect_addr);
697         outb(0xaa, ioaddr->lbal_addr);
698
699         nsect = inb(ioaddr->nsect_addr);
700         lbal = inb(ioaddr->lbal_addr);
701
702         if ((nsect == 0x55) && (lbal == 0xaa))
703                 return 1;       /* we found a device */
704
705         return 0;               /* nothing found */
706 }
707
708 /**
709  *      ata_mmio_devchk - PATA device presence detection
710  *      @ap: ATA channel to examine
711  *      @device: Device to examine (starting at zero)
712  *
713  *      This technique was originally described in
714  *      Hale Landis's ATADRVR (www.ata-atapi.com), and
715  *      later found its way into the ATA/ATAPI spec.
716  *
717  *      Write a pattern to the ATA shadow registers,
718  *      and if a device is present, it will respond by
719  *      correctly storing and echoing back the
720  *      ATA shadow register contents.
721  *
722  *      LOCKING:
723  *      caller.
724  */
725
726 static unsigned int ata_mmio_devchk(struct ata_port *ap,
727                                     unsigned int device)
728 {
729         struct ata_ioports *ioaddr = &ap->ioaddr;
730         u8 nsect, lbal;
731
732         ap->ops->dev_select(ap, device);
733
734         writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
735         writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
736
737         writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
738         writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
739
740         writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
741         writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
742
743         nsect = readb((void __iomem *) ioaddr->nsect_addr);
744         lbal = readb((void __iomem *) ioaddr->lbal_addr);
745
746         if ((nsect == 0x55) && (lbal == 0xaa))
747                 return 1;       /* we found a device */
748
749         return 0;               /* nothing found */
750 }
751
752 /**
753  *      ata_devchk - PATA device presence detection
754  *      @ap: ATA channel to examine
755  *      @device: Device to examine (starting at zero)
756  *
757  *      Dispatch ATA device presence detection, depending
758  *      on whether we are using PIO or MMIO to talk to the
759  *      ATA shadow registers.
760  *
761  *      LOCKING:
762  *      caller.
763  */
764
765 static unsigned int ata_devchk(struct ata_port *ap,
766                                     unsigned int device)
767 {
768         if (ap->flags & ATA_FLAG_MMIO)
769                 return ata_mmio_devchk(ap, device);
770         return ata_pio_devchk(ap, device);
771 }
772
773 /**
774  *      ata_dev_classify - determine device type based on ATA-spec signature
775  *      @tf: ATA taskfile register set for device to be identified
776  *
777  *      Determine from taskfile register contents whether a device is
778  *      ATA or ATAPI, as per "Signature and persistence" section
779  *      of ATA/PI spec (volume 1, sect 5.14).
780  *
781  *      LOCKING:
782  *      None.
783  *
784  *      RETURNS:
785  *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
786  *      the event of failure.
787  */
788
789 unsigned int ata_dev_classify(const struct ata_taskfile *tf)
790 {
791         /* Apple's open source Darwin code hints that some devices only
792          * put a proper signature into the LBA mid/high registers,
793          * So, we only check those.  It's sufficient for uniqueness.
794          */
795
796         if (((tf->lbam == 0) && (tf->lbah == 0)) ||
797             ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
798                 DPRINTK("found ATA device by sig\n");
799                 return ATA_DEV_ATA;
800         }
801
802         if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
803             ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
804                 DPRINTK("found ATAPI device by sig\n");
805                 return ATA_DEV_ATAPI;
806         }
807
808         DPRINTK("unknown device\n");
809         return ATA_DEV_UNKNOWN;
810 }
811
812 /**
813  *      ata_dev_try_classify - Parse returned ATA device signature
814  *      @ap: ATA channel to examine
815  *      @device: Device to examine (starting at zero)
816  *
817  *      After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
818  *      an ATA/ATAPI-defined set of values is placed in the ATA
819  *      shadow registers, indicating the results of device detection
820  *      and diagnostics.
821  *
822  *      Select the ATA device, and read the values from the ATA shadow
823  *      registers.  Then parse according to the Error register value,
824  *      and the spec-defined values examined by ata_dev_classify().
825  *
826  *      LOCKING:
827  *      caller.
828  */
829
830 static u8 ata_dev_try_classify(struct ata_port *ap, unsigned int device)
831 {
832         struct ata_device *dev = &ap->device[device];
833         struct ata_taskfile tf;
834         unsigned int class;
835         u8 err;
836
837         ap->ops->dev_select(ap, device);
838
839         memset(&tf, 0, sizeof(tf));
840
841         ap->ops->tf_read(ap, &tf);
842         err = tf.feature;
843
844         dev->class = ATA_DEV_NONE;
845
846         /* see if device passed diags */
847         if (err == 1)
848                 /* do nothing */ ;
849         else if ((device == 0) && (err == 0x81))
850                 /* do nothing */ ;
851         else
852                 return err;
853
854         /* determine if device if ATA or ATAPI */
855         class = ata_dev_classify(&tf);
856         if (class == ATA_DEV_UNKNOWN)
857                 return err;
858         if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
859                 return err;
860
861         dev->class = class;
862
863         return err;
864 }
865
866 /**
867  *      ata_dev_id_string - Convert IDENTIFY DEVICE page into string
868  *      @id: IDENTIFY DEVICE results we will examine
869  *      @s: string into which data is output
870  *      @ofs: offset into identify device page
871  *      @len: length of string to return. must be an even number.
872  *
873  *      The strings in the IDENTIFY DEVICE page are broken up into
874  *      16-bit chunks.  Run through the string, and output each
875  *      8-bit chunk linearly, regardless of platform.
876  *
877  *      LOCKING:
878  *      caller.
879  */
880
881 void ata_dev_id_string(const u16 *id, unsigned char *s,
882                        unsigned int ofs, unsigned int len)
883 {
884         unsigned int c;
885
886         while (len > 0) {
887                 c = id[ofs] >> 8;
888                 *s = c;
889                 s++;
890
891                 c = id[ofs] & 0xff;
892                 *s = c;
893                 s++;
894
895                 ofs++;
896                 len -= 2;
897         }
898 }
899
900
901 /**
902  *      ata_noop_dev_select - Select device 0/1 on ATA bus
903  *      @ap: ATA channel to manipulate
904  *      @device: ATA device (numbered from zero) to select
905  *
906  *      This function performs no actual function.
907  *
908  *      May be used as the dev_select() entry in ata_port_operations.
909  *
910  *      LOCKING:
911  *      caller.
912  */
913 void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
914 {
915 }
916
917
918 /**
919  *      ata_std_dev_select - Select device 0/1 on ATA bus
920  *      @ap: ATA channel to manipulate
921  *      @device: ATA device (numbered from zero) to select
922  *
923  *      Use the method defined in the ATA specification to
924  *      make either device 0, or device 1, active on the
925  *      ATA channel.  Works with both PIO and MMIO.
926  *
927  *      May be used as the dev_select() entry in ata_port_operations.
928  *
929  *      LOCKING:
930  *      caller.
931  */
932
933 void ata_std_dev_select (struct ata_port *ap, unsigned int device)
934 {
935         u8 tmp;
936
937         if (device == 0)
938                 tmp = ATA_DEVICE_OBS;
939         else
940                 tmp = ATA_DEVICE_OBS | ATA_DEV1;
941
942         if (ap->flags & ATA_FLAG_MMIO) {
943                 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
944         } else {
945                 outb(tmp, ap->ioaddr.device_addr);
946         }
947         ata_pause(ap);          /* needed; also flushes, for mmio */
948 }
949
950 /**
951  *      ata_dev_select - Select device 0/1 on ATA bus
952  *      @ap: ATA channel to manipulate
953  *      @device: ATA device (numbered from zero) to select
954  *      @wait: non-zero to wait for Status register BSY bit to clear
955  *      @can_sleep: non-zero if context allows sleeping
956  *
957  *      Use the method defined in the ATA specification to
958  *      make either device 0, or device 1, active on the
959  *      ATA channel.
960  *
961  *      This is a high-level version of ata_std_dev_select(),
962  *      which additionally provides the services of inserting
963  *      the proper pauses and status polling, where needed.
964  *
965  *      LOCKING:
966  *      caller.
967  */
968
969 void ata_dev_select(struct ata_port *ap, unsigned int device,
970                            unsigned int wait, unsigned int can_sleep)
971 {
972         VPRINTK("ENTER, ata%u: device %u, wait %u\n",
973                 ap->id, device, wait);
974
975         if (wait)
976                 ata_wait_idle(ap);
977
978         ap->ops->dev_select(ap, device);
979
980         if (wait) {
981                 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
982                         msleep(150);
983                 ata_wait_idle(ap);
984         }
985 }
986
987 /**
988  *      ata_dump_id - IDENTIFY DEVICE info debugging output
989  *      @dev: Device whose IDENTIFY DEVICE page we will dump
990  *
991  *      Dump selected 16-bit words from a detected device's
992  *      IDENTIFY PAGE page.
993  *
994  *      LOCKING:
995  *      caller.
996  */
997
998 static inline void ata_dump_id(const struct ata_device *dev)
999 {
1000         DPRINTK("49==0x%04x  "
1001                 "53==0x%04x  "
1002                 "63==0x%04x  "
1003                 "64==0x%04x  "
1004                 "75==0x%04x  \n",
1005                 dev->id[49],
1006                 dev->id[53],
1007                 dev->id[63],
1008                 dev->id[64],
1009                 dev->id[75]);
1010         DPRINTK("80==0x%04x  "
1011                 "81==0x%04x  "
1012                 "82==0x%04x  "
1013                 "83==0x%04x  "
1014                 "84==0x%04x  \n",
1015                 dev->id[80],
1016                 dev->id[81],
1017                 dev->id[82],
1018                 dev->id[83],
1019                 dev->id[84]);
1020         DPRINTK("88==0x%04x  "
1021                 "93==0x%04x\n",
1022                 dev->id[88],
1023                 dev->id[93]);
1024 }
1025
1026 /*
1027  *      Compute the PIO modes available for this device. This is not as
1028  *      trivial as it seems if we must consider early devices correctly.
1029  *
1030  *      FIXME: pre IDE drive timing (do we care ?). 
1031  */
1032
1033 static unsigned int ata_pio_modes(const struct ata_device *adev)
1034 {
1035         u16 modes;
1036
1037         /* Usual case. Word 53 indicates word 88 is valid */
1038         if (adev->id[ATA_ID_FIELD_VALID] & (1 << 2)) {
1039                 modes = adev->id[ATA_ID_PIO_MODES] & 0x03;
1040                 modes <<= 3;
1041                 modes |= 0x7;
1042                 return modes;
1043         }
1044
1045         /* If word 88 isn't valid then Word 51 holds the PIO timing number
1046            for the maximum. Turn it into a mask and return it */
1047         modes = (2 << (adev->id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
1048         return modes;
1049 }
1050
1051 /**
1052  *      ata_dev_identify - obtain IDENTIFY x DEVICE page
1053  *      @ap: port on which device we wish to probe resides
1054  *      @device: device bus address, starting at zero
1055  *
1056  *      Following bus reset, we issue the IDENTIFY [PACKET] DEVICE
1057  *      command, and read back the 512-byte device information page.
1058  *      The device information page is fed to us via the standard
1059  *      PIO-IN protocol, but we hand-code it here. (TODO: investigate
1060  *      using standard PIO-IN paths)
1061  *
1062  *      After reading the device information page, we use several
1063  *      bits of information from it to initialize data structures
1064  *      that will be used during the lifetime of the ata_device.
1065  *      Other data from the info page is used to disqualify certain
1066  *      older ATA devices we do not wish to support.
1067  *
1068  *      LOCKING:
1069  *      Inherited from caller.  Some functions called by this function
1070  *      obtain the host_set lock.
1071  */
1072
1073 static void ata_dev_identify(struct ata_port *ap, unsigned int device)
1074 {
1075         struct ata_device *dev = &ap->device[device];
1076         unsigned int major_version;
1077         u16 tmp;
1078         unsigned long xfer_modes;
1079         unsigned int using_edd;
1080         DECLARE_COMPLETION(wait);
1081         struct ata_queued_cmd *qc;
1082         unsigned long flags;
1083         int rc;
1084
1085         if (!ata_dev_present(dev)) {
1086                 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
1087                         ap->id, device);
1088                 return;
1089         }
1090
1091         if (ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
1092                 using_edd = 0;
1093         else
1094                 using_edd = 1;
1095
1096         DPRINTK("ENTER, host %u, dev %u\n", ap->id, device);
1097
1098         assert (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ATAPI ||
1099                 dev->class == ATA_DEV_NONE);
1100
1101         ata_dev_select(ap, device, 1, 1); /* select device 0/1 */
1102
1103         qc = ata_qc_new_init(ap, dev);
1104         BUG_ON(qc == NULL);
1105
1106         ata_sg_init_one(qc, dev->id, sizeof(dev->id));
1107         qc->dma_dir = DMA_FROM_DEVICE;
1108         qc->tf.protocol = ATA_PROT_PIO;
1109         qc->nsect = 1;
1110
1111 retry:
1112         if (dev->class == ATA_DEV_ATA) {
1113                 qc->tf.command = ATA_CMD_ID_ATA;
1114                 DPRINTK("do ATA identify\n");
1115         } else {
1116                 qc->tf.command = ATA_CMD_ID_ATAPI;
1117                 DPRINTK("do ATAPI identify\n");
1118         }
1119
1120         qc->waiting = &wait;
1121         qc->complete_fn = ata_qc_complete_noop;
1122
1123         spin_lock_irqsave(&ap->host_set->lock, flags);
1124         rc = ata_qc_issue(qc);
1125         spin_unlock_irqrestore(&ap->host_set->lock, flags);
1126
1127         if (rc)
1128                 goto err_out;
1129         else
1130                 wait_for_completion(&wait);
1131
1132         spin_lock_irqsave(&ap->host_set->lock, flags);
1133         ap->ops->tf_read(ap, &qc->tf);
1134         spin_unlock_irqrestore(&ap->host_set->lock, flags);
1135
1136         if (qc->tf.command & ATA_ERR) {
1137                 /*
1138                  * arg!  EDD works for all test cases, but seems to return
1139                  * the ATA signature for some ATAPI devices.  Until the
1140                  * reason for this is found and fixed, we fix up the mess
1141                  * here.  If IDENTIFY DEVICE returns command aborted
1142                  * (as ATAPI devices do), then we issue an
1143                  * IDENTIFY PACKET DEVICE.
1144                  *
1145                  * ATA software reset (SRST, the default) does not appear
1146                  * to have this problem.
1147                  */
1148                 if ((using_edd) && (qc->tf.command == ATA_CMD_ID_ATA)) {
1149                         u8 err = qc->tf.feature;
1150                         if (err & ATA_ABORTED) {
1151                                 dev->class = ATA_DEV_ATAPI;
1152                                 qc->cursg = 0;
1153                                 qc->cursg_ofs = 0;
1154                                 qc->cursect = 0;
1155                                 qc->nsect = 1;
1156                                 goto retry;
1157                         }
1158                 }
1159                 goto err_out;
1160         }
1161
1162         swap_buf_le16(dev->id, ATA_ID_WORDS);
1163
1164         /* print device capabilities */
1165         printk(KERN_DEBUG "ata%u: dev %u cfg "
1166                "49:%04x 82:%04x 83:%04x 84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1167                ap->id, device, dev->id[49],
1168                dev->id[82], dev->id[83], dev->id[84],
1169                dev->id[85], dev->id[86], dev->id[87],
1170                dev->id[88]);
1171
1172         /*
1173          * common ATA, ATAPI feature tests
1174          */
1175
1176         /* we require DMA support (bits 8 of word 49) */
1177         if (!ata_id_has_dma(dev->id)) {
1178                 printk(KERN_DEBUG "ata%u: no dma\n", ap->id);
1179                 goto err_out_nosup;
1180         }
1181
1182         /* quick-n-dirty find max transfer mode; for printk only */
1183         xfer_modes = dev->id[ATA_ID_UDMA_MODES];
1184         if (!xfer_modes)
1185                 xfer_modes = (dev->id[ATA_ID_MWDMA_MODES]) << ATA_SHIFT_MWDMA;
1186         if (!xfer_modes)
1187                 xfer_modes = ata_pio_modes(dev);
1188
1189         ata_dump_id(dev);
1190
1191         /* ATA-specific feature tests */
1192         if (dev->class == ATA_DEV_ATA) {
1193                 if (!ata_id_is_ata(dev->id))    /* sanity check */
1194                         goto err_out_nosup;
1195
1196                 /* get major version */
1197                 tmp = dev->id[ATA_ID_MAJOR_VER];
1198                 for (major_version = 14; major_version >= 1; major_version--)
1199                         if (tmp & (1 << major_version))
1200                                 break;
1201
1202                 /*
1203                  * The exact sequence expected by certain pre-ATA4 drives is:
1204                  * SRST RESET
1205                  * IDENTIFY
1206                  * INITIALIZE DEVICE PARAMETERS
1207                  * anything else..
1208                  * Some drives were very specific about that exact sequence.
1209                  */
1210                 if (major_version < 4 || (!ata_id_has_lba(dev->id))) {
1211                         ata_dev_init_params(ap, dev);
1212
1213                         /* current CHS translation info (id[53-58]) might be
1214                          * changed. reread the identify device info.
1215                          */
1216                         ata_dev_reread_id(ap, dev);
1217                 }
1218
1219                 if (ata_id_has_lba(dev->id)) {
1220                         dev->flags |= ATA_DFLAG_LBA;
1221
1222                         if (ata_id_has_lba48(dev->id)) {
1223                                 dev->flags |= ATA_DFLAG_LBA48;
1224                                 dev->n_sectors = ata_id_u64(dev->id, 100);
1225                         } else {
1226                                 dev->n_sectors = ata_id_u32(dev->id, 60);
1227                         }
1228
1229                         /* print device info to dmesg */
1230                         printk(KERN_INFO "ata%u: dev %u ATA-%d, max %s, %Lu sectors:%s\n",
1231                                ap->id, device,
1232                                major_version,
1233                                ata_mode_string(xfer_modes),
1234                                (unsigned long long)dev->n_sectors,
1235                                dev->flags & ATA_DFLAG_LBA48 ? " LBA48" : " LBA");
1236                 } else { 
1237                         /* CHS */
1238
1239                         /* Default translation */
1240                         dev->cylinders  = dev->id[1];
1241                         dev->heads      = dev->id[3];
1242                         dev->sectors    = dev->id[6];
1243                         dev->n_sectors  = dev->cylinders * dev->heads * dev->sectors;
1244
1245                         if (ata_id_current_chs_valid(dev->id)) {
1246                                 /* Current CHS translation is valid. */
1247                                 dev->cylinders = dev->id[54];
1248                                 dev->heads     = dev->id[55];
1249                                 dev->sectors   = dev->id[56];
1250                                 
1251                                 dev->n_sectors = ata_id_u32(dev->id, 57);
1252                         }
1253
1254                         /* print device info to dmesg */
1255                         printk(KERN_INFO "ata%u: dev %u ATA-%d, max %s, %Lu sectors: CHS %d/%d/%d\n",
1256                                ap->id, device,
1257                                major_version,
1258                                ata_mode_string(xfer_modes),
1259                                (unsigned long long)dev->n_sectors,
1260                                (int)dev->cylinders, (int)dev->heads, (int)dev->sectors);
1261
1262                 }
1263
1264                 ap->host->max_cmd_len = 16;
1265         }
1266
1267         /* ATAPI-specific feature tests */
1268         else {
1269                 if (ata_id_is_ata(dev->id))             /* sanity check */
1270                         goto err_out_nosup;
1271
1272                 rc = atapi_cdb_len(dev->id);
1273                 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1274                         printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
1275                         goto err_out_nosup;
1276                 }
1277                 ap->cdb_len = (unsigned int) rc;
1278                 ap->host->max_cmd_len = (unsigned char) ap->cdb_len;
1279
1280                 if (ata_id_cdb_intr(dev->id))
1281                         dev->flags |= ATA_DFLAG_CDB_INTR;
1282
1283                 /* print device info to dmesg */
1284                 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
1285                        ap->id, device,
1286                        ata_mode_string(xfer_modes));
1287         }
1288
1289         DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
1290         return;
1291
1292 err_out_nosup:
1293         printk(KERN_WARNING "ata%u: dev %u not supported, ignoring\n",
1294                ap->id, device);
1295 err_out:
1296         dev->class++;   /* converts ATA_DEV_xxx into ATA_DEV_xxx_UNSUP */
1297         DPRINTK("EXIT, err\n");
1298 }
1299
1300
1301 static inline u8 ata_dev_knobble(const struct ata_port *ap)
1302 {
1303         return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(ap->device->id)));
1304 }
1305
1306 /**
1307  *      ata_dev_config - Run device specific handlers and check for
1308  *                       SATA->PATA bridges
1309  *      @ap: Bus
1310  *      @i:  Device
1311  *
1312  *      LOCKING:
1313  */
1314
1315 void ata_dev_config(struct ata_port *ap, unsigned int i)
1316 {
1317         /* limit bridge transfers to udma5, 200 sectors */
1318         if (ata_dev_knobble(ap)) {
1319                 printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
1320                         ap->id, ap->device->devno);
1321                 ap->udma_mask &= ATA_UDMA5;
1322                 ap->host->max_sectors = ATA_MAX_SECTORS;
1323                 ap->host->hostt->max_sectors = ATA_MAX_SECTORS;
1324                 ap->device->flags |= ATA_DFLAG_LOCK_SECTORS;
1325         }
1326
1327         if (ap->ops->dev_config)
1328                 ap->ops->dev_config(ap, &ap->device[i]);
1329 }
1330
1331 /**
1332  *      ata_bus_probe - Reset and probe ATA bus
1333  *      @ap: Bus to probe
1334  *
1335  *      Master ATA bus probing function.  Initiates a hardware-dependent
1336  *      bus reset, then attempts to identify any devices found on
1337  *      the bus.
1338  *
1339  *      LOCKING:
1340  *      PCI/etc. bus probe sem.
1341  *
1342  *      RETURNS:
1343  *      Zero on success, non-zero on error.
1344  */
1345
1346 static int ata_bus_probe(struct ata_port *ap)
1347 {
1348         unsigned int i, found = 0;
1349
1350         ap->ops->phy_reset(ap);
1351         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1352                 goto err_out;
1353
1354         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1355                 ata_dev_identify(ap, i);
1356                 if (ata_dev_present(&ap->device[i])) {
1357                         found = 1;
1358                         ata_dev_config(ap,i);
1359                 }
1360         }
1361
1362         if ((!found) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1363                 goto err_out_disable;
1364
1365         ata_set_mode(ap);
1366         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1367                 goto err_out_disable;
1368
1369         return 0;
1370
1371 err_out_disable:
1372         ap->ops->port_disable(ap);
1373 err_out:
1374         return -1;
1375 }
1376
1377 /**
1378  *      ata_port_probe - Mark port as enabled
1379  *      @ap: Port for which we indicate enablement
1380  *
1381  *      Modify @ap data structure such that the system
1382  *      thinks that the entire port is enabled.
1383  *
1384  *      LOCKING: host_set lock, or some other form of
1385  *      serialization.
1386  */
1387
1388 void ata_port_probe(struct ata_port *ap)
1389 {
1390         ap->flags &= ~ATA_FLAG_PORT_DISABLED;
1391 }
1392
1393 /**
1394  *      __sata_phy_reset - Wake/reset a low-level SATA PHY
1395  *      @ap: SATA port associated with target SATA PHY.
1396  *
1397  *      This function issues commands to standard SATA Sxxx
1398  *      PHY registers, to wake up the phy (and device), and
1399  *      clear any reset condition.
1400  *
1401  *      LOCKING:
1402  *      PCI/etc. bus probe sem.
1403  *
1404  */
1405 void __sata_phy_reset(struct ata_port *ap)
1406 {
1407         u32 sstatus;
1408         unsigned long timeout = jiffies + (HZ * 5);
1409
1410         if (ap->flags & ATA_FLAG_SATA_RESET) {
1411                 /* issue phy wake/reset */
1412                 scr_write_flush(ap, SCR_CONTROL, 0x301);
1413                 /* Couldn't find anything in SATA I/II specs, but
1414                  * AHCI-1.1 10.4.2 says at least 1 ms. */
1415                 mdelay(1);
1416         }
1417         scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
1418
1419         /* wait for phy to become ready, if necessary */
1420         do {
1421                 msleep(200);
1422                 sstatus = scr_read(ap, SCR_STATUS);
1423                 if ((sstatus & 0xf) != 1)
1424                         break;
1425         } while (time_before(jiffies, timeout));
1426
1427         /* TODO: phy layer with polling, timeouts, etc. */
1428         if (sata_dev_present(ap))
1429                 ata_port_probe(ap);
1430         else {
1431                 sstatus = scr_read(ap, SCR_STATUS);
1432                 printk(KERN_INFO "ata%u: no device found (phy stat %08x)\n",
1433                        ap->id, sstatus);
1434                 ata_port_disable(ap);
1435         }
1436
1437         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1438                 return;
1439
1440         if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1441                 ata_port_disable(ap);
1442                 return;
1443         }
1444
1445         ap->cbl = ATA_CBL_SATA;
1446 }
1447
1448 /**
1449  *      sata_phy_reset - Reset SATA bus.
1450  *      @ap: SATA port associated with target SATA PHY.
1451  *
1452  *      This function resets the SATA bus, and then probes
1453  *      the bus for devices.
1454  *
1455  *      LOCKING:
1456  *      PCI/etc. bus probe sem.
1457  *
1458  */
1459 void sata_phy_reset(struct ata_port *ap)
1460 {
1461         __sata_phy_reset(ap);
1462         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1463                 return;
1464         ata_bus_reset(ap);
1465 }
1466
1467 /**
1468  *      ata_port_disable - Disable port.
1469  *      @ap: Port to be disabled.
1470  *
1471  *      Modify @ap data structure such that the system
1472  *      thinks that the entire port is disabled, and should
1473  *      never attempt to probe or communicate with devices
1474  *      on this port.
1475  *
1476  *      LOCKING: host_set lock, or some other form of
1477  *      serialization.
1478  */
1479
1480 void ata_port_disable(struct ata_port *ap)
1481 {
1482         ap->device[0].class = ATA_DEV_NONE;
1483         ap->device[1].class = ATA_DEV_NONE;
1484         ap->flags |= ATA_FLAG_PORT_DISABLED;
1485 }
1486
1487 /*
1488  * This mode timing computation functionality is ported over from
1489  * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
1490  */
1491 /*
1492  * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
1493  * These were taken from ATA/ATAPI-6 standard, rev 0a, except
1494  * for PIO 5, which is a nonstandard extension and UDMA6, which
1495  * is currently supported only by Maxtor drives. 
1496  */
1497
1498 static const struct ata_timing ata_timing[] = {
1499
1500         { XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
1501         { XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
1502         { XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
1503         { XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },
1504
1505         { XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
1506         { XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
1507         { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
1508
1509 /*      { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
1510                                           
1511         { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
1512         { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
1513         { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
1514                                           
1515         { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
1516         { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
1517         { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
1518
1519 /*      { XFER_PIO_5,     20,  50,  30, 100,  50,  30, 100,   0 }, */
1520         { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
1521         { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },
1522
1523         { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
1524         { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
1525         { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },
1526
1527 /*      { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */
1528
1529         { 0xFF }
1530 };
1531
1532 #define ENOUGH(v,unit)          (((v)-1)/(unit)+1)
1533 #define EZ(v,unit)              ((v)?ENOUGH(v,unit):0)
1534
1535 static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
1536 {
1537         q->setup   = EZ(t->setup   * 1000,  T);
1538         q->act8b   = EZ(t->act8b   * 1000,  T);
1539         q->rec8b   = EZ(t->rec8b   * 1000,  T);
1540         q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
1541         q->active  = EZ(t->active  * 1000,  T);
1542         q->recover = EZ(t->recover * 1000,  T);
1543         q->cycle   = EZ(t->cycle   * 1000,  T);
1544         q->udma    = EZ(t->udma    * 1000, UT);
1545 }
1546
1547 void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
1548                       struct ata_timing *m, unsigned int what)
1549 {
1550         if (what & ATA_TIMING_SETUP  ) m->setup   = max(a->setup,   b->setup);
1551         if (what & ATA_TIMING_ACT8B  ) m->act8b   = max(a->act8b,   b->act8b);
1552         if (what & ATA_TIMING_REC8B  ) m->rec8b   = max(a->rec8b,   b->rec8b);
1553         if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
1554         if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
1555         if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
1556         if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
1557         if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
1558 }
1559
1560 static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
1561 {
1562         const struct ata_timing *t;
1563
1564         for (t = ata_timing; t->mode != speed; t++)
1565                 if (t->mode == 0xFF)
1566                         return NULL;
1567         return t; 
1568 }
1569
1570 int ata_timing_compute(struct ata_device *adev, unsigned short speed,
1571                        struct ata_timing *t, int T, int UT)
1572 {
1573         const struct ata_timing *s;
1574         struct ata_timing p;
1575
1576         /*
1577          * Find the mode. 
1578         */
1579
1580         if (!(s = ata_timing_find_mode(speed)))
1581                 return -EINVAL;
1582
1583         /*
1584          * If the drive is an EIDE drive, it can tell us it needs extended
1585          * PIO/MW_DMA cycle timing.
1586          */
1587
1588         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
1589                 memset(&p, 0, sizeof(p));
1590                 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
1591                         if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
1592                                             else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
1593                 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
1594                         p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
1595                 }
1596                 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
1597         }
1598
1599         /*
1600          * Convert the timing to bus clock counts.
1601          */
1602
1603         ata_timing_quantize(s, t, T, UT);
1604
1605         /*
1606          * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, S.M.A.R.T
1607          * and some other commands. We have to ensure that the DMA cycle timing is
1608          * slower/equal than the fastest PIO timing.
1609          */
1610
1611         if (speed > XFER_PIO_4) {
1612                 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
1613                 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
1614         }
1615
1616         /*
1617          * Lenghten active & recovery time so that cycle time is correct.
1618          */
1619
1620         if (t->act8b + t->rec8b < t->cyc8b) {
1621                 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
1622                 t->rec8b = t->cyc8b - t->act8b;
1623         }
1624
1625         if (t->active + t->recover < t->cycle) {
1626                 t->active += (t->cycle - (t->active + t->recover)) / 2;
1627                 t->recover = t->cycle - t->active;
1628         }
1629
1630         return 0;
1631 }
1632
1633 static const struct {
1634         unsigned int shift;
1635         u8 base;
1636 } xfer_mode_classes[] = {
1637         { ATA_SHIFT_UDMA,       XFER_UDMA_0 },
1638         { ATA_SHIFT_MWDMA,      XFER_MW_DMA_0 },
1639         { ATA_SHIFT_PIO,        XFER_PIO_0 },
1640 };
1641
1642 static inline u8 base_from_shift(unsigned int shift)
1643 {
1644         int i;
1645
1646         for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++)
1647                 if (xfer_mode_classes[i].shift == shift)
1648                         return xfer_mode_classes[i].base;
1649
1650         return 0xff;
1651 }
1652
1653 static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
1654 {
1655         int ofs, idx;
1656         u8 base;
1657
1658         if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1659                 return;
1660
1661         if (dev->xfer_shift == ATA_SHIFT_PIO)
1662                 dev->flags |= ATA_DFLAG_PIO;
1663
1664         ata_dev_set_xfermode(ap, dev);
1665
1666         base = base_from_shift(dev->xfer_shift);
1667         ofs = dev->xfer_mode - base;
1668         idx = ofs + dev->xfer_shift;
1669         WARN_ON(idx >= ARRAY_SIZE(xfer_mode_str));
1670
1671         DPRINTK("idx=%d xfer_shift=%u, xfer_mode=0x%x, base=0x%x, offset=%d\n",
1672                 idx, dev->xfer_shift, (int)dev->xfer_mode, (int)base, ofs);
1673
1674         printk(KERN_INFO "ata%u: dev %u configured for %s\n",
1675                 ap->id, dev->devno, xfer_mode_str[idx]);
1676 }
1677
1678 static int ata_host_set_pio(struct ata_port *ap)
1679 {
1680         unsigned int mask;
1681         int x, i;
1682         u8 base, xfer_mode;
1683
1684         mask = ata_get_mode_mask(ap, ATA_SHIFT_PIO);
1685         x = fgb(mask);
1686         if (x < 0) {
1687                 printk(KERN_WARNING "ata%u: no PIO support\n", ap->id);
1688                 return -1;
1689         }
1690
1691         base = base_from_shift(ATA_SHIFT_PIO);
1692         xfer_mode = base + x;
1693
1694         DPRINTK("base 0x%x xfer_mode 0x%x mask 0x%x x %d\n",
1695                 (int)base, (int)xfer_mode, mask, x);
1696
1697         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1698                 struct ata_device *dev = &ap->device[i];
1699                 if (ata_dev_present(dev)) {
1700                         dev->pio_mode = xfer_mode;
1701                         dev->xfer_mode = xfer_mode;
1702                         dev->xfer_shift = ATA_SHIFT_PIO;
1703                         if (ap->ops->set_piomode)
1704                                 ap->ops->set_piomode(ap, dev);
1705                 }
1706         }
1707
1708         return 0;
1709 }
1710
1711 static void ata_host_set_dma(struct ata_port *ap, u8 xfer_mode,
1712                             unsigned int xfer_shift)
1713 {
1714         int i;
1715
1716         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1717                 struct ata_device *dev = &ap->device[i];
1718                 if (ata_dev_present(dev)) {
1719                         dev->dma_mode = xfer_mode;
1720                         dev->xfer_mode = xfer_mode;
1721                         dev->xfer_shift = xfer_shift;
1722                         if (ap->ops->set_dmamode)
1723                                 ap->ops->set_dmamode(ap, dev);
1724                 }
1725         }
1726 }
1727
1728 /**
1729  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
1730  *      @ap: port on which timings will be programmed
1731  *
1732  *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).
1733  *
1734  *      LOCKING:
1735  *      PCI/etc. bus probe sem.
1736  *
1737  */
1738 static void ata_set_mode(struct ata_port *ap)
1739 {
1740         unsigned int xfer_shift;
1741         u8 xfer_mode;
1742         int rc;
1743
1744         /* step 1: always set host PIO timings */
1745         rc = ata_host_set_pio(ap);
1746         if (rc)
1747                 goto err_out;
1748
1749         /* step 2: choose the best data xfer mode */
1750         xfer_mode = xfer_shift = 0;
1751         rc = ata_choose_xfer_mode(ap, &xfer_mode, &xfer_shift);
1752         if (rc)
1753                 goto err_out;
1754
1755         /* step 3: if that xfer mode isn't PIO, set host DMA timings */
1756         if (xfer_shift != ATA_SHIFT_PIO)
1757                 ata_host_set_dma(ap, xfer_mode, xfer_shift);
1758
1759         /* step 4: update devices' xfer mode */
1760         ata_dev_set_mode(ap, &ap->device[0]);
1761         ata_dev_set_mode(ap, &ap->device[1]);
1762
1763         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1764                 return;
1765
1766         if (ap->ops->post_set_mode)
1767                 ap->ops->post_set_mode(ap);
1768
1769         return;
1770
1771 err_out:
1772         ata_port_disable(ap);
1773 }
1774
1775 /**
1776  *      ata_busy_sleep - sleep until BSY clears, or timeout
1777  *      @ap: port containing status register to be polled
1778  *      @tmout_pat: impatience timeout
1779  *      @tmout: overall timeout
1780  *
1781  *      Sleep until ATA Status register bit BSY clears,
1782  *      or a timeout occurs.
1783  *
1784  *      LOCKING: None.
1785  *
1786  */
1787
1788 static unsigned int ata_busy_sleep (struct ata_port *ap,
1789                                     unsigned long tmout_pat,
1790                                     unsigned long tmout)
1791 {
1792         unsigned long timer_start, timeout;
1793         u8 status;
1794
1795         status = ata_busy_wait(ap, ATA_BUSY, 300);
1796         timer_start = jiffies;
1797         timeout = timer_start + tmout_pat;
1798         while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1799                 msleep(50);
1800                 status = ata_busy_wait(ap, ATA_BUSY, 3);
1801         }
1802
1803         if (status & ATA_BUSY)
1804                 printk(KERN_WARNING "ata%u is slow to respond, "
1805                        "please be patient\n", ap->id);
1806
1807         timeout = timer_start + tmout;
1808         while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1809                 msleep(50);
1810                 status = ata_chk_status(ap);
1811         }
1812
1813         if (status & ATA_BUSY) {
1814                 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
1815                        ap->id, tmout / HZ);
1816                 return 1;
1817         }
1818
1819         return 0;
1820 }
1821
1822 static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
1823 {
1824         struct ata_ioports *ioaddr = &ap->ioaddr;
1825         unsigned int dev0 = devmask & (1 << 0);
1826         unsigned int dev1 = devmask & (1 << 1);
1827         unsigned long timeout;
1828
1829         /* if device 0 was found in ata_devchk, wait for its
1830          * BSY bit to clear
1831          */
1832         if (dev0)
1833                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1834
1835         /* if device 1 was found in ata_devchk, wait for
1836          * register access, then wait for BSY to clear
1837          */
1838         timeout = jiffies + ATA_TMOUT_BOOT;
1839         while (dev1) {
1840                 u8 nsect, lbal;
1841
1842                 ap->ops->dev_select(ap, 1);
1843                 if (ap->flags & ATA_FLAG_MMIO) {
1844                         nsect = readb((void __iomem *) ioaddr->nsect_addr);
1845                         lbal = readb((void __iomem *) ioaddr->lbal_addr);
1846                 } else {
1847                         nsect = inb(ioaddr->nsect_addr);
1848                         lbal = inb(ioaddr->lbal_addr);
1849                 }
1850                 if ((nsect == 1) && (lbal == 1))
1851                         break;
1852                 if (time_after(jiffies, timeout)) {
1853                         dev1 = 0;
1854                         break;
1855                 }
1856                 msleep(50);     /* give drive a breather */
1857         }
1858         if (dev1)
1859                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1860
1861         /* is all this really necessary? */
1862         ap->ops->dev_select(ap, 0);
1863         if (dev1)
1864                 ap->ops->dev_select(ap, 1);
1865         if (dev0)
1866                 ap->ops->dev_select(ap, 0);
1867 }
1868
1869 /**
1870  *      ata_bus_edd - Issue EXECUTE DEVICE DIAGNOSTIC command.
1871  *      @ap: Port to reset and probe
1872  *
1873  *      Use the EXECUTE DEVICE DIAGNOSTIC command to reset and
1874  *      probe the bus.  Not often used these days.
1875  *
1876  *      LOCKING:
1877  *      PCI/etc. bus probe sem.
1878  *      Obtains host_set lock.
1879  *
1880  */
1881
1882 static unsigned int ata_bus_edd(struct ata_port *ap)
1883 {
1884         struct ata_taskfile tf;
1885         unsigned long flags;
1886
1887         /* set up execute-device-diag (bus reset) taskfile */
1888         /* also, take interrupts to a known state (disabled) */
1889         DPRINTK("execute-device-diag\n");
1890         ata_tf_init(ap, &tf, 0);
1891         tf.ctl |= ATA_NIEN;
1892         tf.command = ATA_CMD_EDD;
1893         tf.protocol = ATA_PROT_NODATA;
1894
1895         /* do bus reset */
1896         spin_lock_irqsave(&ap->host_set->lock, flags);
1897         ata_tf_to_host(ap, &tf);
1898         spin_unlock_irqrestore(&ap->host_set->lock, flags);
1899
1900         /* spec says at least 2ms.  but who knows with those
1901          * crazy ATAPI devices...
1902          */
1903         msleep(150);
1904
1905         return ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1906 }
1907
1908 static unsigned int ata_bus_softreset(struct ata_port *ap,
1909                                       unsigned int devmask)
1910 {
1911         struct ata_ioports *ioaddr = &ap->ioaddr;
1912
1913         DPRINTK("ata%u: bus reset via SRST\n", ap->id);
1914
1915         /* software reset.  causes dev0 to be selected */
1916         if (ap->flags & ATA_FLAG_MMIO) {
1917                 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1918                 udelay(20);     /* FIXME: flush */
1919                 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
1920                 udelay(20);     /* FIXME: flush */
1921                 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1922         } else {
1923                 outb(ap->ctl, ioaddr->ctl_addr);
1924                 udelay(10);
1925                 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
1926                 udelay(10);
1927                 outb(ap->ctl, ioaddr->ctl_addr);
1928         }
1929
1930         /* spec mandates ">= 2ms" before checking status.
1931          * We wait 150ms, because that was the magic delay used for
1932          * ATAPI devices in Hale Landis's ATADRVR, for the period of time
1933          * between when the ATA command register is written, and then
1934          * status is checked.  Because waiting for "a while" before
1935          * checking status is fine, post SRST, we perform this magic
1936          * delay here as well.
1937          */
1938         msleep(150);
1939
1940         ata_bus_post_reset(ap, devmask);
1941
1942         return 0;
1943 }
1944
1945 /**
1946  *      ata_bus_reset - reset host port and associated ATA channel
1947  *      @ap: port to reset
1948  *
1949  *      This is typically the first time we actually start issuing
1950  *      commands to the ATA channel.  We wait for BSY to clear, then
1951  *      issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
1952  *      result.  Determine what devices, if any, are on the channel
1953  *      by looking at the device 0/1 error register.  Look at the signature
1954  *      stored in each device's taskfile registers, to determine if
1955  *      the device is ATA or ATAPI.
1956  *
1957  *      LOCKING:
1958  *      PCI/etc. bus probe sem.
1959  *      Obtains host_set lock.
1960  *
1961  *      SIDE EFFECTS:
1962  *      Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
1963  */
1964
1965 void ata_bus_reset(struct ata_port *ap)
1966 {
1967         struct ata_ioports *ioaddr = &ap->ioaddr;
1968         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
1969         u8 err;
1970         unsigned int dev0, dev1 = 0, rc = 0, devmask = 0;
1971
1972         DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
1973
1974         /* determine if device 0/1 are present */
1975         if (ap->flags & ATA_FLAG_SATA_RESET)
1976                 dev0 = 1;
1977         else {
1978                 dev0 = ata_devchk(ap, 0);
1979                 if (slave_possible)
1980                         dev1 = ata_devchk(ap, 1);
1981         }
1982
1983         if (dev0)
1984                 devmask |= (1 << 0);
1985         if (dev1)
1986                 devmask |= (1 << 1);
1987
1988         /* select device 0 again */
1989         ap->ops->dev_select(ap, 0);
1990
1991         /* issue bus reset */
1992         if (ap->flags & ATA_FLAG_SRST)
1993                 rc = ata_bus_softreset(ap, devmask);
1994         else if ((ap->flags & ATA_FLAG_SATA_RESET) == 0) {
1995                 /* set up device control */
1996                 if (ap->flags & ATA_FLAG_MMIO)
1997                         writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1998                 else
1999                         outb(ap->ctl, ioaddr->ctl_addr);
2000                 rc = ata_bus_edd(ap);
2001         }
2002
2003         if (rc)
2004                 goto err_out;
2005
2006         /*
2007          * determine by signature whether we have ATA or ATAPI devices
2008          */
2009         err = ata_dev_try_classify(ap, 0);
2010         if ((slave_possible) && (err != 0x81))
2011                 ata_dev_try_classify(ap, 1);
2012
2013         /* re-enable interrupts */
2014         if (ap->ioaddr.ctl_addr)        /* FIXME: hack. create a hook instead */
2015                 ata_irq_on(ap);
2016
2017         /* is double-select really necessary? */
2018         if (ap->device[1].class != ATA_DEV_NONE)
2019                 ap->ops->dev_select(ap, 1);
2020         if (ap->device[0].class != ATA_DEV_NONE)
2021                 ap->ops->dev_select(ap, 0);
2022
2023         /* if no devices were detected, disable this port */
2024         if ((ap->device[0].class == ATA_DEV_NONE) &&
2025             (ap->device[1].class == ATA_DEV_NONE))
2026                 goto err_out;
2027
2028         if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2029                 /* set up device control for ATA_FLAG_SATA_RESET */
2030                 if (ap->flags & ATA_FLAG_MMIO)
2031                         writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2032                 else
2033                         outb(ap->ctl, ioaddr->ctl_addr);
2034         }
2035
2036         DPRINTK("EXIT\n");
2037         return;
2038
2039 err_out:
2040         printk(KERN_ERR "ata%u: disabling port\n", ap->id);
2041         ap->ops->port_disable(ap);
2042
2043         DPRINTK("EXIT\n");
2044 }
2045
2046 static void ata_pr_blacklisted(const struct ata_port *ap,
2047                                const struct ata_device *dev)
2048 {
2049         printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, disabling DMA\n",
2050                 ap->id, dev->devno);
2051 }
2052
2053 static const char * ata_dma_blacklist [] = {
2054         "WDC AC11000H",
2055         "WDC AC22100H",
2056         "WDC AC32500H",
2057         "WDC AC33100H",
2058         "WDC AC31600H",
2059         "WDC AC32100H",
2060         "WDC AC23200L",
2061         "Compaq CRD-8241B",
2062         "CRD-8400B",
2063         "CRD-8480B",
2064         "CRD-8482B",
2065         "CRD-84",
2066         "SanDisk SDP3B",
2067         "SanDisk SDP3B-64",
2068         "SANYO CD-ROM CRD",
2069         "HITACHI CDR-8",
2070         "HITACHI CDR-8335",
2071         "HITACHI CDR-8435",
2072         "Toshiba CD-ROM XM-6202B",
2073         "TOSHIBA CD-ROM XM-1702BC",
2074         "CD-532E-A",
2075         "E-IDE CD-ROM CR-840",
2076         "CD-ROM Drive/F5A",
2077         "WPI CDD-820",
2078         "SAMSUNG CD-ROM SC-148C",
2079         "SAMSUNG CD-ROM SC",
2080         "SanDisk SDP3B-64",
2081         "ATAPI CD-ROM DRIVE 40X MAXIMUM",
2082         "_NEC DV5800A",
2083 };
2084
2085 static int ata_dma_blacklisted(const struct ata_device *dev)
2086 {
2087         unsigned char model_num[40];
2088         char *s;
2089         unsigned int len;
2090         int i;
2091
2092         ata_dev_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
2093                           sizeof(model_num));
2094         s = &model_num[0];
2095         len = strnlen(s, sizeof(model_num));
2096
2097         /* ATAPI specifies that empty space is blank-filled; remove blanks */
2098         while ((len > 0) && (s[len - 1] == ' ')) {
2099                 len--;
2100                 s[len] = 0;
2101         }
2102
2103         for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i++)
2104                 if (!strncmp(ata_dma_blacklist[i], s, len))
2105                         return 1;
2106
2107         return 0;
2108 }
2109
2110 static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift)
2111 {
2112         const struct ata_device *master, *slave;
2113         unsigned int mask;
2114
2115         master = &ap->device[0];
2116         slave = &ap->device[1];
2117
2118         assert (ata_dev_present(master) || ata_dev_present(slave));
2119
2120         if (shift == ATA_SHIFT_UDMA) {
2121                 mask = ap->udma_mask;
2122                 if (ata_dev_present(master)) {
2123                         mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
2124                         if (ata_dma_blacklisted(master)) {
2125                                 mask = 0;
2126                                 ata_pr_blacklisted(ap, master);
2127                         }
2128                 }
2129                 if (ata_dev_present(slave)) {
2130                         mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
2131                         if (ata_dma_blacklisted(slave)) {
2132                                 mask = 0;
2133                                 ata_pr_blacklisted(ap, slave);
2134                         }
2135                 }
2136         }
2137         else if (shift == ATA_SHIFT_MWDMA) {
2138                 mask = ap->mwdma_mask;
2139                 if (ata_dev_present(master)) {
2140                         mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
2141                         if (ata_dma_blacklisted(master)) {
2142                                 mask = 0;
2143                                 ata_pr_blacklisted(ap, master);
2144                         }
2145                 }
2146                 if (ata_dev_present(slave)) {
2147                         mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
2148                         if (ata_dma_blacklisted(slave)) {
2149                                 mask = 0;
2150                                 ata_pr_blacklisted(ap, slave);
2151                         }
2152                 }
2153         }
2154         else if (shift == ATA_SHIFT_PIO) {
2155                 mask = ap->pio_mask;
2156                 if (ata_dev_present(master)) {
2157                         /* spec doesn't return explicit support for
2158                          * PIO0-2, so we fake it
2159                          */
2160                         u16 tmp_mode = master->id[ATA_ID_PIO_MODES] & 0x03;
2161                         tmp_mode <<= 3;
2162                         tmp_mode |= 0x7;
2163                         mask &= tmp_mode;
2164                 }
2165                 if (ata_dev_present(slave)) {
2166                         /* spec doesn't return explicit support for
2167                          * PIO0-2, so we fake it
2168                          */
2169                         u16 tmp_mode = slave->id[ATA_ID_PIO_MODES] & 0x03;
2170                         tmp_mode <<= 3;
2171                         tmp_mode |= 0x7;
2172                         mask &= tmp_mode;
2173                 }
2174         }
2175         else {
2176                 mask = 0xffffffff; /* shut up compiler warning */
2177                 BUG();
2178         }
2179
2180         return mask;
2181 }
2182
2183 /* find greatest bit */
2184 static int fgb(u32 bitmap)
2185 {
2186         unsigned int i;
2187         int x = -1;
2188
2189         for (i = 0; i < 32; i++)
2190                 if (bitmap & (1 << i))
2191                         x = i;
2192
2193         return x;
2194 }
2195
2196 /**
2197  *      ata_choose_xfer_mode - attempt to find best transfer mode
2198  *      @ap: Port for which an xfer mode will be selected
2199  *      @xfer_mode_out: (output) SET FEATURES - XFER MODE code
2200  *      @xfer_shift_out: (output) bit shift that selects this mode
2201  *
2202  *      Based on host and device capabilities, determine the
2203  *      maximum transfer mode that is amenable to all.
2204  *
2205  *      LOCKING:
2206  *      PCI/etc. bus probe sem.
2207  *
2208  *      RETURNS:
2209  *      Zero on success, negative on error.
2210  */
2211
2212 static int ata_choose_xfer_mode(const struct ata_port *ap,
2213                                 u8 *xfer_mode_out,
2214                                 unsigned int *xfer_shift_out)
2215 {
2216         unsigned int mask, shift;
2217         int x, i;
2218
2219         for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++) {
2220                 shift = xfer_mode_classes[i].shift;
2221                 mask = ata_get_mode_mask(ap, shift);
2222
2223                 x = fgb(mask);
2224                 if (x >= 0) {
2225                         *xfer_mode_out = xfer_mode_classes[i].base + x;
2226                         *xfer_shift_out = shift;
2227                         return 0;
2228                 }
2229         }
2230
2231         return -1;
2232 }
2233
2234 /**
2235  *      ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
2236  *      @ap: Port associated with device @dev
2237  *      @dev: Device to which command will be sent
2238  *
2239  *      Issue SET FEATURES - XFER MODE command to device @dev
2240  *      on port @ap.
2241  *
2242  *      LOCKING:
2243  *      PCI/etc. bus probe sem.
2244  */
2245
2246 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
2247 {
2248         DECLARE_COMPLETION(wait);
2249         struct ata_queued_cmd *qc;
2250         int rc;
2251         unsigned long flags;
2252
2253         /* set up set-features taskfile */
2254         DPRINTK("set features - xfer mode\n");
2255
2256         qc = ata_qc_new_init(ap, dev);
2257         BUG_ON(qc == NULL);
2258
2259         qc->tf.command = ATA_CMD_SET_FEATURES;
2260         qc->tf.feature = SETFEATURES_XFER;
2261         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2262         qc->tf.protocol = ATA_PROT_NODATA;
2263         qc->tf.nsect = dev->xfer_mode;
2264
2265         qc->waiting = &wait;
2266         qc->complete_fn = ata_qc_complete_noop;
2267
2268         spin_lock_irqsave(&ap->host_set->lock, flags);
2269         rc = ata_qc_issue(qc);
2270         spin_unlock_irqrestore(&ap->host_set->lock, flags);
2271
2272         if (rc)
2273                 ata_port_disable(ap);
2274         else
2275                 wait_for_completion(&wait);
2276
2277         DPRINTK("EXIT\n");
2278 }
2279
2280 /**
2281  *      ata_dev_reread_id - Reread the device identify device info
2282  *      @ap: port where the device is
2283  *      @dev: device to reread the identify device info
2284  *
2285  *      LOCKING:
2286  */
2287
2288 static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev)
2289 {
2290         DECLARE_COMPLETION(wait);
2291         struct ata_queued_cmd *qc;
2292         unsigned long flags;
2293         int rc;
2294
2295         qc = ata_qc_new_init(ap, dev);
2296         BUG_ON(qc == NULL);
2297
2298         ata_sg_init_one(qc, dev->id, sizeof(dev->id));
2299         qc->dma_dir = DMA_FROM_DEVICE;
2300
2301         if (dev->class == ATA_DEV_ATA) {
2302                 qc->tf.command = ATA_CMD_ID_ATA;
2303                 DPRINTK("do ATA identify\n");
2304         } else {
2305                 qc->tf.command = ATA_CMD_ID_ATAPI;
2306                 DPRINTK("do ATAPI identify\n");
2307         }
2308
2309         qc->tf.flags |= ATA_TFLAG_DEVICE;
2310         qc->tf.protocol = ATA_PROT_PIO;
2311         qc->nsect = 1;
2312
2313         qc->waiting = &wait;
2314         qc->complete_fn = ata_qc_complete_noop;
2315
2316         spin_lock_irqsave(&ap->host_set->lock, flags);
2317         rc = ata_qc_issue(qc);
2318         spin_unlock_irqrestore(&ap->host_set->lock, flags);
2319
2320         if (rc)
2321                 goto err_out;
2322
2323         wait_for_completion(&wait);
2324
2325         swap_buf_le16(dev->id, ATA_ID_WORDS);
2326
2327         ata_dump_id(dev);
2328
2329         DPRINTK("EXIT\n");
2330
2331         return;
2332 err_out:
2333         ata_port_disable(ap);
2334 }
2335
2336 /**
2337  *      ata_dev_init_params - Issue INIT DEV PARAMS command
2338  *      @ap: Port associated with device @dev
2339  *      @dev: Device to which command will be sent
2340  *
2341  *      LOCKING:
2342  */
2343
2344 static void ata_dev_init_params(struct ata_port *ap, struct ata_device *dev)
2345 {
2346         DECLARE_COMPLETION(wait);
2347         struct ata_queued_cmd *qc;
2348         int rc;
2349         unsigned long flags;
2350         u16 sectors = dev->id[6];
2351         u16 heads   = dev->id[3];
2352
2353         /* Number of sectors per track 1-255. Number of heads 1-16 */
2354         if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
2355                 return;
2356
2357         /* set up init dev params taskfile */
2358         DPRINTK("init dev params \n");
2359
2360         qc = ata_qc_new_init(ap, dev);
2361         BUG_ON(qc == NULL);
2362
2363         qc->tf.command = ATA_CMD_INIT_DEV_PARAMS;
2364         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2365         qc->tf.protocol = ATA_PROT_NODATA;
2366         qc->tf.nsect = sectors;
2367         qc->tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
2368
2369         qc->waiting = &wait;
2370         qc->complete_fn = ata_qc_complete_noop;
2371
2372         spin_lock_irqsave(&ap->host_set->lock, flags);
2373         rc = ata_qc_issue(qc);
2374         spin_unlock_irqrestore(&ap->host_set->lock, flags);
2375
2376         if (rc)
2377                 ata_port_disable(ap);
2378         else
2379                 wait_for_completion(&wait);
2380
2381         DPRINTK("EXIT\n");
2382 }
2383
2384 /**
2385  *      ata_sg_clean - Unmap DMA memory associated with command
2386  *      @qc: Command containing DMA memory to be released
2387  *
2388  *      Unmap all mapped DMA memory associated with this command.
2389  *
2390  *      LOCKING:
2391  *      spin_lock_irqsave(host_set lock)
2392  */
2393
2394 static void ata_sg_clean(struct ata_queued_cmd *qc)
2395 {
2396         struct ata_port *ap = qc->ap;
2397         struct scatterlist *sg = qc->sg;
2398         int dir = qc->dma_dir;
2399
2400         assert(qc->flags & ATA_QCFLAG_DMAMAP);
2401         assert(sg != NULL);
2402
2403         if (qc->flags & ATA_QCFLAG_SINGLE)
2404                 assert(qc->n_elem == 1);
2405
2406         DPRINTK("unmapping %u sg elements\n", qc->n_elem);
2407
2408         if (qc->flags & ATA_QCFLAG_SG)
2409                 dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2410         else
2411                 dma_unmap_single(ap->host_set->dev, sg_dma_address(&sg[0]),
2412                                  sg_dma_len(&sg[0]), dir);
2413
2414         qc->flags &= ~ATA_QCFLAG_DMAMAP;
2415         qc->sg = NULL;
2416 }
2417
2418 /**
2419  *      ata_fill_sg - Fill PCI IDE PRD table
2420  *      @qc: Metadata associated with taskfile to be transferred
2421  *
2422  *      Fill PCI IDE PRD (scatter-gather) table with segments
2423  *      associated with the current disk command.
2424  *
2425  *      LOCKING:
2426  *      spin_lock_irqsave(host_set lock)
2427  *
2428  */
2429 static void ata_fill_sg(struct ata_queued_cmd *qc)
2430 {
2431         struct scatterlist *sg = qc->sg;
2432         struct ata_port *ap = qc->ap;
2433         unsigned int idx, nelem;
2434
2435         assert(sg != NULL);
2436         assert(qc->n_elem > 0);
2437
2438         idx = 0;
2439         for (nelem = qc->n_elem; nelem; nelem--,sg++) {
2440                 u32 addr, offset;
2441                 u32 sg_len, len;
2442
2443                 /* determine if physical DMA addr spans 64K boundary.
2444                  * Note h/w doesn't support 64-bit, so we unconditionally
2445                  * truncate dma_addr_t to u32.
2446                  */
2447                 addr = (u32) sg_dma_address(sg);
2448                 sg_len = sg_dma_len(sg);
2449
2450                 while (sg_len) {
2451                         offset = addr & 0xffff;
2452                         len = sg_len;
2453                         if ((offset + sg_len) > 0x10000)
2454                                 len = 0x10000 - offset;
2455
2456                         ap->prd[idx].addr = cpu_to_le32(addr);
2457                         ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
2458                         VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
2459
2460                         idx++;
2461                         sg_len -= len;
2462                         addr += len;
2463                 }
2464         }
2465
2466         if (idx)
2467                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2468 }
2469 /**
2470  *      ata_check_atapi_dma - Check whether ATAPI DMA can be supported
2471  *      @qc: Metadata associated with taskfile to check
2472  *
2473  *      Allow low-level driver to filter ATA PACKET commands, returning
2474  *      a status indicating whether or not it is OK to use DMA for the
2475  *      supplied PACKET command.
2476  *
2477  *      LOCKING:
2478  *      spin_lock_irqsave(host_set lock)
2479  *
2480  *      RETURNS: 0 when ATAPI DMA can be used
2481  *               nonzero otherwise
2482  */
2483 int ata_check_atapi_dma(struct ata_queued_cmd *qc)
2484 {
2485         struct ata_port *ap = qc->ap;
2486         int rc = 0; /* Assume ATAPI DMA is OK by default */
2487
2488         if (ap->ops->check_atapi_dma)
2489                 rc = ap->ops->check_atapi_dma(qc);
2490
2491         return rc;
2492 }
2493 /**
2494  *      ata_qc_prep - Prepare taskfile for submission
2495  *      @qc: Metadata associated with taskfile to be prepared
2496  *
2497  *      Prepare ATA taskfile for submission.
2498  *
2499  *      LOCKING:
2500  *      spin_lock_irqsave(host_set lock)
2501  */
2502 void ata_qc_prep(struct ata_queued_cmd *qc)
2503 {
2504         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2505                 return;
2506
2507         ata_fill_sg(qc);
2508 }
2509
2510 /**
2511  *      ata_sg_init_one - Associate command with memory buffer
2512  *      @qc: Command to be associated
2513  *      @buf: Memory buffer
2514  *      @buflen: Length of memory buffer, in bytes.
2515  *
2516  *      Initialize the data-related elements of queued_cmd @qc
2517  *      to point to a single memory buffer, @buf of byte length @buflen.
2518  *
2519  *      LOCKING:
2520  *      spin_lock_irqsave(host_set lock)
2521  */
2522
2523 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
2524 {
2525         qc->flags |= ATA_QCFLAG_SINGLE;
2526
2527         qc->sg = &qc->sgent;
2528         qc->n_elem = 1;
2529         qc->buf_virt = buf;
2530         sg_init_one(qc->sg, buf, buflen);
2531 }
2532
2533 /**
2534  *      ata_sg_init - Associate command with scatter-gather table.
2535  *      @qc: Command to be associated
2536  *      @sg: Scatter-gather table.
2537  *      @n_elem: Number of elements in s/g table.
2538  *
2539  *      Initialize the data-related elements of queued_cmd @qc
2540  *      to point to a scatter-gather table @sg, containing @n_elem
2541  *      elements.
2542  *
2543  *      LOCKING:
2544  *      spin_lock_irqsave(host_set lock)
2545  */
2546
2547 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
2548                  unsigned int n_elem)
2549 {
2550         qc->flags |= ATA_QCFLAG_SG;
2551         qc->sg = sg;
2552         qc->n_elem = n_elem;
2553 }
2554
2555 /**
2556  *      ata_sg_setup_one - DMA-map the memory buffer associated with a command.
2557  *      @qc: Command with memory buffer to be mapped.
2558  *
2559  *      DMA-map the memory buffer associated with queued_cmd @qc.
2560  *
2561  *      LOCKING:
2562  *      spin_lock_irqsave(host_set lock)
2563  *
2564  *      RETURNS:
2565  *      Zero on success, negative on error.
2566  */
2567
2568 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
2569 {
2570         struct ata_port *ap = qc->ap;
2571         int dir = qc->dma_dir;
2572         struct scatterlist *sg = qc->sg;
2573         dma_addr_t dma_address;
2574
2575         dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
2576                                      sg->length, dir);
2577         if (dma_mapping_error(dma_address))
2578                 return -1;
2579
2580         sg_dma_address(sg) = dma_address;
2581         sg_dma_len(sg) = sg->length;
2582
2583         DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
2584                 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2585
2586         return 0;
2587 }
2588
2589 /**
2590  *      ata_sg_setup - DMA-map the scatter-gather table associated with a command.
2591  *      @qc: Command with scatter-gather table to be mapped.
2592  *
2593  *      DMA-map the scatter-gather table associated with queued_cmd @qc.
2594  *
2595  *      LOCKING:
2596  *      spin_lock_irqsave(host_set lock)
2597  *
2598  *      RETURNS:
2599  *      Zero on success, negative on error.
2600  *
2601  */
2602
2603 static int ata_sg_setup(struct ata_queued_cmd *qc)
2604 {
2605         struct ata_port *ap = qc->ap;
2606         struct scatterlist *sg = qc->sg;
2607         int n_elem, dir;
2608
2609         VPRINTK("ENTER, ata%u\n", ap->id);
2610         assert(qc->flags & ATA_QCFLAG_SG);
2611
2612         dir = qc->dma_dir;
2613         n_elem = dma_map_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2614         if (n_elem < 1)
2615                 return -1;
2616
2617         DPRINTK("%d sg elements mapped\n", n_elem);
2618
2619         qc->n_elem = n_elem;
2620
2621         return 0;
2622 }
2623
2624 /**
2625  *      ata_poll_qc_complete - turn irq back on and finish qc
2626  *      @qc: Command to complete
2627  *      @drv_stat: ATA status register content
2628  *
2629  *      LOCKING:
2630  *      None.  (grabs host lock)
2631  */
2632
2633 void ata_poll_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask)
2634 {
2635         struct ata_port *ap = qc->ap;
2636         unsigned long flags;
2637
2638         spin_lock_irqsave(&ap->host_set->lock, flags);
2639         ata_irq_on(ap);
2640         ata_qc_complete(qc, err_mask);
2641         spin_unlock_irqrestore(&ap->host_set->lock, flags);
2642 }
2643
2644 /**
2645  *      ata_pio_poll -
2646  *      @ap: the target ata_port
2647  *
2648  *      LOCKING:
2649  *      None.  (executing in kernel thread context)
2650  *
2651  *      RETURNS:
2652  *      timeout value to use
2653  */
2654
2655 static unsigned long ata_pio_poll(struct ata_port *ap)
2656 {
2657         u8 status;
2658         unsigned int poll_state = HSM_ST_UNKNOWN;
2659         unsigned int reg_state = HSM_ST_UNKNOWN;
2660         const unsigned int tmout_state = HSM_ST_TMOUT;
2661
2662         switch (ap->hsm_task_state) {
2663         case HSM_ST:
2664         case HSM_ST_POLL:
2665                 poll_state = HSM_ST_POLL;
2666                 reg_state = HSM_ST;
2667                 break;
2668         case HSM_ST_LAST:
2669         case HSM_ST_LAST_POLL:
2670                 poll_state = HSM_ST_LAST_POLL;
2671                 reg_state = HSM_ST_LAST;
2672                 break;
2673         default:
2674                 BUG();
2675                 break;
2676         }
2677
2678         status = ata_chk_status(ap);
2679         if (status & ATA_BUSY) {
2680                 if (time_after(jiffies, ap->pio_task_timeout)) {
2681                         ap->hsm_task_state = tmout_state;
2682                         return 0;
2683                 }
2684                 ap->hsm_task_state = poll_state;
2685                 return ATA_SHORT_PAUSE;
2686         }
2687
2688         ap->hsm_task_state = reg_state;
2689         return 0;
2690 }
2691
2692 /**
2693  *      ata_pio_complete - check if drive is busy or idle
2694  *      @ap: the target ata_port
2695  *
2696  *      LOCKING:
2697  *      None.  (executing in kernel thread context)
2698  *
2699  *      RETURNS:
2700  *      Non-zero if qc completed, zero otherwise.
2701  */
2702
2703 static int ata_pio_complete (struct ata_port *ap)
2704 {
2705         struct ata_queued_cmd *qc;
2706         u8 drv_stat;
2707
2708         /*
2709          * This is purely heuristic.  This is a fast path.  Sometimes when
2710          * we enter, BSY will be cleared in a chk-status or two.  If not,
2711          * the drive is probably seeking or something.  Snooze for a couple
2712          * msecs, then chk-status again.  If still busy, fall back to
2713          * HSM_ST_POLL state.
2714          */
2715         drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2716         if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2717                 msleep(2);
2718                 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2719                 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2720                         ap->hsm_task_state = HSM_ST_LAST_POLL;
2721                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2722                         return 0;
2723                 }
2724         }
2725
2726         drv_stat = ata_wait_idle(ap);
2727         if (!ata_ok(drv_stat)) {
2728                 ap->hsm_task_state = HSM_ST_ERR;
2729                 return 0;
2730         }
2731
2732         qc = ata_qc_from_tag(ap, ap->active_tag);
2733         assert(qc != NULL);
2734
2735         ap->hsm_task_state = HSM_ST_IDLE;
2736
2737         ata_poll_qc_complete(qc, 0);
2738
2739         /* another command may start at this point */
2740
2741         return 1;
2742 }
2743
2744
2745 /**
2746  *      swap_buf_le16 - swap halves of 16-words in place
2747  *      @buf:  Buffer to swap
2748  *      @buf_words:  Number of 16-bit words in buffer.
2749  *
2750  *      Swap halves of 16-bit words if needed to convert from
2751  *      little-endian byte order to native cpu byte order, or
2752  *      vice-versa.
2753  *
2754  *      LOCKING:
2755  *      Inherited from caller.
2756  */
2757 void swap_buf_le16(u16 *buf, unsigned int buf_words)
2758 {
2759 #ifdef __BIG_ENDIAN
2760         unsigned int i;
2761
2762         for (i = 0; i < buf_words; i++)
2763                 buf[i] = le16_to_cpu(buf[i]);
2764 #endif /* __BIG_ENDIAN */
2765 }
2766
2767 /**
2768  *      ata_mmio_data_xfer - Transfer data by MMIO
2769  *      @ap: port to read/write
2770  *      @buf: data buffer
2771  *      @buflen: buffer length
2772  *      @write_data: read/write
2773  *
2774  *      Transfer data from/to the device data register by MMIO.
2775  *
2776  *      LOCKING:
2777  *      Inherited from caller.
2778  */
2779
2780 static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
2781                                unsigned int buflen, int write_data)
2782 {
2783         unsigned int i;
2784         unsigned int words = buflen >> 1;
2785         u16 *buf16 = (u16 *) buf;
2786         void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
2787
2788         /* Transfer multiple of 2 bytes */
2789         if (write_data) {
2790                 for (i = 0; i < words; i++)
2791                         writew(le16_to_cpu(buf16[i]), mmio);
2792         } else {
2793                 for (i = 0; i < words; i++)
2794                         buf16[i] = cpu_to_le16(readw(mmio));
2795         }
2796
2797         /* Transfer trailing 1 byte, if any. */
2798         if (unlikely(buflen & 0x01)) {
2799                 u16 align_buf[1] = { 0 };
2800                 unsigned char *trailing_buf = buf + buflen - 1;
2801
2802                 if (write_data) {
2803                         memcpy(align_buf, trailing_buf, 1);
2804                         writew(le16_to_cpu(align_buf[0]), mmio);
2805                 } else {
2806                         align_buf[0] = cpu_to_le16(readw(mmio));
2807                         memcpy(trailing_buf, align_buf, 1);
2808                 }
2809         }
2810 }
2811
2812 /**
2813  *      ata_pio_data_xfer - Transfer data by PIO
2814  *      @ap: port to read/write
2815  *      @buf: data buffer
2816  *      @buflen: buffer length
2817  *      @write_data: read/write
2818  *
2819  *      Transfer data from/to the device data register by PIO.
2820  *
2821  *      LOCKING:
2822  *      Inherited from caller.
2823  */
2824
2825 static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
2826                               unsigned int buflen, int write_data)
2827 {
2828         unsigned int words = buflen >> 1;
2829
2830         /* Transfer multiple of 2 bytes */
2831         if (write_data)
2832                 outsw(ap->ioaddr.data_addr, buf, words);
2833         else
2834                 insw(ap->ioaddr.data_addr, buf, words);
2835
2836         /* Transfer trailing 1 byte, if any. */
2837         if (unlikely(buflen & 0x01)) {
2838                 u16 align_buf[1] = { 0 };
2839                 unsigned char *trailing_buf = buf + buflen - 1;
2840
2841                 if (write_data) {
2842                         memcpy(align_buf, trailing_buf, 1);
2843                         outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
2844                 } else {
2845                         align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
2846                         memcpy(trailing_buf, align_buf, 1);
2847                 }
2848         }
2849 }
2850
2851 /**
2852  *      ata_data_xfer - Transfer data from/to the data register.
2853  *      @ap: port to read/write
2854  *      @buf: data buffer
2855  *      @buflen: buffer length
2856  *      @do_write: read/write
2857  *
2858  *      Transfer data from/to the device data register.
2859  *
2860  *      LOCKING:
2861  *      Inherited from caller.
2862  */
2863
2864 static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
2865                           unsigned int buflen, int do_write)
2866 {
2867         if (ap->flags & ATA_FLAG_MMIO)
2868                 ata_mmio_data_xfer(ap, buf, buflen, do_write);
2869         else
2870                 ata_pio_data_xfer(ap, buf, buflen, do_write);
2871 }
2872
2873 /**
2874  *      ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
2875  *      @qc: Command on going
2876  *
2877  *      Transfer ATA_SECT_SIZE of data from/to the ATA device.
2878  *
2879  *      LOCKING:
2880  *      Inherited from caller.
2881  */
2882
2883 static void ata_pio_sector(struct ata_queued_cmd *qc)
2884 {
2885         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2886         struct scatterlist *sg = qc->sg;
2887         struct ata_port *ap = qc->ap;
2888         struct page *page;
2889         unsigned int offset;
2890         unsigned char *buf;
2891
2892         if (qc->cursect == (qc->nsect - 1))
2893                 ap->hsm_task_state = HSM_ST_LAST;
2894
2895         page = sg[qc->cursg].page;
2896         offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
2897
2898         /* get the current page and offset */
2899         page = nth_page(page, (offset >> PAGE_SHIFT));
2900         offset %= PAGE_SIZE;
2901
2902         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2903
2904         if (PageHighMem(page)) {
2905                 unsigned long flags;
2906
2907                 local_irq_save(flags);
2908                 buf = kmap_atomic(page, KM_IRQ0);
2909
2910                 /* do the actual data transfer */
2911                 ata_data_xfer(ap, buf + offset, ATA_SECT_SIZE, do_write);
2912
2913                 kunmap_atomic(buf, KM_IRQ0);
2914                 local_irq_restore(flags);
2915         } else {
2916                 buf = page_address(page);
2917                 ata_data_xfer(ap, buf + offset, ATA_SECT_SIZE, do_write);
2918         }
2919
2920         qc->cursect++;
2921         qc->cursg_ofs++;
2922
2923         if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
2924                 qc->cursg++;
2925                 qc->cursg_ofs = 0;
2926         }
2927 }
2928
2929 /**
2930  *      atapi_send_cdb - Write CDB bytes to hardware
2931  *      @ap: Port to which ATAPI device is attached.
2932  *      @qc: Taskfile currently active
2933  *
2934  *      When device has indicated its readiness to accept
2935  *      a CDB, this function is called.  Send the CDB.
2936  *
2937  *      LOCKING:
2938  *      caller.
2939  */
2940
2941 static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
2942 {
2943         /* send SCSI cdb */
2944         DPRINTK("send cdb\n");
2945         assert(ap->cdb_len >= 12);
2946
2947         ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
2948         ata_altstatus(ap); /* flush */
2949
2950         switch (qc->tf.protocol) {
2951         case ATA_PROT_ATAPI:
2952                 ap->hsm_task_state = HSM_ST;
2953                 break;
2954         case ATA_PROT_ATAPI_NODATA:
2955                 ap->hsm_task_state = HSM_ST_LAST;
2956                 break;
2957         case ATA_PROT_ATAPI_DMA:
2958                 ap->hsm_task_state = HSM_ST_LAST;
2959                 /* initiate bmdma */
2960                 ap->ops->bmdma_start(qc);
2961                 break;
2962         }
2963 }
2964
2965 /**
2966  *      ata_dataout_task - Write first data block to hardware
2967  *      @_data: Port to which ATA/ATAPI device is attached.
2968  *
2969  *      When device has indicated its readiness to accept
2970  *      the data, this function sends out the CDB or 
2971  *      the first data block by PIO.
2972  *      After this, 
2973  *        - If polling, ata_pio_task() handles the rest.
2974  *        - Otherwise, interrupt handler takes over.
2975  *
2976  *      LOCKING:
2977  *      Kernel thread context (may sleep)
2978  */
2979
2980 static void ata_dataout_task(void *_data)
2981 {
2982         struct ata_port *ap = _data;
2983         struct ata_queued_cmd *qc;
2984         u8 status;
2985         unsigned long flags;
2986
2987         qc = ata_qc_from_tag(ap, ap->active_tag);
2988         assert(qc != NULL);
2989         assert(qc->flags & ATA_QCFLAG_ACTIVE);
2990
2991         /* sleep-wait for BSY to clear */
2992         DPRINTK("busy wait\n");
2993         if (ata_busy_sleep(ap, ATA_TMOUT_DATAOUT_QUICK, ATA_TMOUT_DATAOUT))
2994                 goto err_out;
2995
2996         /* make sure DRQ is set */
2997         status = ata_chk_status(ap);
2998         if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
2999                 goto err_out;
3000
3001         /* Send the CDB (atapi) or the first data block (ata pio out).
3002          * During the state transition, interrupt handler shouldn't
3003          * be invoked before the data transfer is complete and
3004          * hsm_task_state is changed. Hence, the following locking.
3005          */
3006         spin_lock_irqsave(&ap->host_set->lock, flags);
3007
3008         if (qc->tf.protocol == ATA_PROT_PIO) {
3009                 /* PIO data out protocol.
3010                  * send first data block.
3011                  */
3012
3013                 /* ata_pio_sector() might change the state to HSM_ST_LAST.
3014                  * so, the state is changed here before ata_pio_sector().
3015                  */
3016                 ap->hsm_task_state = HSM_ST;
3017                 ata_pio_sector(qc);
3018                 ata_altstatus(ap); /* flush */
3019         } else
3020                 /* send CDB */
3021                 atapi_send_cdb(ap, qc);
3022
3023         /* if polling, ata_pio_task() handles the rest.
3024          * otherwise, interrupt handler takes over from here.
3025          */
3026         if (qc->tf.flags & ATA_TFLAG_POLLING)
3027                 queue_work(ata_wq, &ap->pio_task);
3028
3029         spin_unlock_irqrestore(&ap->host_set->lock, flags);
3030
3031         return;
3032
3033 err_out:
3034         ata_pio_error(ap);
3035 }
3036
3037 /**
3038  *      __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3039  *      @qc: Command on going
3040  *      @bytes: number of bytes
3041  *
3042  *      Transfer Transfer data from/to the ATAPI device.
3043  *
3044  *      LOCKING:
3045  *      Inherited from caller.
3046  *
3047  */
3048
3049 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3050 {
3051         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3052         struct scatterlist *sg = qc->sg;
3053         struct ata_port *ap = qc->ap;
3054         struct page *page;
3055         unsigned char *buf;
3056         unsigned int offset, count;
3057
3058         if (qc->curbytes + bytes >= qc->nbytes)
3059                 ap->hsm_task_state = HSM_ST_LAST;
3060
3061 next_sg:
3062         if (unlikely(qc->cursg >= qc->n_elem)) {
3063                 /*
3064                  * The end of qc->sg is reached and the device expects
3065                  * more data to transfer. In order not to overrun qc->sg
3066                  * and fulfill length specified in the byte count register,
3067                  *    - for read case, discard trailing data from the device
3068                  *    - for write case, padding zero data to the device
3069                  */
3070                 u16 pad_buf[1] = { 0 };
3071                 unsigned int words = bytes >> 1;
3072                 unsigned int i;
3073
3074                 if (words) /* warning if bytes > 1 */
3075                         printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
3076                                ap->id, bytes);
3077
3078                 for (i = 0; i < words; i++)
3079                         ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
3080
3081                 ap->hsm_task_state = HSM_ST_LAST;
3082                 return;
3083         }
3084
3085         sg = &qc->sg[qc->cursg];
3086
3087         page = sg->page;
3088         offset = sg->offset + qc->cursg_ofs;
3089
3090         /* get the current page and offset */
3091         page = nth_page(page, (offset >> PAGE_SHIFT));
3092         offset %= PAGE_SIZE;
3093
3094         /* don't overrun current sg */
3095         count = min(sg->length - qc->cursg_ofs, bytes);
3096
3097         /* don't cross page boundaries */
3098         count = min(count, (unsigned int)PAGE_SIZE - offset);
3099
3100         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3101
3102         if (PageHighMem(page)) {
3103                 unsigned long flags;
3104
3105                 local_irq_save(flags);
3106                 buf = kmap_atomic(page, KM_IRQ0);
3107
3108                 /* do the actual data transfer */
3109                 ata_data_xfer(ap, buf + offset, count, do_write);
3110
3111                 kunmap_atomic(buf, KM_IRQ0);
3112                 local_irq_restore(flags);
3113         } else {
3114                 buf = page_address(page);
3115                 ata_data_xfer(ap, buf + offset, count, do_write);
3116         }
3117
3118         bytes -= count;
3119         qc->curbytes += count;
3120         qc->cursg_ofs += count;
3121
3122         if (qc->cursg_ofs == sg->length) {
3123                 qc->cursg++;
3124                 qc->cursg_ofs = 0;
3125         }
3126
3127         if (bytes)
3128                 goto next_sg;
3129 }
3130
3131 /**
3132  *      atapi_pio_bytes - Transfer data from/to the ATAPI device.
3133  *      @qc: Command on going
3134  *
3135  *      Transfer Transfer data from/to the ATAPI device.
3136  *
3137  *      LOCKING:
3138  *      Inherited from caller.
3139  */
3140
3141 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3142 {
3143         struct ata_port *ap = qc->ap;
3144         struct ata_device *dev = qc->dev;
3145         unsigned int ireason, bc_lo, bc_hi, bytes;
3146         int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3147
3148         ap->ops->tf_read(ap, &qc->tf);
3149         ireason = qc->tf.nsect;
3150         bc_lo = qc->tf.lbam;
3151         bc_hi = qc->tf.lbah;
3152         bytes = (bc_hi << 8) | bc_lo;
3153
3154         /* shall be cleared to zero, indicating xfer of data */
3155         if (ireason & (1 << 0))
3156                 goto err_out;
3157
3158         /* make sure transfer direction matches expected */
3159         i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3160         if (do_write != i_write)
3161                 goto err_out;
3162
3163         VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes);
3164
3165         __atapi_pio_bytes(qc, bytes);
3166
3167         return;
3168
3169 err_out:
3170         printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
3171               ap->id, dev->devno);
3172         ap->hsm_task_state = HSM_ST_ERR;
3173 }
3174
3175 /**
3176  *      ata_pio_block - start PIO on a block
3177  *      @ap: the target ata_port
3178  *
3179  *      LOCKING:
3180  *      None.  (executing in kernel thread context)
3181  */
3182
3183 static void ata_pio_block(struct ata_port *ap)
3184 {
3185         struct ata_queued_cmd *qc;
3186         u8 status;
3187
3188         /*
3189          * This is purely heuristic.  This is a fast path.
3190          * Sometimes when we enter, BSY will be cleared in
3191          * a chk-status or two.  If not, the drive is probably seeking
3192          * or something.  Snooze for a couple msecs, then
3193          * chk-status again.  If still busy, fall back to
3194          * HSM_ST_POLL state.
3195          */
3196         status = ata_busy_wait(ap, ATA_BUSY, 5);
3197         if (status & ATA_BUSY) {
3198                 msleep(2);
3199                 status = ata_busy_wait(ap, ATA_BUSY, 10);
3200                 if (status & ATA_BUSY) {
3201                         ap->hsm_task_state = HSM_ST_POLL;
3202                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
3203                         return;
3204                 }
3205         }
3206
3207         qc = ata_qc_from_tag(ap, ap->active_tag);
3208         assert(qc != NULL);
3209
3210         if (is_atapi_taskfile(&qc->tf)) {
3211                 /* no more data to transfer or unsupported ATAPI command */
3212                 if ((status & ATA_DRQ) == 0) {
3213                         ap->hsm_task_state = HSM_ST_LAST;
3214                         return;
3215                 }
3216
3217                 atapi_pio_bytes(qc);
3218         } else {
3219                 /* handle BSY=0, DRQ=0 as error */
3220                 if ((status & ATA_DRQ) == 0) {
3221                         ap->hsm_task_state = HSM_ST_ERR;
3222                         return;
3223                 }
3224
3225                 ata_pio_sector(qc);
3226         }
3227 }
3228
3229 static void ata_pio_error(struct ata_port *ap)
3230 {
3231         struct ata_queued_cmd *qc;
3232
3233         printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
3234
3235         qc = ata_qc_from_tag(ap, ap->active_tag);
3236         assert(qc != NULL);
3237
3238         ap->hsm_task_state = HSM_ST_IDLE;
3239
3240         ata_poll_qc_complete(qc, AC_ERR_ATA_BUS);
3241 }
3242
3243 static void ata_pio_task(void *_data)
3244 {
3245         struct ata_port *ap = _data;
3246         unsigned long timeout;
3247         int qc_completed;
3248
3249 fsm_start:
3250         timeout = 0;
3251         qc_completed = 0;
3252
3253         switch (ap->hsm_task_state) {
3254         case HSM_ST_IDLE:
3255                 return;
3256
3257         case HSM_ST:
3258                 ata_pio_block(ap);
3259                 break;
3260
3261         case HSM_ST_LAST:
3262                 qc_completed = ata_pio_complete(ap);
3263                 break;
3264
3265         case HSM_ST_POLL:
3266         case HSM_ST_LAST_POLL:
3267                 timeout = ata_pio_poll(ap);
3268                 break;
3269
3270         case HSM_ST_TMOUT:
3271         case HSM_ST_ERR:
3272                 ata_pio_error(ap);
3273                 return;
3274         }
3275
3276         if (timeout)
3277                 queue_delayed_work(ata_wq, &ap->pio_task, timeout);
3278         else if (!qc_completed)
3279                 goto fsm_start;
3280 }
3281
3282 /**
3283  *      ata_qc_timeout - Handle timeout of queued command
3284  *      @qc: Command that timed out
3285  *
3286  *      Some part of the kernel (currently, only the SCSI layer)
3287  *      has noticed that the active command on port @ap has not
3288  *      completed after a specified length of time.  Handle this
3289  *      condition by disabling DMA (if necessary) and completing
3290  *      transactions, with error if necessary.
3291  *
3292  *      This also handles the case of the "lost interrupt", where
3293  *      for some reason (possibly hardware bug, possibly driver bug)
3294  *      an interrupt was not delivered to the driver, even though the
3295  *      transaction completed successfully.
3296  *
3297  *      LOCKING:
3298  *      Inherited from SCSI layer (none, can sleep)
3299  */
3300
3301 static void ata_qc_timeout(struct ata_queued_cmd *qc)
3302 {
3303         struct ata_port *ap = qc->ap;
3304         struct ata_host_set *host_set = ap->host_set;
3305         struct ata_device *dev = qc->dev;
3306         u8 host_stat = 0, drv_stat;
3307         unsigned long flags;
3308
3309         DPRINTK("ENTER\n");
3310
3311         /* FIXME: doesn't this conflict with timeout handling? */
3312         if (qc->dev->class == ATA_DEV_ATAPI && qc->scsicmd) {
3313                 struct scsi_cmnd *cmd = qc->scsicmd;
3314
3315                 if (!(cmd->eh_eflags & SCSI_EH_CANCEL_CMD)) {
3316
3317                         /* finish completing original command */
3318                         spin_lock_irqsave(&host_set->lock, flags);
3319                         __ata_qc_complete(qc);
3320                         spin_unlock_irqrestore(&host_set->lock, flags);
3321
3322                         atapi_request_sense(ap, dev, cmd);
3323
3324                         cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
3325                         scsi_finish_command(cmd);
3326
3327                         goto out;
3328                 }
3329         }
3330
3331         spin_lock_irqsave(&host_set->lock, flags);
3332
3333         /* hack alert!  We cannot use the supplied completion
3334          * function from inside the ->eh_strategy_handler() thread.
3335          * libata is the only user of ->eh_strategy_handler() in
3336          * any kernel, so the default scsi_done() assumes it is
3337          * not being called from the SCSI EH.
3338          */
3339         qc->scsidone = scsi_finish_command;
3340
3341         switch (qc->tf.protocol) {
3342
3343         case ATA_PROT_DMA:
3344         case ATA_PROT_ATAPI_DMA:
3345                 host_stat = ap->ops->bmdma_status(ap);
3346
3347                 /* before we do anything else, clear DMA-Start bit */
3348                 ap->ops->bmdma_stop(qc);
3349
3350                 /* fall through */
3351
3352         default:
3353                 ata_altstatus(ap);
3354                 drv_stat = ata_chk_status(ap);
3355
3356                 /* ack bmdma irq events */
3357                 ap->ops->irq_clear(ap);
3358
3359                 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
3360                        ap->id, qc->tf.command, drv_stat, host_stat);
3361
3362                 ap->hsm_task_state = HSM_ST_IDLE;
3363
3364                 /* complete taskfile transaction */
3365                 ata_qc_complete(qc, ac_err_mask(drv_stat));
3366                 break;
3367         }
3368
3369         spin_unlock_irqrestore(&host_set->lock, flags);
3370
3371 out:
3372         DPRINTK("EXIT\n");
3373 }
3374
3375 /**
3376  *      ata_eng_timeout - Handle timeout of queued command
3377  *      @ap: Port on which timed-out command is active
3378  *
3379  *      Some part of the kernel (currently, only the SCSI layer)
3380  *      has noticed that the active command on port @ap has not
3381  *      completed after a specified length of time.  Handle this
3382  *      condition by disabling DMA (if necessary) and completing
3383  *      transactions, with error if necessary.
3384  *
3385  *      This also handles the case of the "lost interrupt", where
3386  *      for some reason (possibly hardware bug, possibly driver bug)
3387  *      an interrupt was not delivered to the driver, even though the
3388  *      transaction completed successfully.
3389  *
3390  *      LOCKING:
3391  *      Inherited from SCSI layer (none, can sleep)
3392  */
3393
3394 void ata_eng_timeout(struct ata_port *ap)
3395 {
3396         struct ata_queued_cmd *qc;
3397
3398         DPRINTK("ENTER\n");
3399
3400         qc = ata_qc_from_tag(ap, ap->active_tag);
3401         if (qc)
3402                 ata_qc_timeout(qc);
3403         else {
3404                 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
3405                        ap->id);
3406                 goto out;
3407         }
3408
3409 out:
3410         DPRINTK("EXIT\n");
3411 }
3412
3413 /**
3414  *      ata_qc_new - Request an available ATA command, for queueing
3415  *      @ap: Port associated with device @dev
3416  *      @dev: Device from whom we request an available command structure
3417  *
3418  *      LOCKING:
3419  *      None.
3420  */
3421
3422 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
3423 {
3424       &nb