Merge branch 'upstream'
[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_priv.h"
55 #include <scsi/scsi_cmnd.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         void *pad_buf = NULL;
2400
2401         assert(qc->flags & ATA_QCFLAG_DMAMAP);
2402         assert(sg != NULL);
2403
2404         if (qc->flags & ATA_QCFLAG_SINGLE)
2405                 assert(qc->n_elem == 1);
2406
2407         DPRINTK("unmapping %u sg elements\n", qc->n_elem);
2408
2409         /* if we padded the buffer out to 32-bit bound, and data
2410          * xfer direction is from-device, we must copy from the
2411          * pad buffer back into the supplied buffer
2412          */
2413         if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
2414                 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
2415
2416         if (qc->flags & ATA_QCFLAG_SG) {
2417                 dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2418                 /* restore last sg */
2419                 sg[qc->orig_n_elem - 1].length += qc->pad_len;
2420                 if (pad_buf) {
2421                         struct scatterlist *psg = &qc->pad_sgent;
2422                         void *addr = kmap_atomic(psg->page, KM_IRQ0);
2423                         memcpy(addr + psg->offset, pad_buf, qc->pad_len);
2424                         kunmap_atomic(psg->page, KM_IRQ0);
2425                 }
2426         } else {
2427                 dma_unmap_single(ap->host_set->dev, sg_dma_address(&sg[0]),
2428                                  sg_dma_len(&sg[0]), dir);
2429                 /* restore sg */
2430                 sg->length += qc->pad_len;
2431                 if (pad_buf)
2432                         memcpy(qc->buf_virt + sg->length - qc->pad_len,
2433                                pad_buf, qc->pad_len);
2434         }
2435
2436         qc->flags &= ~ATA_QCFLAG_DMAMAP;
2437         qc->__sg = NULL;
2438 }
2439
2440 /**
2441  *      ata_fill_sg - Fill PCI IDE PRD table
2442  *      @qc: Metadata associated with taskfile to be transferred
2443  *
2444  *      Fill PCI IDE PRD (scatter-gather) table with segments
2445  *      associated with the current disk command.
2446  *
2447  *      LOCKING:
2448  *      spin_lock_irqsave(host_set lock)
2449  *
2450  */
2451 static void ata_fill_sg(struct ata_queued_cmd *qc)
2452 {
2453         struct ata_port *ap = qc->ap;
2454         struct scatterlist *sg;
2455         unsigned int idx;
2456
2457         assert(qc->__sg != NULL);
2458         assert(qc->n_elem > 0);
2459
2460         idx = 0;
2461         ata_for_each_sg(sg, qc) {
2462                 u32 addr, offset;
2463                 u32 sg_len, len;
2464
2465                 /* determine if physical DMA addr spans 64K boundary.
2466                  * Note h/w doesn't support 64-bit, so we unconditionally
2467                  * truncate dma_addr_t to u32.
2468                  */
2469                 addr = (u32) sg_dma_address(sg);
2470                 sg_len = sg_dma_len(sg);
2471
2472                 while (sg_len) {
2473                         offset = addr & 0xffff;
2474                         len = sg_len;
2475                         if ((offset + sg_len) > 0x10000)
2476                                 len = 0x10000 - offset;
2477
2478                         ap->prd[idx].addr = cpu_to_le32(addr);
2479                         ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
2480                         VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
2481
2482                         idx++;
2483                         sg_len -= len;
2484                         addr += len;
2485                 }
2486         }
2487
2488         if (idx)
2489                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2490 }
2491 /**
2492  *      ata_check_atapi_dma - Check whether ATAPI DMA can be supported
2493  *      @qc: Metadata associated with taskfile to check
2494  *
2495  *      Allow low-level driver to filter ATA PACKET commands, returning
2496  *      a status indicating whether or not it is OK to use DMA for the
2497  *      supplied PACKET command.
2498  *
2499  *      LOCKING:
2500  *      spin_lock_irqsave(host_set lock)
2501  *
2502  *      RETURNS: 0 when ATAPI DMA can be used
2503  *               nonzero otherwise
2504  */
2505 int ata_check_atapi_dma(struct ata_queued_cmd *qc)
2506 {
2507         struct ata_port *ap = qc->ap;
2508         int rc = 0; /* Assume ATAPI DMA is OK by default */
2509
2510         if (ap->ops->check_atapi_dma)
2511                 rc = ap->ops->check_atapi_dma(qc);
2512
2513         return rc;
2514 }
2515 /**
2516  *      ata_qc_prep - Prepare taskfile for submission
2517  *      @qc: Metadata associated with taskfile to be prepared
2518  *
2519  *      Prepare ATA taskfile for submission.
2520  *
2521  *      LOCKING:
2522  *      spin_lock_irqsave(host_set lock)
2523  */
2524 void ata_qc_prep(struct ata_queued_cmd *qc)
2525 {
2526         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2527                 return;
2528
2529         ata_fill_sg(qc);
2530 }
2531
2532 /**
2533  *      ata_sg_init_one - Associate command with memory buffer
2534  *      @qc: Command to be associated
2535  *      @buf: Memory buffer
2536  *      @buflen: Length of memory buffer, in bytes.
2537  *
2538  *      Initialize the data-related elements of queued_cmd @qc
2539  *      to point to a single memory buffer, @buf of byte length @buflen.
2540  *
2541  *      LOCKING:
2542  *      spin_lock_irqsave(host_set lock)
2543  */
2544
2545 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
2546 {
2547         struct scatterlist *sg;
2548
2549         qc->flags |= ATA_QCFLAG_SINGLE;
2550
2551         memset(&qc->sgent, 0, sizeof(qc->sgent));
2552         qc->__sg = &qc->sgent;
2553         qc->n_elem = 1;
2554         qc->orig_n_elem = 1;
2555         qc->buf_virt = buf;
2556
2557         sg = qc->__sg;
2558         sg_init_one(sg, buf, buflen);
2559 }
2560
2561 /**
2562  *      ata_sg_init - Associate command with scatter-gather table.
2563  *      @qc: Command to be associated
2564  *      @sg: Scatter-gather table.
2565  *      @n_elem: Number of elements in s/g table.
2566  *
2567  *      Initialize the data-related elements of queued_cmd @qc
2568  *      to point to a scatter-gather table @sg, containing @n_elem
2569  *      elements.
2570  *
2571  *      LOCKING:
2572  *      spin_lock_irqsave(host_set lock)
2573  */
2574
2575 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
2576                  unsigned int n_elem)
2577 {
2578         qc->flags |= ATA_QCFLAG_SG;
2579         qc->__sg = sg;
2580         qc->n_elem = n_elem;
2581         qc->orig_n_elem = n_elem;
2582 }
2583
2584 /**
2585  *      ata_sg_setup_one - DMA-map the memory buffer associated with a command.
2586  *      @qc: Command with memory buffer to be mapped.
2587  *
2588  *      DMA-map the memory buffer associated with queued_cmd @qc.
2589  *
2590  *      LOCKING:
2591  *      spin_lock_irqsave(host_set lock)
2592  *
2593  *      RETURNS:
2594  *      Zero on success, negative on error.
2595  */
2596
2597 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
2598 {
2599         struct ata_port *ap = qc->ap;
2600         int dir = qc->dma_dir;
2601         struct scatterlist *sg = qc->__sg;
2602         dma_addr_t dma_address;
2603
2604         /* we must lengthen transfers to end on a 32-bit boundary */
2605         qc->pad_len = sg->length & 3;
2606         if (qc->pad_len) {
2607                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
2608                 struct scatterlist *psg = &qc->pad_sgent;
2609
2610                 assert(qc->dev->class == ATA_DEV_ATAPI);
2611
2612                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
2613
2614                 if (qc->tf.flags & ATA_TFLAG_WRITE)
2615                         memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
2616                                qc->pad_len);
2617
2618                 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
2619                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
2620                 /* trim sg */
2621                 sg->length -= qc->pad_len;
2622
2623                 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
2624                         sg->length, qc->pad_len);
2625         }
2626
2627         dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
2628                                      sg->length, dir);
2629         if (dma_mapping_error(dma_address)) {
2630                 /* restore sg */
2631                 sg->length += qc->pad_len;
2632                 return -1;
2633         }
2634
2635         sg_dma_address(sg) = dma_address;
2636         sg_dma_len(sg) = sg->length;
2637
2638         DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
2639                 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2640
2641         return 0;
2642 }
2643
2644 /**
2645  *      ata_sg_setup - DMA-map the scatter-gather table associated with a command.
2646  *      @qc: Command with scatter-gather table to be mapped.
2647  *
2648  *      DMA-map the scatter-gather table associated with queued_cmd @qc.
2649  *
2650  *      LOCKING:
2651  *      spin_lock_irqsave(host_set lock)
2652  *
2653  *      RETURNS:
2654  *      Zero on success, negative on error.
2655  *
2656  */
2657
2658 static int ata_sg_setup(struct ata_queued_cmd *qc)
2659 {
2660         struct ata_port *ap = qc->ap;
2661         struct scatterlist *sg = qc->__sg;
2662         struct scatterlist *lsg = &sg[qc->n_elem - 1];
2663         int n_elem, dir;
2664
2665         VPRINTK("ENTER, ata%u\n", ap->id);
2666         assert(qc->flags & ATA_QCFLAG_SG);
2667
2668         /* we must lengthen transfers to end on a 32-bit boundary */
2669         qc->pad_len = lsg->length & 3;
2670         if (qc->pad_len) {
2671                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
2672                 struct scatterlist *psg = &qc->pad_sgent;
2673                 unsigned int offset;
2674
2675                 assert(qc->dev->class == ATA_DEV_ATAPI);
2676
2677                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
2678
2679                 /*
2680                  * psg->page/offset are used to copy to-be-written
2681                  * data in this function or read data in ata_sg_clean.
2682                  */
2683                 offset = lsg->offset + lsg->length - qc->pad_len;
2684                 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
2685                 psg->offset = offset_in_page(offset);
2686
2687                 if (qc->tf.flags & ATA_TFLAG_WRITE) {
2688                         void *addr = kmap_atomic(psg->page, KM_IRQ0);
2689                         memcpy(pad_buf, addr + psg->offset, qc->pad_len);
2690                         kunmap_atomic(psg->page, KM_IRQ0);
2691                 }
2692
2693                 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
2694                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
2695                 /* trim last sg */
2696                 lsg->length -= qc->pad_len;
2697
2698                 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
2699                         qc->n_elem - 1, lsg->length, qc->pad_len);
2700         }
2701
2702         dir = qc->dma_dir;
2703         n_elem = dma_map_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2704         if (n_elem < 1) {
2705                 /* restore last sg */
2706                 lsg->length += qc->pad_len;
2707                 return -1;
2708         }
2709
2710         DPRINTK("%d sg elements mapped\n", n_elem);
2711
2712         qc->n_elem = n_elem;
2713
2714         return 0;
2715 }
2716
2717 /**
2718  *      ata_poll_qc_complete - turn irq back on and finish qc
2719  *      @qc: Command to complete
2720  *      @err_mask: ATA status register content
2721  *
2722  *      LOCKING:
2723  *      None.  (grabs host lock)
2724  */
2725
2726 void ata_poll_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask)
2727 {
2728         struct ata_port *ap = qc->ap;
2729         unsigned long flags;
2730
2731         spin_lock_irqsave(&ap->host_set->lock, flags);
2732         ata_irq_on(ap);
2733         ata_qc_complete(qc, err_mask);
2734         spin_unlock_irqrestore(&ap->host_set->lock, flags);
2735 }
2736
2737 /**
2738  *      ata_pio_poll -
2739  *      @ap: the target ata_port
2740  *
2741  *      LOCKING:
2742  *      None.  (executing in kernel thread context)
2743  *
2744  *      RETURNS:
2745  *      timeout value to use
2746  */
2747
2748 static unsigned long ata_pio_poll(struct ata_port *ap)
2749 {
2750         u8 status;
2751         unsigned int poll_state = HSM_ST_UNKNOWN;
2752         unsigned int reg_state = HSM_ST_UNKNOWN;
2753         const unsigned int tmout_state = HSM_ST_TMOUT;
2754
2755         switch (ap->hsm_task_state) {
2756         case HSM_ST:
2757         case HSM_ST_POLL:
2758                 poll_state = HSM_ST_POLL;
2759                 reg_state = HSM_ST;
2760                 break;
2761         case HSM_ST_LAST:
2762         case HSM_ST_LAST_POLL:
2763                 poll_state = HSM_ST_LAST_POLL;
2764                 reg_state = HSM_ST_LAST;
2765                 break;
2766         default:
2767                 BUG();
2768                 break;
2769         }
2770
2771         status = ata_chk_status(ap);
2772         if (status & ATA_BUSY) {
2773                 if (time_after(jiffies, ap->pio_task_timeout)) {
2774                         ap->hsm_task_state = tmout_state;
2775                         return 0;
2776                 }
2777                 ap->hsm_task_state = poll_state;
2778                 return ATA_SHORT_PAUSE;
2779         }
2780
2781         ap->hsm_task_state = reg_state;
2782         return 0;
2783 }
2784
2785 /**
2786  *      ata_pio_complete - check if drive is busy or idle
2787  *      @ap: the target ata_port
2788  *
2789  *      LOCKING:
2790  *      None.  (executing in kernel thread context)
2791  *
2792  *      RETURNS:
2793  *      Non-zero if qc completed, zero otherwise.
2794  */
2795
2796 static int ata_pio_complete (struct ata_port *ap)
2797 {
2798         struct ata_queued_cmd *qc;
2799         u8 drv_stat;
2800
2801         /*
2802          * This is purely heuristic.  This is a fast path.  Sometimes when
2803          * we enter, BSY will be cleared in a chk-status or two.  If not,
2804          * the drive is probably seeking or something.  Snooze for a couple
2805          * msecs, then chk-status again.  If still busy, fall back to
2806          * HSM_ST_POLL state.
2807          */
2808         drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2809         if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2810                 msleep(2);
2811                 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2812                 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2813                         ap->hsm_task_state = HSM_ST_LAST_POLL;
2814                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2815                         return 0;
2816                 }
2817         }
2818
2819         drv_stat = ata_wait_idle(ap);
2820         if (!ata_ok(drv_stat)) {
2821                 ap->hsm_task_state = HSM_ST_ERR;
2822                 return 0;
2823         }
2824
2825         qc = ata_qc_from_tag(ap, ap->active_tag);
2826         assert(qc != NULL);
2827
2828         ap->hsm_task_state = HSM_ST_IDLE;
2829
2830         ata_poll_qc_complete(qc, 0);
2831
2832         /* another command may start at this point */
2833
2834         return 1;
2835 }
2836
2837
2838 /**
2839  *      swap_buf_le16 - swap halves of 16-words in place
2840  *      @buf:  Buffer to swap
2841  *      @buf_words:  Number of 16-bit words in buffer.
2842  *
2843  *      Swap halves of 16-bit words if needed to convert from
2844  *      little-endian byte order to native cpu byte order, or
2845  *      vice-versa.
2846  *
2847  *      LOCKING:
2848  *      Inherited from caller.
2849  */
2850 void swap_buf_le16(u16 *buf, unsigned int buf_words)
2851 {
2852 #ifdef __BIG_ENDIAN
2853         unsigned int i;
2854
2855         for (i = 0; i < buf_words; i++)
2856                 buf[i] = le16_to_cpu(buf[i]);
2857 #endif /* __BIG_ENDIAN */
2858 }
2859
2860 /**
2861  *      ata_mmio_data_xfer - Transfer data by MMIO
2862  *      @ap: port to read/write
2863  *      @buf: data buffer
2864  *      @buflen: buffer length
2865  *      @write_data: read/write
2866  *
2867  *      Transfer data from/to the device data register by MMIO.
2868  *
2869  *      LOCKING:
2870  *      Inherited from caller.
2871  */
2872
2873 static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
2874                                unsigned int buflen, int write_data)
2875 {
2876         unsigned int i;
2877         unsigned int words = buflen >> 1;
2878         u16 *buf16 = (u16 *) buf;
2879         void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
2880
2881         /* Transfer multiple of 2 bytes */
2882         if (write_data) {
2883                 for (i = 0; i < words; i++)
2884                         writew(le16_to_cpu(buf16[i]), mmio);
2885         } else {
2886                 for (i = 0; i < words; i++)
2887                         buf16[i] = cpu_to_le16(readw(mmio));
2888         }
2889
2890         /* Transfer trailing 1 byte, if any. */
2891         if (unlikely(buflen & 0x01)) {
2892                 u16 align_buf[1] = { 0 };
2893                 unsigned char *trailing_buf = buf + buflen - 1;
2894
2895                 if (write_data) {
2896                         memcpy(align_buf, trailing_buf, 1);
2897                         writew(le16_to_cpu(align_buf[0]), mmio);
2898                 } else {
2899                         align_buf[0] = cpu_to_le16(readw(mmio));
2900                         memcpy(trailing_buf, align_buf, 1);
2901                 }
2902         }
2903 }
2904
2905 /**
2906  *      ata_pio_data_xfer - Transfer data by PIO
2907  *      @ap: port to read/write
2908  *      @buf: data buffer
2909  *      @buflen: buffer length
2910  *      @write_data: read/write
2911  *
2912  *      Transfer data from/to the device data register by PIO.
2913  *
2914  *      LOCKING:
2915  *      Inherited from caller.
2916  */
2917
2918 static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
2919                               unsigned int buflen, int write_data)
2920 {
2921         unsigned int words = buflen >> 1;
2922
2923         /* Transfer multiple of 2 bytes */
2924         if (write_data)
2925                 outsw(ap->ioaddr.data_addr, buf, words);
2926         else
2927                 insw(ap->ioaddr.data_addr, buf, words);
2928
2929         /* Transfer trailing 1 byte, if any. */
2930         if (unlikely(buflen & 0x01)) {
2931                 u16 align_buf[1] = { 0 };
2932                 unsigned char *trailing_buf = buf + buflen - 1;
2933
2934                 if (write_data) {
2935                         memcpy(align_buf, trailing_buf, 1);
2936                         outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
2937                 } else {
2938                         align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
2939                         memcpy(trailing_buf, align_buf, 1);
2940                 }
2941         }
2942 }
2943
2944 /**
2945  *      ata_data_xfer - Transfer data from/to the data register.
2946  *      @ap: port to read/write
2947  *      @buf: data buffer
2948  *      @buflen: buffer length
2949  *      @do_write: read/write
2950  *
2951  *      Transfer data from/to the device data register.
2952  *
2953  *      LOCKING:
2954  *      Inherited from caller.
2955  */
2956
2957 static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
2958                           unsigned int buflen, int do_write)
2959 {
2960         if (ap->flags & ATA_FLAG_MMIO)
2961                 ata_mmio_data_xfer(ap, buf, buflen, do_write);
2962         else
2963                 ata_pio_data_xfer(ap, buf, buflen, do_write);
2964 }
2965
2966 /**
2967  *      ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
2968  *      @qc: Command on going
2969  *
2970  *      Transfer ATA_SECT_SIZE of data from/to the ATA device.
2971  *
2972  *      LOCKING:
2973  *      Inherited from caller.
2974  */
2975
2976 static void ata_pio_sector(struct ata_queued_cmd *qc)
2977 {
2978         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2979         struct scatterlist *sg = qc->__sg;
2980         struct ata_port *ap = qc->ap;
2981         struct page *page;
2982         unsigned int offset;
2983         unsigned char *buf;
2984
2985         if (qc->cursect == (qc->nsect - 1))
2986                 ap->hsm_task_state = HSM_ST_LAST;
2987
2988         page = sg[qc->cursg].page;
2989         offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
2990
2991         /* get the current page and offset */
2992         page = nth_page(page, (offset >> PAGE_SHIFT));
2993         offset %= PAGE_SIZE;
2994
2995         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2996
2997         if (PageHighMem(page)) {
2998                 unsigned long flags;
2999
3000                 local_irq_save(flags);
3001                 buf = kmap_atomic(page, KM_IRQ0);
3002
3003                 /* do the actual data transfer */
3004                 ata_data_xfer(ap, buf + offset, ATA_SECT_SIZE, do_write);
3005
3006                 kunmap_atomic(buf, KM_IRQ0);
3007                 local_irq_restore(flags);
3008         } else {
3009                 buf = page_address(page);
3010                 ata_data_xfer(ap, buf + offset, ATA_SECT_SIZE, do_write);
3011         }
3012
3013         qc->cursect++;
3014         qc->cursg_ofs++;
3015
3016         if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
3017                 qc->cursg++;
3018                 qc->cursg_ofs = 0;
3019         }
3020 }
3021
3022 /**
3023  *      atapi_send_cdb - Write CDB bytes to hardware
3024  *      @ap: Port to which ATAPI device is attached.
3025  *      @qc: Taskfile currently active
3026  *
3027  *      When device has indicated its readiness to accept
3028  *      a CDB, this function is called.  Send the CDB.
3029  *
3030  *      LOCKING:
3031  *      caller.
3032  */
3033
3034 static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
3035 {
3036         /* send SCSI cdb */
3037         DPRINTK("send cdb\n");
3038         assert(ap->cdb_len >= 12);
3039
3040         ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
3041         ata_altstatus(ap); /* flush */
3042
3043         switch (qc->tf.protocol) {
3044         case ATA_PROT_ATAPI:
3045                 ap->hsm_task_state = HSM_ST;
3046                 break;
3047         case ATA_PROT_ATAPI_NODATA:
3048                 ap->hsm_task_state = HSM_ST_LAST;
3049                 break;
3050         case ATA_PROT_ATAPI_DMA:
3051                 ap->hsm_task_state = HSM_ST_LAST;
3052                 /* initiate bmdma */
3053                 ap->ops->bmdma_start(qc);
3054                 break;
3055         }
3056 }
3057
3058 /**
3059  *      ata_dataout_task - Write first data block to hardware
3060  *      @_data: Port to which ATA/ATAPI device is attached.
3061  *
3062  *      When device has indicated its readiness to accept
3063  *      the data, this function sends out the CDB or 
3064  *      the first data block by PIO.
3065  *      After this, 
3066  *        - If polling, ata_pio_task() handles the rest.
3067  *        - Otherwise, interrupt handler takes over.
3068  *
3069  *      LOCKING:
3070  *      Kernel thread context (may sleep)
3071  */
3072
3073 static void ata_dataout_task(void *_data)
3074 {
3075         struct ata_port *ap = _data;
3076         struct ata_queued_cmd *qc;
3077         u8 status;
3078         unsigned long flags;
3079
3080         qc = ata_qc_from_tag(ap, ap->active_tag);
3081         assert(qc != NULL);
3082         assert(qc->flags & ATA_QCFLAG_ACTIVE);
3083
3084         /* sleep-wait for BSY to clear */
3085         DPRINTK("busy wait\n");
3086         if (ata_busy_sleep(ap, ATA_TMOUT_DATAOUT_QUICK, ATA_TMOUT_DATAOUT))
3087                 goto err_out;
3088
3089         /* make sure DRQ is set */
3090         status = ata_chk_status(ap);
3091         if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
3092                 goto err_out;
3093
3094         /* Send the CDB (atapi) or the first data block (ata pio out).
3095          * During the state transition, interrupt handler shouldn't
3096          * be invoked before the data transfer is complete and
3097          * hsm_task_state is changed. Hence, the following locking.
3098          */
3099         spin_lock_irqsave(&ap->host_set->lock, flags);
3100
3101         if (qc->tf.protocol == ATA_PROT_PIO) {
3102                 /* PIO data out protocol.
3103                  * send first data block.
3104                  */
3105
3106                 /* ata_pio_sector() might change the state to HSM_ST_LAST.
3107                  * so, the state is changed here before ata_pio_sector().
3108                  */
3109                 ap->hsm_task_state = HSM_ST;
3110                 ata_pio_sector(qc);
3111                 ata_altstatus(ap); /* flush */
3112         } else
3113                 /* send CDB */
3114                 atapi_send_cdb(ap, qc);
3115
3116         /* if polling, ata_pio_task() handles the rest.
3117          * otherwise, interrupt handler takes over from here.
3118          */
3119         if (qc->tf.flags & ATA_TFLAG_POLLING)
3120                 queue_work(ata_wq, &ap->pio_task);
3121
3122         spin_unlock_irqrestore(&ap->host_set->lock, flags);
3123
3124         return;
3125
3126 err_out:
3127         ata_pio_error(ap);
3128 }
3129
3130 /**
3131  *      __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3132  *      @qc: Command on going
3133  *      @bytes: number of bytes
3134  *
3135  *      Transfer Transfer data from/to the ATAPI device.
3136  *
3137  *      LOCKING:
3138  *      Inherited from caller.
3139  *
3140  */
3141
3142 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3143 {
3144         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3145         struct scatterlist *sg = qc->__sg;
3146         struct ata_port *ap = qc->ap;
3147         struct page *page;
3148         unsigned char *buf;
3149         unsigned int offset, count;
3150
3151         if (qc->curbytes + bytes >= qc->nbytes)
3152                 ap->hsm_task_state = HSM_ST_LAST;
3153
3154 next_sg:
3155         if (unlikely(qc->cursg >= qc->n_elem)) {
3156                 /*
3157                  * The end of qc->sg is reached and the device expects
3158                  * more data to transfer. In order not to overrun qc->sg
3159                  * and fulfill length specified in the byte count register,
3160                  *    - for read case, discard trailing data from the device
3161                  *    - for write case, padding zero data to the device
3162                  */
3163                 u16 pad_buf[1] = { 0 };
3164                 unsigned int words = bytes >> 1;
3165                 unsigned int i;
3166
3167                 if (words) /* warning if bytes > 1 */
3168                         printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
3169                                ap->id, bytes);
3170
3171                 for (i = 0; i < words; i++)
3172                         ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
3173
3174                 ap->hsm_task_state = HSM_ST_LAST;
3175                 return;
3176         }
3177
3178         sg = &qc->__sg[qc->cursg];
3179
3180         page = sg->page;
3181         offset = sg->offset + qc->cursg_ofs;
3182
3183         /* get the current page and offset */
3184         page = nth_page(page, (offset >> PAGE_SHIFT));
3185         offset %= PAGE_SIZE;
3186
3187         /* don't overrun current sg */
3188         count = min(sg->length - qc->cursg_ofs, bytes);
3189
3190         /* don't cross page boundaries */
3191         count = min(count, (unsigned int)PAGE_SIZE - offset);
3192
3193         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3194
3195         if (PageHighMem(page)) {
3196                 unsigned long flags;
3197
3198                 local_irq_save(flags);
3199                 buf = kmap_atomic(page, KM_IRQ0);
3200
3201                 /* do the actual data transfer */
3202                 ata_data_xfer(ap, buf + offset, count, do_write);
3203
3204                 kunmap_atomic(buf, KM_IRQ0);
3205                 local_irq_restore(flags);
3206         } else {
3207                 buf = page_address(page);
3208                 ata_data_xfer(ap, buf + offset, count, do_write);
3209         }
3210
3211         bytes -= count;
3212         qc->curbytes += count;
3213         qc->cursg_ofs += count;
3214
3215         if (qc->cursg_ofs == sg->length) {
3216                 qc->cursg++;
3217                 qc->cursg_ofs = 0;
3218         }
3219
3220         if (bytes)
3221                 goto next_sg;
3222 }
3223
3224 /**
3225  *      atapi_pio_bytes - Transfer data from/to the ATAPI device.
3226  *      @qc: Command on going
3227  *
3228  *      Transfer Transfer data from/to the ATAPI device.
3229  *
3230  *      LOCKING:
3231  *      Inherited from caller.
3232  */
3233
3234 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3235 {
3236         struct ata_port *ap = qc->ap;
3237         struct ata_device *dev = qc->dev;
3238         unsigned int ireason, bc_lo, bc_hi, bytes;
3239         int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3240
3241         ap->ops->tf_read(ap, &qc->tf);
3242         ireason = qc->tf.nsect;
3243         bc_lo = qc->tf.lbam;
3244         bc_hi = qc->tf.lbah;
3245         bytes = (bc_hi << 8) | bc_lo;
3246
3247         /* shall be cleared to zero, indicating xfer of data */
3248         if (ireason & (1 << 0))
3249                 goto err_out;
3250
3251         /* make sure transfer direction matches expected */
3252         i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3253         if (do_write != i_write)
3254                 goto err_out;
3255
3256         VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes);
3257
3258         __atapi_pio_bytes(qc, bytes);
3259
3260         return;
3261
3262 err_out:
3263         printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
3264               ap->id, dev->devno);
3265         ap->hsm_task_state = HSM_ST_ERR;
3266 }
3267
3268 /**
3269  *      ata_pio_block - start PIO on a block
3270  *      @ap: the target ata_port
3271  *
3272  *      LOCKING:
3273  *      None.  (executing in kernel thread context)
3274  */
3275
3276 static void ata_pio_block(struct ata_port *ap)
3277 {
3278         struct ata_queued_cmd *qc;
3279         u8 status;
3280
3281         /*
3282          * This is purely heuristic.  This is a fast path.
3283          * Sometimes when we enter, BSY will be cleared in
3284          * a chk-status or two.  If not, the drive is probably seeking
3285          * or something.  Snooze for a couple msecs, then
3286          * chk-status again.  If still busy, fall back to
3287          * HSM_ST_POLL state.
3288          */
3289         status = ata_busy_wait(ap, ATA_BUSY, 5);
3290         if (status & ATA_BUSY) {
3291                 msleep(2);
3292                 status = ata_busy_wait(ap, ATA_BUSY, 10);
3293                 if (status & ATA_BUSY) {
3294                         ap->hsm_task_state = HSM_ST_POLL;
3295                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
3296                         return;
3297                 }
3298         }
3299
3300         qc = ata_qc_from_tag(ap, ap->active_tag);
3301         assert(qc != NULL);
3302
3303         if (is_atapi_taskfile(&qc->tf)) {
3304                 /* no more data to transfer or unsupported ATAPI command */
3305                 if ((status & ATA_DRQ) == 0) {
3306                         ap->hsm_task_state = HSM_ST_LAST;
3307                         return;
3308                 }
3309
3310                 atapi_pio_bytes(qc);
3311         } else {
3312                 /* handle BSY=0, DRQ=0 as error */
3313                 if ((status & ATA_DRQ) == 0) {
3314                         ap->hsm_task_state = HSM_ST_ERR;
3315                         return;
3316                 }
3317
3318                 ata_pio_sector(qc);
3319         }
3320 }
3321
3322 static void ata_pio_error(struct ata_port *ap)
3323 {
3324         struct ata_queued_cmd *qc;
3325
3326         printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
3327
3328         qc = ata_qc_from_tag(ap, ap->active_tag);
3329         assert(qc != NULL);
3330
3331         ap->hsm_task_state = HSM_ST_IDLE;
3332
3333         ata_poll_qc_complete(qc, AC_ERR_ATA_BUS);
3334 }
3335
3336 static void ata_pio_task(void *_data)
3337 {
3338         struct ata_port *ap = _data;
3339         unsigned long timeout;
3340         int qc_completed;
3341
3342 fsm_start:
3343         timeout = 0;
3344         qc_completed = 0;
3345
3346         switch (ap->hsm_task_state) {
3347         case HSM_ST_IDLE:
3348                 return;
3349
3350         case HSM_ST:
3351                 ata_pio_block(ap);
3352                 break;
3353
3354         case HSM_ST_LAST:
3355                 qc_completed = ata_pio_complete(ap);
3356                 break;
3357
3358         case HSM_ST_POLL:
3359         case HSM_ST_LAST_POLL:
3360                 timeout = ata_pio_poll(ap);
3361                 break;
3362
3363         case HSM_ST_TMOUT:
3364         case HSM_ST_ERR:
3365                 ata_pio_error(ap);
3366                 return;
3367         }
3368
3369         if (timeout)
3370                 queue_delayed_work(ata_wq, &ap->pio_task, timeout);
3371         else if (!qc_completed)
3372                 goto fsm_start;
3373 }
3374
3375 /**
3376  *      ata_qc_timeout - Handle timeout of queued command
3377  *      @qc: Command that timed out
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 static void ata_qc_timeout(struct ata_queued_cmd *qc)
3395 {
3396         struct ata_port *ap = qc->ap;
3397         struct ata_host_set *host_set = ap->host_set;
3398         struct ata_device *dev = qc->dev;
3399         u8 host_stat = 0, drv_stat;
3400         unsigned long flags;
3401
3402         DPRINTK("ENTER\n");
3403
3404         /* FIXME: doesn't this conflict with timeout handling? */
3405         if (qc->dev->class == ATA_DEV_ATAPI && qc->scsicmd) {
3406                 struct scsi_cmnd *cmd = qc->scsicmd;
3407
3408                 if (!(cmd->eh_eflags & SCSI_EH_CANCEL_CMD)) {