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