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