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