Merge git://git.infradead.org/mtd-2.6
[linux-2.6] / drivers / ata / 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/kernel.h>
36 #include <linux/module.h>
37 #include <linux/pci.h>
38 #include <linux/init.h>
39 #include <linux/list.h>
40 #include <linux/mm.h>
41 #include <linux/highmem.h>
42 #include <linux/spinlock.h>
43 #include <linux/blkdev.h>
44 #include <linux/delay.h>
45 #include <linux/timer.h>
46 #include <linux/interrupt.h>
47 #include <linux/completion.h>
48 #include <linux/suspend.h>
49 #include <linux/workqueue.h>
50 #include <linux/jiffies.h>
51 #include <linux/scatterlist.h>
52 #include <scsi/scsi.h>
53 #include <scsi/scsi_cmnd.h>
54 #include <scsi/scsi_host.h>
55 #include <linux/libata.h>
56 #include <asm/io.h>
57 #include <asm/semaphore.h>
58 #include <asm/byteorder.h>
59
60 #include "libata.h"
61
62 #define DRV_VERSION     "2.20"  /* must be exactly four chars */
63
64
65 /* debounce timing parameters in msecs { interval, duration, timeout } */
66 const unsigned long sata_deb_timing_normal[]            = {   5,  100, 2000 };
67 const unsigned long sata_deb_timing_hotplug[]           = {  25,  500, 2000 };
68 const unsigned long sata_deb_timing_long[]              = { 100, 2000, 5000 };
69
70 static unsigned int ata_dev_init_params(struct ata_device *dev,
71                                         u16 heads, u16 sectors);
72 static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
73 static void ata_dev_xfermask(struct ata_device *dev);
74
75 static unsigned int ata_print_id = 1;
76 static struct workqueue_struct *ata_wq;
77
78 struct workqueue_struct *ata_aux_wq;
79
80 int atapi_enabled = 1;
81 module_param(atapi_enabled, int, 0444);
82 MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
83
84 int atapi_dmadir = 0;
85 module_param(atapi_dmadir, int, 0444);
86 MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
87
88 int libata_fua = 0;
89 module_param_named(fua, libata_fua, int, 0444);
90 MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
91
92 static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ;
93 module_param(ata_probe_timeout, int, 0444);
94 MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
95
96 int noacpi;
97 module_param(noacpi, int, 0444);
98 MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in suspend/resume when set");
99
100 MODULE_AUTHOR("Jeff Garzik");
101 MODULE_DESCRIPTION("Library module for ATA devices");
102 MODULE_LICENSE("GPL");
103 MODULE_VERSION(DRV_VERSION);
104
105
106 /**
107  *      ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
108  *      @tf: Taskfile to convert
109  *      @fis: Buffer into which data will output
110  *      @pmp: Port multiplier port
111  *
112  *      Converts a standard ATA taskfile to a Serial ATA
113  *      FIS structure (Register - Host to Device).
114  *
115  *      LOCKING:
116  *      Inherited from caller.
117  */
118
119 void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
120 {
121         fis[0] = 0x27;  /* Register - Host to Device FIS */
122         fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
123                                             bit 7 indicates Command FIS */
124         fis[2] = tf->command;
125         fis[3] = tf->feature;
126
127         fis[4] = tf->lbal;
128         fis[5] = tf->lbam;
129         fis[6] = tf->lbah;
130         fis[7] = tf->device;
131
132         fis[8] = tf->hob_lbal;
133         fis[9] = tf->hob_lbam;
134         fis[10] = tf->hob_lbah;
135         fis[11] = tf->hob_feature;
136
137         fis[12] = tf->nsect;
138         fis[13] = tf->hob_nsect;
139         fis[14] = 0;
140         fis[15] = tf->ctl;
141
142         fis[16] = 0;
143         fis[17] = 0;
144         fis[18] = 0;
145         fis[19] = 0;
146 }
147
148 /**
149  *      ata_tf_from_fis - Convert SATA FIS to ATA taskfile
150  *      @fis: Buffer from which data will be input
151  *      @tf: Taskfile to output
152  *
153  *      Converts a serial ATA FIS structure to a standard ATA taskfile.
154  *
155  *      LOCKING:
156  *      Inherited from caller.
157  */
158
159 void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
160 {
161         tf->command     = fis[2];       /* status */
162         tf->feature     = fis[3];       /* error */
163
164         tf->lbal        = fis[4];
165         tf->lbam        = fis[5];
166         tf->lbah        = fis[6];
167         tf->device      = fis[7];
168
169         tf->hob_lbal    = fis[8];
170         tf->hob_lbam    = fis[9];
171         tf->hob_lbah    = fis[10];
172
173         tf->nsect       = fis[12];
174         tf->hob_nsect   = fis[13];
175 }
176
177 static const u8 ata_rw_cmds[] = {
178         /* pio multi */
179         ATA_CMD_READ_MULTI,
180         ATA_CMD_WRITE_MULTI,
181         ATA_CMD_READ_MULTI_EXT,
182         ATA_CMD_WRITE_MULTI_EXT,
183         0,
184         0,
185         0,
186         ATA_CMD_WRITE_MULTI_FUA_EXT,
187         /* pio */
188         ATA_CMD_PIO_READ,
189         ATA_CMD_PIO_WRITE,
190         ATA_CMD_PIO_READ_EXT,
191         ATA_CMD_PIO_WRITE_EXT,
192         0,
193         0,
194         0,
195         0,
196         /* dma */
197         ATA_CMD_READ,
198         ATA_CMD_WRITE,
199         ATA_CMD_READ_EXT,
200         ATA_CMD_WRITE_EXT,
201         0,
202         0,
203         0,
204         ATA_CMD_WRITE_FUA_EXT
205 };
206
207 /**
208  *      ata_rwcmd_protocol - set taskfile r/w commands and protocol
209  *      @tf: command to examine and configure
210  *      @dev: device tf belongs to
211  *
212  *      Examine the device configuration and tf->flags to calculate
213  *      the proper read/write commands and protocol to use.
214  *
215  *      LOCKING:
216  *      caller.
217  */
218 static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
219 {
220         u8 cmd;
221
222         int index, fua, lba48, write;
223
224         fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
225         lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
226         write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
227
228         if (dev->flags & ATA_DFLAG_PIO) {
229                 tf->protocol = ATA_PROT_PIO;
230                 index = dev->multi_count ? 0 : 8;
231         } else if (lba48 && (dev->ap->flags & ATA_FLAG_PIO_LBA48)) {
232                 /* Unable to use DMA due to host limitation */
233                 tf->protocol = ATA_PROT_PIO;
234                 index = dev->multi_count ? 0 : 8;
235         } else {
236                 tf->protocol = ATA_PROT_DMA;
237                 index = 16;
238         }
239
240         cmd = ata_rw_cmds[index + fua + lba48 + write];
241         if (cmd) {
242                 tf->command = cmd;
243                 return 0;
244         }
245         return -1;
246 }
247
248 /**
249  *      ata_tf_read_block - Read block address from ATA taskfile
250  *      @tf: ATA taskfile of interest
251  *      @dev: ATA device @tf belongs to
252  *
253  *      LOCKING:
254  *      None.
255  *
256  *      Read block address from @tf.  This function can handle all
257  *      three address formats - LBA, LBA48 and CHS.  tf->protocol and
258  *      flags select the address format to use.
259  *
260  *      RETURNS:
261  *      Block address read from @tf.
262  */
263 u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev)
264 {
265         u64 block = 0;
266
267         if (tf->flags & ATA_TFLAG_LBA) {
268                 if (tf->flags & ATA_TFLAG_LBA48) {
269                         block |= (u64)tf->hob_lbah << 40;
270                         block |= (u64)tf->hob_lbam << 32;
271                         block |= tf->hob_lbal << 24;
272                 } else
273                         block |= (tf->device & 0xf) << 24;
274
275                 block |= tf->lbah << 16;
276                 block |= tf->lbam << 8;
277                 block |= tf->lbal;
278         } else {
279                 u32 cyl, head, sect;
280
281                 cyl = tf->lbam | (tf->lbah << 8);
282                 head = tf->device & 0xf;
283                 sect = tf->lbal;
284
285                 block = (cyl * dev->heads + head) * dev->sectors + sect;
286         }
287
288         return block;
289 }
290
291 /**
292  *      ata_build_rw_tf - Build ATA taskfile for given read/write request
293  *      @tf: Target ATA taskfile
294  *      @dev: ATA device @tf belongs to
295  *      @block: Block address
296  *      @n_block: Number of blocks
297  *      @tf_flags: RW/FUA etc...
298  *      @tag: tag
299  *
300  *      LOCKING:
301  *      None.
302  *
303  *      Build ATA taskfile @tf for read/write request described by
304  *      @block, @n_block, @tf_flags and @tag on @dev.
305  *
306  *      RETURNS:
307  *
308  *      0 on success, -ERANGE if the request is too large for @dev,
309  *      -EINVAL if the request is invalid.
310  */
311 int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
312                     u64 block, u32 n_block, unsigned int tf_flags,
313                     unsigned int tag)
314 {
315         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
316         tf->flags |= tf_flags;
317
318         if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) {
319                 /* yay, NCQ */
320                 if (!lba_48_ok(block, n_block))
321                         return -ERANGE;
322
323                 tf->protocol = ATA_PROT_NCQ;
324                 tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
325
326                 if (tf->flags & ATA_TFLAG_WRITE)
327                         tf->command = ATA_CMD_FPDMA_WRITE;
328                 else
329                         tf->command = ATA_CMD_FPDMA_READ;
330
331                 tf->nsect = tag << 3;
332                 tf->hob_feature = (n_block >> 8) & 0xff;
333                 tf->feature = n_block & 0xff;
334
335                 tf->hob_lbah = (block >> 40) & 0xff;
336                 tf->hob_lbam = (block >> 32) & 0xff;
337                 tf->hob_lbal = (block >> 24) & 0xff;
338                 tf->lbah = (block >> 16) & 0xff;
339                 tf->lbam = (block >> 8) & 0xff;
340                 tf->lbal = block & 0xff;
341
342                 tf->device = 1 << 6;
343                 if (tf->flags & ATA_TFLAG_FUA)
344                         tf->device |= 1 << 7;
345         } else if (dev->flags & ATA_DFLAG_LBA) {
346                 tf->flags |= ATA_TFLAG_LBA;
347
348                 if (lba_28_ok(block, n_block)) {
349                         /* use LBA28 */
350                         tf->device |= (block >> 24) & 0xf;
351                 } else if (lba_48_ok(block, n_block)) {
352                         if (!(dev->flags & ATA_DFLAG_LBA48))
353                                 return -ERANGE;
354
355                         /* use LBA48 */
356                         tf->flags |= ATA_TFLAG_LBA48;
357
358                         tf->hob_nsect = (n_block >> 8) & 0xff;
359
360                         tf->hob_lbah = (block >> 40) & 0xff;
361                         tf->hob_lbam = (block >> 32) & 0xff;
362                         tf->hob_lbal = (block >> 24) & 0xff;
363                 } else
364                         /* request too large even for LBA48 */
365                         return -ERANGE;
366
367                 if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
368                         return -EINVAL;
369
370                 tf->nsect = n_block & 0xff;
371
372                 tf->lbah = (block >> 16) & 0xff;
373                 tf->lbam = (block >> 8) & 0xff;
374                 tf->lbal = block & 0xff;
375
376                 tf->device |= ATA_LBA;
377         } else {
378                 /* CHS */
379                 u32 sect, head, cyl, track;
380
381                 /* The request -may- be too large for CHS addressing. */
382                 if (!lba_28_ok(block, n_block))
383                         return -ERANGE;
384
385                 if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
386                         return -EINVAL;
387
388                 /* Convert LBA to CHS */
389                 track = (u32)block / dev->sectors;
390                 cyl   = track / dev->heads;
391                 head  = track % dev->heads;
392                 sect  = (u32)block % dev->sectors + 1;
393
394                 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
395                         (u32)block, track, cyl, head, sect);
396
397                 /* Check whether the converted CHS can fit.
398                    Cylinder: 0-65535
399                    Head: 0-15
400                    Sector: 1-255*/
401                 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
402                         return -ERANGE;
403
404                 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
405                 tf->lbal = sect;
406                 tf->lbam = cyl;
407                 tf->lbah = cyl >> 8;
408                 tf->device |= head;
409         }
410
411         return 0;
412 }
413
414 /**
415  *      ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
416  *      @pio_mask: pio_mask
417  *      @mwdma_mask: mwdma_mask
418  *      @udma_mask: udma_mask
419  *
420  *      Pack @pio_mask, @mwdma_mask and @udma_mask into a single
421  *      unsigned int xfer_mask.
422  *
423  *      LOCKING:
424  *      None.
425  *
426  *      RETURNS:
427  *      Packed xfer_mask.
428  */
429 static unsigned int ata_pack_xfermask(unsigned int pio_mask,
430                                       unsigned int mwdma_mask,
431                                       unsigned int udma_mask)
432 {
433         return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
434                 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
435                 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
436 }
437
438 /**
439  *      ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
440  *      @xfer_mask: xfer_mask to unpack
441  *      @pio_mask: resulting pio_mask
442  *      @mwdma_mask: resulting mwdma_mask
443  *      @udma_mask: resulting udma_mask
444  *
445  *      Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
446  *      Any NULL distination masks will be ignored.
447  */
448 static void ata_unpack_xfermask(unsigned int xfer_mask,
449                                 unsigned int *pio_mask,
450                                 unsigned int *mwdma_mask,
451                                 unsigned int *udma_mask)
452 {
453         if (pio_mask)
454                 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
455         if (mwdma_mask)
456                 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
457         if (udma_mask)
458                 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
459 }
460
461 static const struct ata_xfer_ent {
462         int shift, bits;
463         u8 base;
464 } ata_xfer_tbl[] = {
465         { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
466         { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
467         { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
468         { -1, },
469 };
470
471 /**
472  *      ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
473  *      @xfer_mask: xfer_mask of interest
474  *
475  *      Return matching XFER_* value for @xfer_mask.  Only the highest
476  *      bit of @xfer_mask is considered.
477  *
478  *      LOCKING:
479  *      None.
480  *
481  *      RETURNS:
482  *      Matching XFER_* value, 0 if no match found.
483  */
484 static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
485 {
486         int highbit = fls(xfer_mask) - 1;
487         const struct ata_xfer_ent *ent;
488
489         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
490                 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
491                         return ent->base + highbit - ent->shift;
492         return 0;
493 }
494
495 /**
496  *      ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
497  *      @xfer_mode: XFER_* of interest
498  *
499  *      Return matching xfer_mask for @xfer_mode.
500  *
501  *      LOCKING:
502  *      None.
503  *
504  *      RETURNS:
505  *      Matching xfer_mask, 0 if no match found.
506  */
507 static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
508 {
509         const struct ata_xfer_ent *ent;
510
511         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
512                 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
513                         return 1 << (ent->shift + xfer_mode - ent->base);
514         return 0;
515 }
516
517 /**
518  *      ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
519  *      @xfer_mode: XFER_* of interest
520  *
521  *      Return matching xfer_shift for @xfer_mode.
522  *
523  *      LOCKING:
524  *      None.
525  *
526  *      RETURNS:
527  *      Matching xfer_shift, -1 if no match found.
528  */
529 static int ata_xfer_mode2shift(unsigned int xfer_mode)
530 {
531         const struct ata_xfer_ent *ent;
532
533         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
534                 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
535                         return ent->shift;
536         return -1;
537 }
538
539 /**
540  *      ata_mode_string - convert xfer_mask to string
541  *      @xfer_mask: mask of bits supported; only highest bit counts.
542  *
543  *      Determine string which represents the highest speed
544  *      (highest bit in @modemask).
545  *
546  *      LOCKING:
547  *      None.
548  *
549  *      RETURNS:
550  *      Constant C string representing highest speed listed in
551  *      @mode_mask, or the constant C string "<n/a>".
552  */
553 static const char *ata_mode_string(unsigned int xfer_mask)
554 {
555         static const char * const xfer_mode_str[] = {
556                 "PIO0",
557                 "PIO1",
558                 "PIO2",
559                 "PIO3",
560                 "PIO4",
561                 "PIO5",
562                 "PIO6",
563                 "MWDMA0",
564                 "MWDMA1",
565                 "MWDMA2",
566                 "MWDMA3",
567                 "MWDMA4",
568                 "UDMA/16",
569                 "UDMA/25",
570                 "UDMA/33",
571                 "UDMA/44",
572                 "UDMA/66",
573                 "UDMA/100",
574                 "UDMA/133",
575                 "UDMA7",
576         };
577         int highbit;
578
579         highbit = fls(xfer_mask) - 1;
580         if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
581                 return xfer_mode_str[highbit];
582         return "<n/a>";
583 }
584
585 static const char *sata_spd_string(unsigned int spd)
586 {
587         static const char * const spd_str[] = {
588                 "1.5 Gbps",
589                 "3.0 Gbps",
590         };
591
592         if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
593                 return "<unknown>";
594         return spd_str[spd - 1];
595 }
596
597 void ata_dev_disable(struct ata_device *dev)
598 {
599         if (ata_dev_enabled(dev) && ata_msg_drv(dev->ap)) {
600                 ata_dev_printk(dev, KERN_WARNING, "disabled\n");
601                 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |
602                                              ATA_DNXFER_QUIET);
603                 dev->class++;
604         }
605 }
606
607 /**
608  *      ata_devchk - PATA device presence detection
609  *      @ap: ATA channel to examine
610  *      @device: Device to examine (starting at zero)
611  *
612  *      This technique was originally described in
613  *      Hale Landis's ATADRVR (www.ata-atapi.com), and
614  *      later found its way into the ATA/ATAPI spec.
615  *
616  *      Write a pattern to the ATA shadow registers,
617  *      and if a device is present, it will respond by
618  *      correctly storing and echoing back the
619  *      ATA shadow register contents.
620  *
621  *      LOCKING:
622  *      caller.
623  */
624
625 static unsigned int ata_devchk(struct ata_port *ap, unsigned int device)
626 {
627         struct ata_ioports *ioaddr = &ap->ioaddr;
628         u8 nsect, lbal;
629
630         ap->ops->dev_select(ap, device);
631
632         iowrite8(0x55, ioaddr->nsect_addr);
633         iowrite8(0xaa, ioaddr->lbal_addr);
634
635         iowrite8(0xaa, ioaddr->nsect_addr);
636         iowrite8(0x55, ioaddr->lbal_addr);
637
638         iowrite8(0x55, ioaddr->nsect_addr);
639         iowrite8(0xaa, ioaddr->lbal_addr);
640
641         nsect = ioread8(ioaddr->nsect_addr);
642         lbal = ioread8(ioaddr->lbal_addr);
643
644         if ((nsect == 0x55) && (lbal == 0xaa))
645                 return 1;       /* we found a device */
646
647         return 0;               /* nothing found */
648 }
649
650 /**
651  *      ata_dev_classify - determine device type based on ATA-spec signature
652  *      @tf: ATA taskfile register set for device to be identified
653  *
654  *      Determine from taskfile register contents whether a device is
655  *      ATA or ATAPI, as per "Signature and persistence" section
656  *      of ATA/PI spec (volume 1, sect 5.14).
657  *
658  *      LOCKING:
659  *      None.
660  *
661  *      RETURNS:
662  *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
663  *      the event of failure.
664  */
665
666 unsigned int ata_dev_classify(const struct ata_taskfile *tf)
667 {
668         /* Apple's open source Darwin code hints that some devices only
669          * put a proper signature into the LBA mid/high registers,
670          * So, we only check those.  It's sufficient for uniqueness.
671          */
672
673         if (((tf->lbam == 0) && (tf->lbah == 0)) ||
674             ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
675                 DPRINTK("found ATA device by sig\n");
676                 return ATA_DEV_ATA;
677         }
678
679         if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
680             ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
681                 DPRINTK("found ATAPI device by sig\n");
682                 return ATA_DEV_ATAPI;
683         }
684
685         DPRINTK("unknown device\n");
686         return ATA_DEV_UNKNOWN;
687 }
688
689 /**
690  *      ata_dev_try_classify - Parse returned ATA device signature
691  *      @ap: ATA channel to examine
692  *      @device: Device to examine (starting at zero)
693  *      @r_err: Value of error register on completion
694  *
695  *      After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
696  *      an ATA/ATAPI-defined set of values is placed in the ATA
697  *      shadow registers, indicating the results of device detection
698  *      and diagnostics.
699  *
700  *      Select the ATA device, and read the values from the ATA shadow
701  *      registers.  Then parse according to the Error register value,
702  *      and the spec-defined values examined by ata_dev_classify().
703  *
704  *      LOCKING:
705  *      caller.
706  *
707  *      RETURNS:
708  *      Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
709  */
710
711 unsigned int
712 ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
713 {
714         struct ata_taskfile tf;
715         unsigned int class;
716         u8 err;
717
718         ap->ops->dev_select(ap, device);
719
720         memset(&tf, 0, sizeof(tf));
721
722         ap->ops->tf_read(ap, &tf);
723         err = tf.feature;
724         if (r_err)
725                 *r_err = err;
726
727         /* see if device passed diags: if master then continue and warn later */
728         if (err == 0 && device == 0)
729                 /* diagnostic fail : do nothing _YET_ */
730                 ap->device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC;
731         else if (err == 1)
732                 /* do nothing */ ;
733         else if ((device == 0) && (err == 0x81))
734                 /* do nothing */ ;
735         else
736                 return ATA_DEV_NONE;
737
738         /* determine if device is ATA or ATAPI */
739         class = ata_dev_classify(&tf);
740
741         if (class == ATA_DEV_UNKNOWN)
742                 return ATA_DEV_NONE;
743         if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
744                 return ATA_DEV_NONE;
745         return class;
746 }
747
748 /**
749  *      ata_id_string - Convert IDENTIFY DEVICE page into string
750  *      @id: IDENTIFY DEVICE results we will examine
751  *      @s: string into which data is output
752  *      @ofs: offset into identify device page
753  *      @len: length of string to return. must be an even number.
754  *
755  *      The strings in the IDENTIFY DEVICE page are broken up into
756  *      16-bit chunks.  Run through the string, and output each
757  *      8-bit chunk linearly, regardless of platform.
758  *
759  *      LOCKING:
760  *      caller.
761  */
762
763 void ata_id_string(const u16 *id, unsigned char *s,
764                    unsigned int ofs, unsigned int len)
765 {
766         unsigned int c;
767
768         while (len > 0) {
769                 c = id[ofs] >> 8;
770                 *s = c;
771                 s++;
772
773                 c = id[ofs] & 0xff;
774                 *s = c;
775                 s++;
776
777                 ofs++;
778                 len -= 2;
779         }
780 }
781
782 /**
783  *      ata_id_c_string - Convert IDENTIFY DEVICE page into C string
784  *      @id: IDENTIFY DEVICE results we will examine
785  *      @s: string into which data is output
786  *      @ofs: offset into identify device page
787  *      @len: length of string to return. must be an odd number.
788  *
789  *      This function is identical to ata_id_string except that it
790  *      trims trailing spaces and terminates the resulting string with
791  *      null.  @len must be actual maximum length (even number) + 1.
792  *
793  *      LOCKING:
794  *      caller.
795  */
796 void ata_id_c_string(const u16 *id, unsigned char *s,
797                      unsigned int ofs, unsigned int len)
798 {
799         unsigned char *p;
800
801         WARN_ON(!(len & 1));
802
803         ata_id_string(id, s, ofs, len - 1);
804
805         p = s + strnlen(s, len - 1);
806         while (p > s && p[-1] == ' ')
807                 p--;
808         *p = '\0';
809 }
810
811 static u64 ata_id_n_sectors(const u16 *id)
812 {
813         if (ata_id_has_lba(id)) {
814                 if (ata_id_has_lba48(id))
815                         return ata_id_u64(id, 100);
816                 else
817                         return ata_id_u32(id, 60);
818         } else {
819                 if (ata_id_current_chs_valid(id))
820                         return ata_id_u32(id, 57);
821                 else
822                         return id[1] * id[3] * id[6];
823         }
824 }
825
826 /**
827  *      ata_id_to_dma_mode      -       Identify DMA mode from id block
828  *      @dev: device to identify
829  *      @mode: mode to assume if we cannot tell
830  *
831  *      Set up the timing values for the device based upon the identify
832  *      reported values for the DMA mode. This function is used by drivers
833  *      which rely upon firmware configured modes, but wish to report the
834  *      mode correctly when possible.
835  *
836  *      In addition we emit similarly formatted messages to the default
837  *      ata_dev_set_mode handler, in order to provide consistency of
838  *      presentation.
839  */
840
841 void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown)
842 {
843         unsigned int mask;
844         u8 mode;
845
846         /* Pack the DMA modes */
847         mask = ((dev->id[63] >> 8) << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA;
848         if (dev->id[53] & 0x04)
849                 mask |= ((dev->id[88] >> 8) << ATA_SHIFT_UDMA) & ATA_MASK_UDMA;
850
851         /* Select the mode in use */
852         mode = ata_xfer_mask2mode(mask);
853
854         if (mode != 0) {
855                 ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
856                        ata_mode_string(mask));
857         } else {
858                 /* SWDMA perhaps ? */
859                 mode = unknown;
860                 ata_dev_printk(dev, KERN_INFO, "configured for DMA\n");
861         }
862
863         /* Configure the device reporting */
864         dev->xfer_mode = mode;
865         dev->xfer_shift = ata_xfer_mode2shift(mode);
866 }
867
868 /**
869  *      ata_noop_dev_select - Select device 0/1 on ATA bus
870  *      @ap: ATA channel to manipulate
871  *      @device: ATA device (numbered from zero) to select
872  *
873  *      This function performs no actual function.
874  *
875  *      May be used as the dev_select() entry in ata_port_operations.
876  *
877  *      LOCKING:
878  *      caller.
879  */
880 void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
881 {
882 }
883
884
885 /**
886  *      ata_std_dev_select - Select device 0/1 on ATA bus
887  *      @ap: ATA channel to manipulate
888  *      @device: ATA device (numbered from zero) to select
889  *
890  *      Use the method defined in the ATA specification to
891  *      make either device 0, or device 1, active on the
892  *      ATA channel.  Works with both PIO and MMIO.
893  *
894  *      May be used as the dev_select() entry in ata_port_operations.
895  *
896  *      LOCKING:
897  *      caller.
898  */
899
900 void ata_std_dev_select (struct ata_port *ap, unsigned int device)
901 {
902         u8 tmp;
903
904         if (device == 0)
905                 tmp = ATA_DEVICE_OBS;
906         else
907                 tmp = ATA_DEVICE_OBS | ATA_DEV1;
908
909         iowrite8(tmp, ap->ioaddr.device_addr);
910         ata_pause(ap);          /* needed; also flushes, for mmio */
911 }
912
913 /**
914  *      ata_dev_select - Select device 0/1 on ATA bus
915  *      @ap: ATA channel to manipulate
916  *      @device: ATA device (numbered from zero) to select
917  *      @wait: non-zero to wait for Status register BSY bit to clear
918  *      @can_sleep: non-zero if context allows sleeping
919  *
920  *      Use the method defined in the ATA specification to
921  *      make either device 0, or device 1, active on the
922  *      ATA channel.
923  *
924  *      This is a high-level version of ata_std_dev_select(),
925  *      which additionally provides the services of inserting
926  *      the proper pauses and status polling, where needed.
927  *
928  *      LOCKING:
929  *      caller.
930  */
931
932 void ata_dev_select(struct ata_port *ap, unsigned int device,
933                            unsigned int wait, unsigned int can_sleep)
934 {
935         if (ata_msg_probe(ap))
936                 ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, "
937                                 "device %u, wait %u\n", device, wait);
938
939         if (wait)
940                 ata_wait_idle(ap);
941
942         ap->ops->dev_select(ap, device);
943
944         if (wait) {
945                 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
946                         msleep(150);
947                 ata_wait_idle(ap);
948         }
949 }
950
951 /**
952  *      ata_dump_id - IDENTIFY DEVICE info debugging output
953  *      @id: IDENTIFY DEVICE page to dump
954  *
955  *      Dump selected 16-bit words from the given IDENTIFY DEVICE
956  *      page.
957  *
958  *      LOCKING:
959  *      caller.
960  */
961
962 static inline void ata_dump_id(const u16 *id)
963 {
964         DPRINTK("49==0x%04x  "
965                 "53==0x%04x  "
966                 "63==0x%04x  "
967                 "64==0x%04x  "
968                 "75==0x%04x  \n",
969                 id[49],
970                 id[53],
971                 id[63],
972                 id[64],
973                 id[75]);
974         DPRINTK("80==0x%04x  "
975                 "81==0x%04x  "
976                 "82==0x%04x  "
977                 "83==0x%04x  "
978                 "84==0x%04x  \n",
979                 id[80],
980                 id[81],
981                 id[82],
982                 id[83],
983                 id[84]);
984         DPRINTK("88==0x%04x  "
985                 "93==0x%04x\n",
986                 id[88],
987                 id[93]);
988 }
989
990 /**
991  *      ata_id_xfermask - Compute xfermask from the given IDENTIFY data
992  *      @id: IDENTIFY data to compute xfer mask from
993  *
994  *      Compute the xfermask for this device. This is not as trivial
995  *      as it seems if we must consider early devices correctly.
996  *
997  *      FIXME: pre IDE drive timing (do we care ?).
998  *
999  *      LOCKING:
1000  *      None.
1001  *
1002  *      RETURNS:
1003  *      Computed xfermask
1004  */
1005 static unsigned int ata_id_xfermask(const u16 *id)
1006 {
1007         unsigned int pio_mask, mwdma_mask, udma_mask;
1008
1009         /* Usual case. Word 53 indicates word 64 is valid */
1010         if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
1011                 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
1012                 pio_mask <<= 3;
1013                 pio_mask |= 0x7;
1014         } else {
1015                 /* If word 64 isn't valid then Word 51 high byte holds
1016                  * the PIO timing number for the maximum. Turn it into
1017                  * a mask.
1018                  */
1019                 u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
1020                 if (mode < 5)   /* Valid PIO range */
1021                         pio_mask = (2 << mode) - 1;
1022                 else
1023                         pio_mask = 1;
1024
1025                 /* But wait.. there's more. Design your standards by
1026                  * committee and you too can get a free iordy field to
1027                  * process. However its the speeds not the modes that
1028                  * are supported... Note drivers using the timing API
1029                  * will get this right anyway
1030                  */
1031         }
1032
1033         mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
1034
1035         if (ata_id_is_cfa(id)) {
1036                 /*
1037                  *      Process compact flash extended modes
1038                  */
1039                 int pio = id[163] & 0x7;
1040                 int dma = (id[163] >> 3) & 7;
1041
1042                 if (pio)
1043                         pio_mask |= (1 << 5);
1044                 if (pio > 1)
1045                         pio_mask |= (1 << 6);
1046                 if (dma)
1047                         mwdma_mask |= (1 << 3);
1048                 if (dma > 1)
1049                         mwdma_mask |= (1 << 4);
1050         }
1051
1052         udma_mask = 0;
1053         if (id[ATA_ID_FIELD_VALID] & (1 << 2))
1054                 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
1055
1056         return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
1057 }
1058
1059 /**
1060  *      ata_port_queue_task - Queue port_task
1061  *      @ap: The ata_port to queue port_task for
1062  *      @fn: workqueue function to be scheduled
1063  *      @data: data for @fn to use
1064  *      @delay: delay time for workqueue function
1065  *
1066  *      Schedule @fn(@data) for execution after @delay jiffies using
1067  *      port_task.  There is one port_task per port and it's the
1068  *      user(low level driver)'s responsibility to make sure that only
1069  *      one task is active at any given time.
1070  *
1071  *      libata core layer takes care of synchronization between
1072  *      port_task and EH.  ata_port_queue_task() may be ignored for EH
1073  *      synchronization.
1074  *
1075  *      LOCKING:
1076  *      Inherited from caller.
1077  */
1078 void ata_port_queue_task(struct ata_port *ap, work_func_t fn, void *data,
1079                          unsigned long delay)
1080 {
1081         int rc;
1082
1083         if (ap->pflags & ATA_PFLAG_FLUSH_PORT_TASK)
1084                 return;
1085
1086         PREPARE_DELAYED_WORK(&ap->port_task, fn);
1087         ap->port_task_data = data;
1088
1089         rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
1090
1091         /* rc == 0 means that another user is using port task */
1092         WARN_ON(rc == 0);
1093 }
1094
1095 /**
1096  *      ata_port_flush_task - Flush port_task
1097  *      @ap: The ata_port to flush port_task for
1098  *
1099  *      After this function completes, port_task is guranteed not to
1100  *      be running or scheduled.
1101  *
1102  *      LOCKING:
1103  *      Kernel thread context (may sleep)
1104  */
1105 void ata_port_flush_task(struct ata_port *ap)
1106 {
1107         unsigned long flags;
1108
1109         DPRINTK("ENTER\n");
1110
1111         spin_lock_irqsave(ap->lock, flags);
1112         ap->pflags |= ATA_PFLAG_FLUSH_PORT_TASK;
1113         spin_unlock_irqrestore(ap->lock, flags);
1114
1115         DPRINTK("flush #1\n");
1116         flush_workqueue(ata_wq);
1117
1118         /*
1119          * At this point, if a task is running, it's guaranteed to see
1120          * the FLUSH flag; thus, it will never queue pio tasks again.
1121          * Cancel and flush.
1122          */
1123         if (!cancel_delayed_work(&ap->port_task)) {
1124                 if (ata_msg_ctl(ap))
1125                         ata_port_printk(ap, KERN_DEBUG, "%s: flush #2\n",
1126                                         __FUNCTION__);
1127                 flush_workqueue(ata_wq);
1128         }
1129
1130         spin_lock_irqsave(ap->lock, flags);
1131         ap->pflags &= ~ATA_PFLAG_FLUSH_PORT_TASK;
1132         spin_unlock_irqrestore(ap->lock, flags);
1133
1134         if (ata_msg_ctl(ap))
1135                 ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __FUNCTION__);
1136 }
1137
1138 static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
1139 {
1140         struct completion *waiting = qc->private_data;
1141
1142         complete(waiting);
1143 }
1144
1145 /**
1146  *      ata_exec_internal_sg - execute libata internal command
1147  *      @dev: Device to which the command is sent
1148  *      @tf: Taskfile registers for the command and the result
1149  *      @cdb: CDB for packet command
1150  *      @dma_dir: Data tranfer direction of the command
1151  *      @sg: sg list for the data buffer of the command
1152  *      @n_elem: Number of sg entries
1153  *
1154  *      Executes libata internal command with timeout.  @tf contains
1155  *      command on entry and result on return.  Timeout and error
1156  *      conditions are reported via return value.  No recovery action
1157  *      is taken after a command times out.  It's caller's duty to
1158  *      clean up after timeout.
1159  *
1160  *      LOCKING:
1161  *      None.  Should be called with kernel context, might sleep.
1162  *
1163  *      RETURNS:
1164  *      Zero on success, AC_ERR_* mask on failure
1165  */
1166 unsigned ata_exec_internal_sg(struct ata_device *dev,
1167                               struct ata_taskfile *tf, const u8 *cdb,
1168                               int dma_dir, struct scatterlist *sg,
1169                               unsigned int n_elem)
1170 {
1171         struct ata_port *ap = dev->ap;
1172         u8 command = tf->command;
1173         struct ata_queued_cmd *qc;
1174         unsigned int tag, preempted_tag;
1175         u32 preempted_sactive, preempted_qc_active;
1176         DECLARE_COMPLETION_ONSTACK(wait);
1177         unsigned long flags;
1178         unsigned int err_mask;
1179         int rc;
1180
1181         spin_lock_irqsave(ap->lock, flags);
1182
1183         /* no internal command while frozen */
1184         if (ap->pflags & ATA_PFLAG_FROZEN) {
1185                 spin_unlock_irqrestore(ap->lock, flags);
1186                 return AC_ERR_SYSTEM;
1187         }
1188
1189         /* initialize internal qc */
1190
1191         /* XXX: Tag 0 is used for drivers with legacy EH as some
1192          * drivers choke if any other tag is given.  This breaks
1193          * ata_tag_internal() test for those drivers.  Don't use new
1194          * EH stuff without converting to it.
1195          */
1196         if (ap->ops->error_handler)
1197                 tag = ATA_TAG_INTERNAL;
1198         else
1199                 tag = 0;
1200
1201         if (test_and_set_bit(tag, &ap->qc_allocated))
1202                 BUG();
1203         qc = __ata_qc_from_tag(ap, tag);
1204
1205         qc->tag = tag;
1206         qc->scsicmd = NULL;
1207         qc->ap = ap;
1208         qc->dev = dev;
1209         ata_qc_reinit(qc);
1210
1211         preempted_tag = ap->active_tag;
1212         preempted_sactive = ap->sactive;
1213         preempted_qc_active = ap->qc_active;
1214         ap->active_tag = ATA_TAG_POISON;
1215         ap->sactive = 0;
1216         ap->qc_active = 0;
1217
1218         /* prepare & issue qc */
1219         qc->tf = *tf;
1220         if (cdb)
1221                 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
1222         qc->flags |= ATA_QCFLAG_RESULT_TF;
1223         qc->dma_dir = dma_dir;
1224         if (dma_dir != DMA_NONE) {
1225                 unsigned int i, buflen = 0;
1226
1227                 for (i = 0; i < n_elem; i++)
1228                         buflen += sg[i].length;
1229
1230                 ata_sg_init(qc, sg, n_elem);
1231                 qc->nbytes = buflen;
1232         }
1233
1234         qc->private_data = &wait;
1235         qc->complete_fn = ata_qc_complete_internal;
1236
1237         ata_qc_issue(qc);
1238
1239         spin_unlock_irqrestore(ap->lock, flags);
1240
1241         rc = wait_for_completion_timeout(&wait, ata_probe_timeout);
1242
1243         ata_port_flush_task(ap);
1244
1245         if (!rc) {
1246                 spin_lock_irqsave(ap->lock, flags);
1247
1248                 /* We're racing with irq here.  If we lose, the
1249                  * following test prevents us from completing the qc
1250                  * twice.  If we win, the port is frozen and will be
1251                  * cleaned up by ->post_internal_cmd().
1252                  */
1253                 if (qc->flags & ATA_QCFLAG_ACTIVE) {
1254                         qc->err_mask |= AC_ERR_TIMEOUT;
1255
1256                         if (ap->ops->error_handler)
1257                                 ata_port_freeze(ap);
1258                         else
1259                                 ata_qc_complete(qc);
1260
1261                         if (ata_msg_warn(ap))
1262                                 ata_dev_printk(dev, KERN_WARNING,
1263                                         "qc timeout (cmd 0x%x)\n", command);
1264                 }
1265
1266                 spin_unlock_irqrestore(ap->lock, flags);
1267         }
1268
1269         /* do post_internal_cmd */
1270         if (ap->ops->post_internal_cmd)
1271                 ap->ops->post_internal_cmd(qc);
1272
1273         if ((qc->flags & ATA_QCFLAG_FAILED) && !qc->err_mask) {
1274                 if (ata_msg_warn(ap))
1275                         ata_dev_printk(dev, KERN_WARNING,
1276                                 "zero err_mask for failed "
1277                                 "internal command, assuming AC_ERR_OTHER\n");
1278                 qc->err_mask |= AC_ERR_OTHER;
1279         }
1280
1281         /* finish up */
1282         spin_lock_irqsave(ap->lock, flags);
1283
1284         *tf = qc->result_tf;
1285         err_mask = qc->err_mask;
1286
1287         ata_qc_free(qc);
1288         ap->active_tag = preempted_tag;
1289         ap->sactive = preempted_sactive;
1290         ap->qc_active = preempted_qc_active;
1291
1292         /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1293          * Until those drivers are fixed, we detect the condition
1294          * here, fail the command with AC_ERR_SYSTEM and reenable the
1295          * port.
1296          *
1297          * Note that this doesn't change any behavior as internal
1298          * command failure results in disabling the device in the
1299          * higher layer for LLDDs without new reset/EH callbacks.
1300          *
1301          * Kill the following code as soon as those drivers are fixed.
1302          */
1303         if (ap->flags & ATA_FLAG_DISABLED) {
1304                 err_mask |= AC_ERR_SYSTEM;
1305                 ata_port_probe(ap);
1306         }
1307
1308         spin_unlock_irqrestore(ap->lock, flags);
1309
1310         return err_mask;
1311 }
1312
1313 /**
1314  *      ata_exec_internal - execute libata internal command
1315  *      @dev: Device to which the command is sent
1316  *      @tf: Taskfile registers for the command and the result
1317  *      @cdb: CDB for packet command
1318  *      @dma_dir: Data tranfer direction of the command
1319  *      @buf: Data buffer of the command
1320  *      @buflen: Length of data buffer
1321  *
1322  *      Wrapper around ata_exec_internal_sg() which takes simple
1323  *      buffer instead of sg list.
1324  *
1325  *      LOCKING:
1326  *      None.  Should be called with kernel context, might sleep.
1327  *
1328  *      RETURNS:
1329  *      Zero on success, AC_ERR_* mask on failure
1330  */
1331 unsigned ata_exec_internal(struct ata_device *dev,
1332                            struct ata_taskfile *tf, const u8 *cdb,
1333                            int dma_dir, void *buf, unsigned int buflen)
1334 {
1335         struct scatterlist *psg = NULL, sg;
1336         unsigned int n_elem = 0;
1337
1338         if (dma_dir != DMA_NONE) {
1339                 WARN_ON(!buf);
1340                 sg_init_one(&sg, buf, buflen);
1341                 psg = &sg;
1342                 n_elem++;
1343         }
1344
1345         return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem);
1346 }
1347
1348 /**
1349  *      ata_do_simple_cmd - execute simple internal command
1350  *      @dev: Device to which the command is sent
1351  *      @cmd: Opcode to execute
1352  *
1353  *      Execute a 'simple' command, that only consists of the opcode
1354  *      'cmd' itself, without filling any other registers
1355  *
1356  *      LOCKING:
1357  *      Kernel thread context (may sleep).
1358  *
1359  *      RETURNS:
1360  *      Zero on success, AC_ERR_* mask on failure
1361  */
1362 unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
1363 {
1364         struct ata_taskfile tf;
1365
1366         ata_tf_init(dev, &tf);
1367
1368         tf.command = cmd;
1369         tf.flags |= ATA_TFLAG_DEVICE;
1370         tf.protocol = ATA_PROT_NODATA;
1371
1372         return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
1373 }
1374
1375 /**
1376  *      ata_pio_need_iordy      -       check if iordy needed
1377  *      @adev: ATA device
1378  *
1379  *      Check if the current speed of the device requires IORDY. Used
1380  *      by various controllers for chip configuration.
1381  */
1382
1383 unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1384 {
1385         int pio;
1386         int speed = adev->pio_mode - XFER_PIO_0;
1387
1388         if (speed < 2)
1389                 return 0;
1390         if (speed > 2)
1391                 return 1;
1392
1393         /* If we have no drive specific rule, then PIO 2 is non IORDY */
1394
1395         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1396                 pio = adev->id[ATA_ID_EIDE_PIO];
1397                 /* Is the speed faster than the drive allows non IORDY ? */
1398                 if (pio) {
1399                         /* This is cycle times not frequency - watch the logic! */
1400                         if (pio > 240)  /* PIO2 is 240nS per cycle */
1401                                 return 1;
1402                         return 0;
1403                 }
1404         }
1405         return 0;
1406 }
1407
1408 /**
1409  *      ata_dev_read_id - Read ID data from the specified device
1410  *      @dev: target device
1411  *      @p_class: pointer to class of the target device (may be changed)
1412  *      @flags: ATA_READID_* flags
1413  *      @id: buffer to read IDENTIFY data into
1414  *
1415  *      Read ID data from the specified device.  ATA_CMD_ID_ATA is
1416  *      performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
1417  *      devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
1418  *      for pre-ATA4 drives.
1419  *
1420  *      LOCKING:
1421  *      Kernel thread context (may sleep)
1422  *
1423  *      RETURNS:
1424  *      0 on success, -errno otherwise.
1425  */
1426 int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
1427                     unsigned int flags, u16 *id)
1428 {
1429         struct ata_port *ap = dev->ap;
1430         unsigned int class = *p_class;
1431         struct ata_taskfile tf;
1432         unsigned int err_mask = 0;
1433         const char *reason;
1434         int rc;
1435
1436         if (ata_msg_ctl(ap))
1437                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__);
1438
1439         ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1440
1441  retry:
1442         ata_tf_init(dev, &tf);
1443
1444         switch (class) {
1445         case ATA_DEV_ATA:
1446                 tf.command = ATA_CMD_ID_ATA;
1447                 break;
1448         case ATA_DEV_ATAPI:
1449                 tf.command = ATA_CMD_ID_ATAPI;
1450                 break;
1451         default:
1452                 rc = -ENODEV;
1453                 reason = "unsupported class";
1454                 goto err_out;
1455         }
1456
1457         tf.protocol = ATA_PROT_PIO;
1458
1459         /* Some devices choke if TF registers contain garbage.  Make
1460          * sure those are properly initialized.
1461          */
1462         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1463
1464         /* Device presence detection is unreliable on some
1465          * controllers.  Always poll IDENTIFY if available.
1466          */
1467         tf.flags |= ATA_TFLAG_POLLING;
1468
1469         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
1470                                      id, sizeof(id[0]) * ATA_ID_WORDS);
1471         if (err_mask) {
1472                 if (err_mask & AC_ERR_NODEV_HINT) {
1473                         DPRINTK("ata%u.%d: NODEV after polling detection\n",
1474                                 ap->print_id, dev->devno);
1475                         return -ENOENT;
1476                 }
1477
1478                 rc = -EIO;
1479                 reason = "I/O error";
1480                 goto err_out;
1481         }
1482
1483         swap_buf_le16(id, ATA_ID_WORDS);
1484
1485         /* sanity check */
1486         rc = -EINVAL;
1487         reason = "device reports illegal type";
1488
1489         if (class == ATA_DEV_ATA) {
1490                 if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
1491                         goto err_out;
1492         } else {
1493                 if (ata_id_is_ata(id))
1494                         goto err_out;
1495         }
1496
1497         if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) {
1498                 /*
1499                  * The exact sequence expected by certain pre-ATA4 drives is:
1500                  * SRST RESET
1501                  * IDENTIFY
1502                  * INITIALIZE DEVICE PARAMETERS
1503                  * anything else..
1504                  * Some drives were very specific about that exact sequence.
1505                  */
1506                 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
1507                         err_mask = ata_dev_init_params(dev, id[3], id[6]);
1508                         if (err_mask) {
1509                                 rc = -EIO;
1510                                 reason = "INIT_DEV_PARAMS failed";
1511                                 goto err_out;
1512                         }
1513
1514                         /* current CHS translation info (id[53-58]) might be
1515                          * changed. reread the identify device info.
1516                          */
1517                         flags &= ~ATA_READID_POSTRESET;
1518                         goto retry;
1519                 }
1520         }
1521
1522         *p_class = class;
1523
1524         return 0;
1525
1526  err_out:
1527         if (ata_msg_warn(ap))
1528                 ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY "
1529                                "(%s, err_mask=0x%x)\n", reason, err_mask);
1530         return rc;
1531 }
1532
1533 static inline u8 ata_dev_knobble(struct ata_device *dev)
1534 {
1535         return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
1536 }
1537
1538 static void ata_dev_config_ncq(struct ata_device *dev,
1539                                char *desc, size_t desc_sz)
1540 {
1541         struct ata_port *ap = dev->ap;
1542         int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
1543
1544         if (!ata_id_has_ncq(dev->id)) {
1545                 desc[0] = '\0';
1546                 return;
1547         }
1548         if (ata_device_blacklisted(dev) & ATA_HORKAGE_NONCQ) {
1549                 snprintf(desc, desc_sz, "NCQ (not used)");
1550                 return;
1551         }
1552         if (ap->flags & ATA_FLAG_NCQ) {
1553                 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1);
1554                 dev->flags |= ATA_DFLAG_NCQ;
1555         }
1556
1557         if (hdepth >= ddepth)
1558                 snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth);
1559         else
1560                 snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth);
1561 }
1562
1563 static void ata_set_port_max_cmd_len(struct ata_port *ap)
1564 {
1565         int i;
1566
1567         if (ap->scsi_host) {
1568                 unsigned int len = 0;
1569
1570                 for (i = 0; i < ATA_MAX_DEVICES; i++)
1571                         len = max(len, ap->device[i].cdb_len);
1572
1573                 ap->scsi_host->max_cmd_len = len;
1574         }
1575 }
1576
1577 /**
1578  *      ata_dev_configure - Configure the specified ATA/ATAPI device
1579  *      @dev: Target device to configure
1580  *
1581  *      Configure @dev according to @dev->id.  Generic and low-level
1582  *      driver specific fixups are also applied.
1583  *
1584  *      LOCKING:
1585  *      Kernel thread context (may sleep)
1586  *
1587  *      RETURNS:
1588  *      0 on success, -errno otherwise
1589  */
1590 int ata_dev_configure(struct ata_device *dev)
1591 {
1592         struct ata_port *ap = dev->ap;
1593         int print_info = ap->eh_context.i.flags & ATA_EHI_PRINTINFO;
1594         const u16 *id = dev->id;
1595         unsigned int xfer_mask;
1596         char revbuf[7];         /* XYZ-99\0 */
1597         char fwrevbuf[ATA_ID_FW_REV_LEN+1];
1598         char modelbuf[ATA_ID_PROD_LEN+1];
1599         int rc;
1600
1601         if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
1602                 ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n",
1603                                __FUNCTION__);
1604                 return 0;
1605         }
1606
1607         if (ata_msg_probe(ap))
1608                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__);
1609
1610         /* set _SDD */
1611         rc = ata_acpi_push_id(ap, dev->devno);
1612         if (rc) {
1613                 ata_dev_printk(dev, KERN_WARNING, "failed to set _SDD(%d)\n",
1614                         rc);
1615         }
1616
1617         /* retrieve and execute the ATA task file of _GTF */
1618         ata_acpi_exec_tfs(ap);
1619
1620         /* print device capabilities */
1621         if (ata_msg_probe(ap))
1622                 ata_dev_printk(dev, KERN_DEBUG,
1623                                "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
1624                                "85:%04x 86:%04x 87:%04x 88:%04x\n",
1625                                __FUNCTION__,
1626                                id[49], id[82], id[83], id[84],
1627                                id[85], id[86], id[87], id[88]);
1628
1629         /* initialize to-be-configured parameters */
1630         dev->flags &= ~ATA_DFLAG_CFG_MASK;
1631         dev->max_sectors = 0;
1632         dev->cdb_len = 0;
1633         dev->n_sectors = 0;
1634         dev->cylinders = 0;
1635         dev->heads = 0;
1636         dev->sectors = 0;
1637
1638         /*
1639          * common ATA, ATAPI feature tests
1640          */
1641
1642         /* find max transfer mode; for printk only */
1643         xfer_mask = ata_id_xfermask(id);
1644
1645         if (ata_msg_probe(ap))
1646                 ata_dump_id(id);
1647
1648         /* ATA-specific feature tests */
1649         if (dev->class == ATA_DEV_ATA) {
1650                 if (ata_id_is_cfa(id)) {
1651                         if (id[162] & 1) /* CPRM may make this media unusable */
1652                                 ata_dev_printk(dev, KERN_WARNING,
1653                                                "supports DRM functions and may "
1654                                                "not be fully accessable.\n");
1655                         snprintf(revbuf, 7, "CFA");
1656                 }
1657                 else
1658                         snprintf(revbuf, 7, "ATA-%d",  ata_id_major_version(id));
1659
1660                 dev->n_sectors = ata_id_n_sectors(id);
1661
1662                 /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
1663                 ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
1664                                 sizeof(fwrevbuf));
1665
1666                 ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
1667                                 sizeof(modelbuf));
1668
1669                 if (dev->id[59] & 0x100)
1670                         dev->multi_count = dev->id[59] & 0xff;
1671
1672                 if (ata_id_has_lba(id)) {
1673                         const char *lba_desc;
1674                         char ncq_desc[20];
1675
1676                         lba_desc = "LBA";
1677                         dev->flags |= ATA_DFLAG_LBA;
1678                         if (ata_id_has_lba48(id)) {
1679                                 dev->flags |= ATA_DFLAG_LBA48;
1680                                 lba_desc = "LBA48";
1681
1682                                 if (dev->n_sectors >= (1UL << 28) &&
1683                                     ata_id_has_flush_ext(id))
1684                                         dev->flags |= ATA_DFLAG_FLUSH_EXT;
1685                         }
1686
1687                         /* config NCQ */
1688                         ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
1689
1690                         /* print device info to dmesg */
1691                         if (ata_msg_drv(ap) && print_info) {
1692                                 ata_dev_printk(dev, KERN_INFO,
1693                                         "%s: %s, %s, max %s\n",
1694                                         revbuf, modelbuf, fwrevbuf,
1695                                         ata_mode_string(xfer_mask));
1696                                 ata_dev_printk(dev, KERN_INFO,
1697                                         "%Lu sectors, multi %u: %s %s\n",
1698                                         (unsigned long long)dev->n_sectors,
1699                                         dev->multi_count, lba_desc, ncq_desc);
1700                         }
1701                 } else {
1702                         /* CHS */
1703
1704                         /* Default translation */
1705                         dev->cylinders  = id[1];
1706                         dev->heads      = id[3];
1707                         dev->sectors    = id[6];
1708
1709                         if (ata_id_current_chs_valid(id)) {
1710                                 /* Current CHS translation is valid. */
1711                                 dev->cylinders = id[54];
1712                                 dev->heads     = id[55];
1713                                 dev->sectors   = id[56];
1714                         }
1715
1716                         /* print device info to dmesg */
1717                         if (ata_msg_drv(ap) && print_info) {
1718                                 ata_dev_printk(dev, KERN_INFO,
1719                                         "%s: %s, %s, max %s\n",
1720                                         revbuf, modelbuf, fwrevbuf,
1721                                         ata_mode_string(xfer_mask));
1722                                 ata_dev_printk(dev, KERN_INFO,
1723                                         "%Lu sectors, multi %u, CHS %u/%u/%u\n",
1724                                         (unsigned long long)dev->n_sectors,
1725                                         dev->multi_count, dev->cylinders,
1726                                         dev->heads, dev->sectors);
1727                         }
1728                 }
1729
1730                 dev->cdb_len = 16;
1731         }
1732
1733         /* ATAPI-specific feature tests */
1734         else if (dev->class == ATA_DEV_ATAPI) {
1735                 char *cdb_intr_string = "";
1736
1737                 rc = atapi_cdb_len(id);
1738                 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1739                         if (ata_msg_warn(ap))
1740                                 ata_dev_printk(dev, KERN_WARNING,
1741                                                "unsupported CDB len\n");
1742                         rc = -EINVAL;
1743                         goto err_out_nosup;
1744                 }
1745                 dev->cdb_len = (unsigned int) rc;
1746
1747                 if (ata_id_cdb_intr(dev->id)) {
1748                         dev->flags |= ATA_DFLAG_CDB_INTR;
1749                         cdb_intr_string = ", CDB intr";
1750                 }
1751
1752                 /* print device info to dmesg */
1753                 if (ata_msg_drv(ap) && print_info)
1754                         ata_dev_printk(dev, KERN_INFO, "ATAPI, max %s%s\n",
1755                                        ata_mode_string(xfer_mask),
1756                                        cdb_intr_string);
1757         }
1758
1759         /* determine max_sectors */
1760         dev->max_sectors = ATA_MAX_SECTORS;
1761         if (dev->flags & ATA_DFLAG_LBA48)
1762                 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
1763
1764         if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
1765                 /* Let the user know. We don't want to disallow opens for
1766                    rescue purposes, or in case the vendor is just a blithering
1767                    idiot */
1768                 if (print_info) {
1769                         ata_dev_printk(dev, KERN_WARNING,
1770 "Drive reports diagnostics failure. This may indicate a drive\n");
1771                         ata_dev_printk(dev, KERN_WARNING,
1772 "fault or invalid emulation. Contact drive vendor for information.\n");
1773                 }
1774         }
1775
1776         ata_set_port_max_cmd_len(ap);
1777
1778         /* limit bridge transfers to udma5, 200 sectors */
1779         if (ata_dev_knobble(dev)) {
1780                 if (ata_msg_drv(ap) && print_info)
1781                         ata_dev_printk(dev, KERN_INFO,
1782                                        "applying bridge limits\n");
1783                 dev->udma_mask &= ATA_UDMA5;
1784                 dev->max_sectors = ATA_MAX_SECTORS;
1785         }
1786
1787         if (ap->ops->dev_config)
1788                 ap->ops->dev_config(ap, dev);
1789
1790         if (ata_msg_probe(ap))
1791                 ata_dev_printk(dev, KERN_DEBUG, "%s: EXIT, drv_stat = 0x%x\n",
1792                         __FUNCTION__, ata_chk_status(ap));
1793         return 0;
1794
1795 err_out_nosup:
1796         if (ata_msg_probe(ap))
1797                 ata_dev_printk(dev, KERN_DEBUG,
1798                                "%s: EXIT, err\n", __FUNCTION__);
1799         return rc;
1800 }
1801
1802 /**
1803  *      ata_bus_probe - Reset and probe ATA bus
1804  *      @ap: Bus to probe
1805  *
1806  *      Master ATA bus probing function.  Initiates a hardware-dependent
1807  *      bus reset, then attempts to identify any devices found on
1808  *      the bus.
1809  *
1810  *      LOCKING:
1811  *      PCI/etc. bus probe sem.
1812  *
1813  *      RETURNS:
1814  *      Zero on success, negative errno otherwise.
1815  */
1816
1817 int ata_bus_probe(struct ata_port *ap)
1818 {
1819         unsigned int classes[ATA_MAX_DEVICES];
1820         int tries[ATA_MAX_DEVICES];
1821         int i, rc;
1822         struct ata_device *dev;
1823
1824         ata_port_probe(ap);
1825
1826         for (i = 0; i < ATA_MAX_DEVICES; i++)
1827                 tries[i] = ATA_PROBE_MAX_TRIES;
1828
1829  retry:
1830         /* reset and determine device classes */
1831         ap->ops->phy_reset(ap);
1832
1833         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1834                 dev = &ap->device[i];
1835
1836                 if (!(ap->flags & ATA_FLAG_DISABLED) &&
1837                     dev->class != ATA_DEV_UNKNOWN)
1838                         classes[dev->devno] = dev->class;
1839                 else
1840                         classes[dev->devno] = ATA_DEV_NONE;
1841
1842                 dev->class = ATA_DEV_UNKNOWN;
1843         }
1844
1845         ata_port_probe(ap);
1846
1847         /* after the reset the device state is PIO 0 and the controller
1848            state is undefined. Record the mode */
1849
1850         for (i = 0; i < ATA_MAX_DEVICES; i++)
1851                 ap->device[i].pio_mode = XFER_PIO_0;
1852
1853         /* read IDENTIFY page and configure devices. We have to do the identify
1854            specific sequence bass-ackwards so that PDIAG- is released by
1855            the slave device */
1856
1857         for (i = ATA_MAX_DEVICES - 1; i >=  0; i--) {
1858                 dev = &ap->device[i];
1859
1860                 if (tries[i])
1861                         dev->class = classes[i];
1862
1863                 if (!ata_dev_enabled(dev))
1864                         continue;
1865
1866                 rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET,
1867                                      dev->id);
1868                 if (rc)
1869                         goto fail;
1870         }
1871
1872         /* After the identify sequence we can now set up the devices. We do
1873            this in the normal order so that the user doesn't get confused */
1874
1875         for(i = 0; i < ATA_MAX_DEVICES; i++) {
1876                 dev = &ap->device[i];
1877                 if (!ata_dev_enabled(dev))
1878                         continue;
1879
1880                 ap->eh_context.i.flags |= ATA_EHI_PRINTINFO;
1881                 rc = ata_dev_configure(dev);
1882                 ap->eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
1883                 if (rc)
1884                         goto fail;
1885         }
1886
1887         /* configure transfer mode */
1888         rc = ata_set_mode(ap, &dev);
1889         if (rc)
1890                 goto fail;
1891
1892         for (i = 0; i < ATA_MAX_DEVICES; i++)
1893                 if (ata_dev_enabled(&ap->device[i]))
1894                         return 0;
1895
1896         /* no device present, disable port */
1897         ata_port_disable(ap);
1898         ap->ops->port_disable(ap);
1899         return -ENODEV;
1900
1901  fail:
1902         tries[dev->devno]--;
1903
1904         switch (rc) {
1905         case -EINVAL:
1906                 /* eeek, something went very wrong, give up */
1907                 tries[dev->devno] = 0;
1908                 break;
1909
1910         case -ENODEV:
1911                 /* give it just one more chance */
1912                 tries[dev->devno] = min(tries[dev->devno], 1);
1913         case -EIO:
1914                 if (tries[dev->devno] == 1) {
1915                         /* This is the last chance, better to slow
1916                          * down than lose it.
1917                          */
1918                         sata_down_spd_limit(ap);
1919                         ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
1920                 }
1921         }
1922
1923         if (!tries[dev->devno])
1924                 ata_dev_disable(dev);
1925
1926         goto retry;
1927 }
1928
1929 /**
1930  *      ata_port_probe - Mark port as enabled
1931  *      @ap: Port for which we indicate enablement
1932  *
1933  *      Modify @ap data structure such that the system
1934  *      thinks that the entire port is enabled.
1935  *
1936  *      LOCKING: host lock, or some other form of
1937  *      serialization.
1938  */
1939
1940 void ata_port_probe(struct ata_port *ap)
1941 {
1942         ap->flags &= ~ATA_FLAG_DISABLED;
1943 }
1944
1945 /**
1946  *      sata_print_link_status - Print SATA link status
1947  *      @ap: SATA port to printk link status about
1948  *
1949  *      This function prints link speed and status of a SATA link.
1950  *
1951  *      LOCKING:
1952  *      None.
1953  */
1954 static void sata_print_link_status(struct ata_port *ap)
1955 {
1956         u32 sstatus, scontrol, tmp;
1957
1958         if (sata_scr_read(ap, SCR_STATUS, &sstatus))
1959                 return;
1960         sata_scr_read(ap, SCR_CONTROL, &scontrol);
1961
1962         if (ata_port_online(ap)) {
1963                 tmp = (sstatus >> 4) & 0xf;
1964                 ata_port_printk(ap, KERN_INFO,
1965                                 "SATA link up %s (SStatus %X SControl %X)\n",
1966                                 sata_spd_string(tmp), sstatus, scontrol);
1967         } else {
1968                 ata_port_printk(ap, KERN_INFO,
1969                                 "SATA link down (SStatus %X SControl %X)\n",
1970                                 sstatus, scontrol);
1971         }
1972 }
1973
1974 /**
1975  *      __sata_phy_reset - Wake/reset a low-level SATA PHY
1976  *      @ap: SATA port associated with target SATA PHY.
1977  *
1978  *      This function issues commands to standard SATA Sxxx
1979  *      PHY registers, to wake up the phy (and device), and
1980  *      clear any reset condition.
1981  *
1982  *      LOCKING:
1983  *      PCI/etc. bus probe sem.
1984  *
1985  */
1986 void __sata_phy_reset(struct ata_port *ap)
1987 {
1988         u32 sstatus;
1989         unsigned long timeout = jiffies + (HZ * 5);
1990
1991         if (ap->flags & ATA_FLAG_SATA_RESET) {
1992                 /* issue phy wake/reset */
1993                 sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
1994                 /* Couldn't find anything in SATA I/II specs, but
1995                  * AHCI-1.1 10.4.2 says at least 1 ms. */
1996                 mdelay(1);
1997         }
1998         /* phy wake/clear reset */
1999         sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
2000
2001         /* wait for phy to become ready, if necessary */
2002         do {
2003                 msleep(200);
2004                 sata_scr_read(ap, SCR_STATUS, &sstatus);
2005                 if ((sstatus & 0xf) != 1)
2006                         break;
2007         } while (time_before(jiffies, timeout));
2008
2009         /* print link status */
2010         sata_print_link_status(ap);
2011
2012         /* TODO: phy layer with polling, timeouts, etc. */
2013         if (!ata_port_offline(ap))
2014                 ata_port_probe(ap);
2015         else
2016                 ata_port_disable(ap);
2017
2018         if (ap->flags & ATA_FLAG_DISABLED)
2019                 return;
2020
2021         if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
2022                 ata_port_disable(ap);
2023                 return;
2024         }
2025
2026         ap->cbl = ATA_CBL_SATA;
2027 }
2028
2029 /**
2030  *      sata_phy_reset - Reset SATA bus.
2031  *      @ap: SATA port associated with target SATA PHY.
2032  *
2033  *      This function resets the SATA bus, and then probes
2034  *      the bus for devices.
2035  *
2036  *      LOCKING:
2037  *      PCI/etc. bus probe sem.
2038  *
2039  */
2040 void sata_phy_reset(struct ata_port *ap)
2041 {
2042         __sata_phy_reset(ap);
2043         if (ap->flags & ATA_FLAG_DISABLED)
2044                 return;
2045         ata_bus_reset(ap);
2046 }
2047
2048 /**
2049  *      ata_dev_pair            -       return other device on cable
2050  *      @adev: device
2051  *
2052  *      Obtain the other device on the same cable, or if none is
2053  *      present NULL is returned
2054  */
2055
2056 struct ata_device *ata_dev_pair(struct ata_device *adev)
2057 {
2058         struct ata_port *ap = adev->ap;
2059         struct ata_device *pair = &ap->device[1 - adev->devno];
2060         if (!ata_dev_enabled(pair))
2061                 return NULL;
2062         return pair;
2063 }
2064
2065 /**
2066  *      ata_port_disable - Disable port.
2067  *      @ap: Port to be disabled.
2068  *
2069  *      Modify @ap data structure such that the system
2070  *      thinks that the entire port is disabled, and should
2071  *      never attempt to probe or communicate with devices
2072  *      on this port.
2073  *
2074  *      LOCKING: host lock, or some other form of
2075  *      serialization.
2076  */
2077
2078 void ata_port_disable(struct ata_port *ap)
2079 {
2080         ap->device[0].class = ATA_DEV_NONE;
2081         ap->device[1].class = ATA_DEV_NONE;
2082         ap->flags |= ATA_FLAG_DISABLED;
2083 }
2084
2085 /**
2086  *      sata_down_spd_limit - adjust SATA spd limit downward
2087  *      @ap: Port to adjust SATA spd limit for
2088  *
2089  *      Adjust SATA spd limit of @ap downward.  Note that this
2090  *      function only adjusts the limit.  The change must be applied
2091  *      using sata_set_spd().
2092  *
2093  *      LOCKING:
2094  *      Inherited from caller.
2095  *
2096  *      RETURNS:
2097  *      0 on success, negative errno on failure
2098  */
2099 int sata_down_spd_limit(struct ata_port *ap)
2100 {
2101         u32 sstatus, spd, mask;
2102         int rc, highbit;
2103
2104         rc = sata_scr_read(ap, SCR_STATUS, &sstatus);
2105         if (rc)
2106                 return rc;
2107
2108         mask = ap->sata_spd_limit;
2109         if (mask <= 1)
2110                 return -EINVAL;
2111         highbit = fls(mask) - 1;
2112         mask &= ~(1 << highbit);
2113
2114         spd = (sstatus >> 4) & 0xf;
2115         if (spd <= 1)
2116                 return -EINVAL;
2117         spd--;
2118         mask &= (1 << spd) - 1;
2119         if (!mask)
2120                 return -EINVAL;
2121
2122         ap->sata_spd_limit = mask;
2123
2124         ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n",
2125                         sata_spd_string(fls(mask)));
2126
2127         return 0;
2128 }
2129
2130 static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
2131 {
2132         u32 spd, limit;
2133
2134         if (ap->sata_spd_limit == UINT_MAX)
2135                 limit = 0;
2136         else
2137                 limit = fls(ap->sata_spd_limit);
2138
2139         spd = (*scontrol >> 4) & 0xf;
2140         *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
2141
2142         return spd != limit;
2143 }
2144
2145 /**
2146  *      sata_set_spd_needed - is SATA spd configuration needed
2147  *      @ap: Port in question
2148  *
2149  *      Test whether the spd limit in SControl matches
2150  *      @ap->sata_spd_limit.  This function is used to determine
2151  *      whether hardreset is necessary to apply SATA spd
2152  *      configuration.
2153  *
2154  *      LOCKING:
2155  *      Inherited from caller.
2156  *
2157  *      RETURNS:
2158  *      1 if SATA spd configuration is needed, 0 otherwise.
2159  */
2160 int sata_set_spd_needed(struct ata_port *ap)
2161 {
2162         u32 scontrol;
2163
2164         if (sata_scr_read(ap, SCR_CONTROL, &scontrol))
2165                 return 0;
2166
2167         return __sata_set_spd_needed(ap, &scontrol);
2168 }
2169
2170 /**
2171  *      sata_set_spd - set SATA spd according to spd limit
2172  *      @ap: Port to set SATA spd for
2173  *
2174  *      Set SATA spd of @ap according to sata_spd_limit.
2175  *
2176  *      LOCKING:
2177  *      Inherited from caller.
2178  *
2179  *      RETURNS:
2180  *      0 if spd doesn't need to be changed, 1 if spd has been
2181  *      changed.  Negative errno if SCR registers are inaccessible.
2182  */
2183 int sata_set_spd(struct ata_port *ap)
2184 {
2185         u32 scontrol;
2186         int rc;
2187
2188         if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2189                 return rc;
2190
2191         if (!__sata_set_spd_needed(ap, &scontrol))
2192                 return 0;
2193
2194         if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
2195                 return rc;
2196
2197         return 1;
2198 }
2199
2200 /*
2201  * This mode timing computation functionality is ported over from
2202  * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
2203  */
2204 /*
2205  * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
2206  * These were taken from ATA/ATAPI-6 standard, rev 0a, except
2207  * for UDMA6, which is currently supported only by Maxtor drives.
2208  *
2209  * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0.
2210  */
2211
2212 static const struct ata_timing ata_timing[] = {
2213
2214         { XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
2215         { XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
2216         { XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
2217         { XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },
2218
2219         { XFER_MW_DMA_4,  25,   0,   0,   0,  55,  20,  80,   0 },
2220         { XFER_MW_DMA_3,  25,   0,   0,   0,  65,  25, 100,   0 },
2221         { XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
2222         { XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
2223         { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
2224
2225 /*      { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
2226
2227         { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
2228         { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
2229         { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
2230
2231         { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
2232         { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
2233         { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
2234
2235         { XFER_PIO_6,     10,  55,  20,  80,  55,  20,  80,   0 },
2236         { XFER_PIO_5,     15,  65,  25, 100,  65,  25, 100,   0 },
2237         { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
2238         { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },
2239
2240         { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
2241         { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
2242         { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },
2243
2244 /*      { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */
2245
2246         { 0xFF }
2247 };
2248
2249 #define ENOUGH(v,unit)          (((v)-1)/(unit)+1)
2250 #define EZ(v,unit)              ((v)?ENOUGH(v,unit):0)
2251
2252 static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
2253 {
2254         q->setup   = EZ(t->setup   * 1000,  T);
2255         q->act8b   = EZ(t->act8b   * 1000,  T);
2256         q->rec8b   = EZ(t->rec8b   * 1000,  T);
2257         q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
2258         q->active  = EZ(t->active  * 1000,  T);
2259         q->recover = EZ(t->recover * 1000,  T);
2260         q->cycle   = EZ(t->cycle   * 1000,  T);
2261         q->udma    = EZ(t->udma    * 1000, UT);
2262 }
2263
2264 void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
2265                       struct ata_timing *m, unsigned int what)
2266 {
2267         if (what & ATA_TIMING_SETUP  ) m->setup   = max(a->setup,   b->setup);
2268         if (what & ATA_TIMING_ACT8B  ) m->act8b   = max(a->act8b,   b->act8b);
2269         if (what & ATA_TIMING_REC8B  ) m->rec8b   = max(a->rec8b,   b->rec8b);
2270         if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
2271         if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
2272         if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
2273         if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
2274         if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
2275 }
2276
2277 static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
2278 {
2279         const struct ata_timing *t;
2280
2281         for (t = ata_timing; t->mode != speed; t++)
2282                 if (t->mode == 0xFF)
2283                         return NULL;
2284         return t;
2285 }
2286
2287 int ata_timing_compute(struct ata_device *adev, unsigned short speed,
2288                        struct ata_timing *t, int T, int UT)
2289 {
2290         const struct ata_timing *s;
2291         struct ata_timing p;
2292
2293         /*
2294          * Find the mode.
2295          */
2296
2297         if (!(s = ata_timing_find_mode(speed)))
2298                 return -EINVAL;
2299
2300         memcpy(t, s, sizeof(*s));
2301
2302         /*
2303          * If the drive is an EIDE drive, it can tell us it needs extended
2304          * PIO/MW_DMA cycle timing.
2305          */
2306
2307         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
2308                 memset(&p, 0, sizeof(p));
2309                 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
2310                         if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
2311                                             else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
2312                 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
2313                         p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
2314                 }
2315                 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
2316         }
2317
2318         /*
2319          * Convert the timing to bus clock counts.
2320          */
2321
2322         ata_timing_quantize(t, t, T, UT);
2323
2324         /*
2325          * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
2326          * S.M.A.R.T * and some other commands. We have to ensure that the
2327          * DMA cycle timing is slower/equal than the fastest PIO timing.
2328          */
2329
2330         if (speed > XFER_PIO_6) {
2331                 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
2332                 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
2333         }
2334
2335         /*
2336          * Lengthen active & recovery time so that cycle time is correct.
2337          */
2338
2339         if (t->act8b + t->rec8b < t->cyc8b) {
2340                 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
2341                 t->rec8b = t->cyc8b - t->act8b;
2342         }
2343
2344         if (t->active + t->recover < t->cycle) {
2345                 t->active += (t->cycle - (t->active + t->recover)) / 2;
2346                 t->recover = t->cycle - t->active;
2347         }
2348
2349         return 0;
2350 }
2351
2352 /**
2353  *      ata_down_xfermask_limit - adjust dev xfer masks downward
2354  *      @dev: Device to adjust xfer masks
2355  *      @sel: ATA_DNXFER_* selector
2356  *
2357  *      Adjust xfer masks of @dev downward.  Note that this function
2358  *      does not apply the change.  Invoking ata_set_mode() afterwards
2359  *      will apply the limit.
2360  *
2361  *      LOCKING:
2362  *      Inherited from caller.
2363  *
2364  *      RETURNS:
2365  *      0 on success, negative errno on failure
2366  */
2367 int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
2368 {
2369         char buf[32];
2370         unsigned int orig_mask, xfer_mask;
2371         unsigned int pio_mask, mwdma_mask, udma_mask;
2372         int quiet, highbit;
2373
2374         quiet = !!(sel & ATA_DNXFER_QUIET);
2375         sel &= ~ATA_DNXFER_QUIET;
2376
2377         xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
2378                                                   dev->mwdma_mask,
2379                                                   dev->udma_mask);
2380         ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
2381
2382         switch (sel) {
2383         case ATA_DNXFER_PIO:
2384                 highbit = fls(pio_mask) - 1;
2385                 pio_mask &= ~(1 << highbit);
2386                 break;
2387
2388         case ATA_DNXFER_DMA:
2389                 if (udma_mask) {
2390                         highbit = fls(udma_mask) - 1;
2391                         udma_mask &= ~(1 << highbit);
2392                         if (!udma_mask)
2393                                 return -ENOENT;
2394                 } else if (mwdma_mask) {
2395                         highbit = fls(mwdma_mask) - 1;
2396                         mwdma_mask &= ~(1 << highbit);
2397                         if (!mwdma_mask)
2398                                 return -ENOENT;
2399                 }
2400                 break;
2401
2402         case ATA_DNXFER_40C:
2403                 udma_mask &= ATA_UDMA_MASK_40C;
2404                 break;
2405
2406         case ATA_DNXFER_FORCE_PIO0:
2407                 pio_mask &= 1;
2408         case ATA_DNXFER_FORCE_PIO:
2409                 mwdma_mask = 0;
2410                 udma_mask = 0;
2411                 break;
2412
2413         default:
2414                 BUG();
2415         }
2416
2417         xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
2418
2419         if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
2420                 return -ENOENT;
2421
2422         if (!quiet) {
2423                 if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
2424                         snprintf(buf, sizeof(buf), "%s:%s",
2425                                  ata_mode_string(xfer_mask),
2426                                  ata_mode_string(xfer_mask & ATA_MASK_PIO));
2427                 else
2428                         snprintf(buf, sizeof(buf), "%s",
2429                                  ata_mode_string(xfer_mask));
2430
2431                 ata_dev_printk(dev, KERN_WARNING,
2432                                "limiting speed to %s\n", buf);
2433         }
2434
2435         ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
2436                             &dev->udma_mask);
2437
2438         return 0;
2439 }
2440
2441 static int ata_dev_set_mode(struct ata_device *dev)
2442 {
2443         struct ata_eh_context *ehc = &dev->ap->eh_context;
2444         unsigned int err_mask;
2445         int rc;
2446
2447         dev->flags &= ~ATA_DFLAG_PIO;
2448         if (dev->xfer_shift == ATA_SHIFT_PIO)
2449                 dev->flags |= ATA_DFLAG_PIO;
2450
2451         err_mask = ata_dev_set_xfermode(dev);
2452         /* Old CFA may refuse this command, which is just fine */
2453         if (dev->xfer_shift == ATA_SHIFT_PIO && ata_id_is_cfa(dev->id))
2454                 err_mask &= ~AC_ERR_DEV;
2455
2456         if (err_mask) {
2457                 ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
2458                                "(err_mask=0x%x)\n", err_mask);
2459                 return -EIO;
2460         }
2461
2462         ehc->i.flags |= ATA_EHI_POST_SETMODE;
2463         rc = ata_dev_revalidate(dev, 0);
2464         ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
2465         if (rc)
2466                 return rc;
2467
2468         DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
2469                 dev->xfer_shift, (int)dev->xfer_mode);
2470
2471         ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
2472                        ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
2473         return 0;
2474 }
2475
2476 /**
2477  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
2478  *      @ap: port on which timings will be programmed
2479  *      @r_failed_dev: out paramter for failed device
2480  *
2481  *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
2482  *      ata_set_mode() fails, pointer to the failing device is
2483  *      returned in @r_failed_dev.
2484  *
2485  *      LOCKING:
2486  *      PCI/etc. bus probe sem.
2487  *
2488  *      RETURNS:
2489  *      0 on success, negative errno otherwise
2490  */
2491 int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
2492 {
2493         struct ata_device *dev;
2494         int i, rc = 0, used_dma = 0, found = 0;
2495
2496         /* has private set_mode? */
2497         if (ap->ops->set_mode)
2498                 return ap->ops->set_mode(ap, r_failed_dev);
2499
2500         /* step 1: calculate xfer_mask */
2501         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2502                 unsigned int pio_mask, dma_mask;
2503
2504                 dev = &ap->device[i];
2505
2506                 if (!ata_dev_enabled(dev))
2507                         continue;
2508
2509                 ata_dev_xfermask(dev);
2510
2511                 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
2512                 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
2513                 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
2514                 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
2515
2516                 found = 1;
2517                 if (dev->dma_mode)
2518                         used_dma = 1;
2519         }
2520         if (!found)
2521                 goto out;
2522
2523         /* step 2: always set host PIO timings */
2524         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2525                 dev = &ap->device[i];
2526                 if (!ata_dev_enabled(dev))
2527                         continue;
2528
2529                 if (!dev->pio_mode) {
2530                         ata_dev_printk(dev, KERN_WARNING, "no PIO support\n");
2531                         rc = -EINVAL;
2532                         goto out;
2533                 }
2534
2535                 dev->xfer_mode = dev->pio_mode;
2536                 dev->xfer_shift = ATA_SHIFT_PIO;
2537                 if (ap->ops->set_piomode)
2538                         ap->ops->set_piomode(ap, dev);
2539         }
2540
2541         /* step 3: set host DMA timings */
2542         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2543                 dev = &ap->device[i];
2544
2545                 if (!ata_dev_enabled(dev) || !dev->dma_mode)
2546                         continue;
2547
2548                 dev->xfer_mode = dev->dma_mode;
2549                 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
2550                 if (ap->ops->set_dmamode)
2551                         ap->ops->set_dmamode(ap, dev);
2552         }
2553
2554         /* step 4: update devices' xfer mode */
2555         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2556                 dev = &ap->device[i];
2557
2558                 /* don't update suspended devices' xfer mode */
2559                 if (!ata_dev_ready(dev))
2560                         continue;
2561
2562                 rc = ata_dev_set_mode(dev);
2563                 if (rc)
2564                         goto out;
2565         }
2566
2567         /* Record simplex status. If we selected DMA then the other
2568          * host channels are not permitted to do so.
2569          */
2570         if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
2571                 ap->host->simplex_claimed = ap;
2572
2573         /* step5: chip specific finalisation */
2574         if (ap->ops->post_set_mode)
2575                 ap->ops->post_set_mode(ap);
2576  out:
2577         if (rc)
2578                 *r_failed_dev = dev;
2579         return rc;
2580 }
2581
2582 /**
2583  *      ata_tf_to_host - issue ATA taskfile to host controller
2584  *      @ap: port to which command is being issued
2585  *      @tf: ATA taskfile register set
2586  *
2587  *      Issues ATA taskfile register set to ATA host controller,
2588  *      with proper synchronization with interrupt handler and
2589  *      other threads.
2590  *
2591  *      LOCKING:
2592  *      spin_lock_irqsave(host lock)
2593  */
2594
2595 static inline void ata_tf_to_host(struct ata_port *ap,
2596                                   const struct ata_taskfile *tf)
2597 {
2598         ap->ops->tf_load(ap, tf);
2599         ap->ops->exec_command(ap, tf);
2600 }
2601
2602 /**
2603  *      ata_busy_sleep - sleep until BSY clears, or timeout
2604  *      @ap: port containing status register to be polled
2605  *      @tmout_pat: impatience timeout
2606  *      @tmout: overall timeout
2607  *
2608  *      Sleep until ATA Status register bit BSY clears,
2609  *      or a timeout occurs.
2610  *
2611  *      LOCKING:
2612  *      Kernel thread context (may sleep).
2613  *
2614  *      RETURNS:
2615  *      0 on success, -errno otherwise.
2616  */
2617 int ata_busy_sleep(struct ata_port *ap,
2618                    unsigned long tmout_pat, unsigned long tmout)
2619 {
2620         unsigned long timer_start, timeout;
2621         u8 status;
2622
2623         status = ata_busy_wait(ap, ATA_BUSY, 300);
2624         timer_start = jiffies;
2625         timeout = timer_start + tmout_pat;
2626         while (status != 0xff && (status & ATA_BUSY) &&
2627                time_before(jiffies, timeout)) {
2628                 msleep(50);
2629                 status = ata_busy_wait(ap, ATA_BUSY, 3);
2630         }
2631
2632         if (status != 0xff && (status & ATA_BUSY))
2633                 ata_port_printk(ap, KERN_WARNING,
2634                                 "port is slow to respond, please be patient "
2635                                 "(Status 0x%x)\n", status);
2636
2637         timeout = timer_start + tmout;
2638         while (status != 0xff && (status & ATA_BUSY) &&
2639                time_before(jiffies, timeout)) {
2640                 msleep(50);
2641                 status = ata_chk_status(ap);
2642         }
2643
2644         if (status == 0xff)
2645                 return -ENODEV;
2646
2647         if (status & ATA_BUSY) {
2648                 ata_port_printk(ap, KERN_ERR, "port failed to respond "
2649                                 "(%lu secs, Status 0x%x)\n",
2650                                 tmout / HZ, status);
2651                 return -EBUSY;
2652         }
2653
2654         return 0;
2655 }
2656
2657 static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
2658 {
2659         struct ata_ioports *ioaddr = &ap->ioaddr;
2660         unsigned int dev0 = devmask & (1 << 0);
2661         unsigned int dev1 = devmask & (1 << 1);
2662         unsigned long timeout;
2663
2664         /* if device 0 was found in ata_devchk, wait for its
2665          * BSY bit to clear
2666          */
2667         if (dev0)
2668                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2669
2670         /* if device 1 was found in ata_devchk, wait for
2671          * register access, then wait for BSY to clear
2672          */
2673         timeout = jiffies + ATA_TMOUT_BOOT;
2674         while (dev1) {
2675                 u8 nsect, lbal;
2676
2677                 ap->ops->dev_select(ap, 1);
2678                 nsect = ioread8(ioaddr->nsect_addr);
2679                 lbal = ioread8(ioaddr->lbal_addr);
2680                 if ((nsect == 1) && (lbal == 1))
2681                         break;
2682                 if (time_after(jiffies, timeout)) {
2683                         dev1 = 0;
2684                         break;
2685                 }
2686                 msleep(50);     /* give drive a breather */
2687         }
2688         if (dev1)
2689                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2690
2691         /* is all this really necessary? */
2692         ap->ops->dev_select(ap, 0);
2693         if (dev1)
2694                 ap->ops->dev_select(ap, 1);
2695         if (dev0)
2696                 ap->ops->dev_select(ap, 0);
2697 }
2698
2699 static unsigned int ata_bus_softreset(struct ata_port *ap,
2700                                       unsigned int devmask)
2701 {
2702         struct ata_ioports *ioaddr = &ap->ioaddr;
2703
2704         DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
2705
2706         /* software reset.  causes dev0 to be selected */
2707         iowrite8(ap->ctl, ioaddr->ctl_addr);
2708         udelay(20);     /* FIXME: flush */
2709         iowrite8(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2710         udelay(20);     /* FIXME: flush */
2711         iowrite8(ap->ctl, ioaddr->ctl_addr);
2712
2713         /* spec mandates ">= 2ms" before checking status.
2714          * We wait 150ms, because that was the magic delay used for
2715          * ATAPI devices in Hale Landis's ATADRVR, for the period of time
2716          * between when the ATA command register is written, and then
2717          * status is checked.  Because waiting for "a while" before
2718          * checking status is fine, post SRST, we perform this magic
2719          * delay here as well.
2720          *
2721          * Old drivers/ide uses the 2mS rule and then waits for ready
2722          */
2723         msleep(150);
2724
2725         /* Before we perform post reset processing we want to see if
2726          * the bus shows 0xFF because the odd clown forgets the D7
2727          * pulldown resistor.
2728          */
2729         if (ata_check_status(ap) == 0xFF)
2730                 return 0;
2731
2732         ata_bus_post_reset(ap, devmask);
2733
2734         return 0;
2735 }
2736
2737 /**
2738  *      ata_bus_reset - reset host port and associated ATA channel
2739  *      @ap: port to reset
2740  *
2741  *      This is typically the first time we actually start issuing
2742  *      commands to the ATA channel.  We wait for BSY to clear, then
2743  *      issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
2744  *      result.  Determine what devices, if any, are on the channel
2745  *      by looking at the device 0/1 error register.  Look at the signature
2746  *      stored in each device's taskfile registers, to determine if
2747  *      the device is ATA or ATAPI.
2748  *
2749  *      LOCKING:
2750  *      PCI/etc. bus probe sem.
2751  *      Obtains host lock.
2752  *
2753  *      SIDE EFFECTS:
2754  *      Sets ATA_FLAG_DISABLED if bus reset fails.
2755  */
2756
2757 void ata_bus_reset(struct ata_port *ap)
2758 {
2759         struct ata_ioports *ioaddr = &ap->ioaddr;
2760         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2761         u8 err;
2762         unsigned int dev0, dev1 = 0, devmask = 0;
2763
2764         DPRINTK("ENTER, host %u, port %u\n", ap->print_id, ap->port_no);
2765
2766         /* determine if device 0/1 are present */
2767         if (ap->flags & ATA_FLAG_SATA_RESET)
2768                 dev0 = 1;
2769         else {
2770                 dev0 = ata_devchk(ap, 0);
2771                 if (slave_possible)
2772                         dev1 = ata_devchk(ap, 1);
2773         }
2774
2775         if (dev0)
2776                 devmask |= (1 << 0);
2777         if (dev1)
2778                 devmask |= (1 << 1);
2779
2780         /* select device 0 again */
2781         ap->ops->dev_select(ap, 0);
2782
2783         /* issue bus reset */
2784         if (ap->flags & ATA_FLAG_SRST)
2785                 if (ata_bus_softreset(ap, devmask))
2786                         goto err_out;
2787
2788         /*
2789          * determine by signature whether we have ATA or ATAPI devices
2790          */
2791         ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
2792         if ((slave_possible) && (err != 0x81))
2793                 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
2794
2795         /* re-enable interrupts */
2796         ap->ops->irq_on(ap);
2797
2798         /* is double-select really necessary? */
2799         if (ap->device[1].class != ATA_DEV_NONE)
2800                 ap->ops->dev_select(ap, 1);
2801         if (ap->device[0].class != ATA_DEV_NONE)
2802                 ap->ops->dev_select(ap, 0);
2803
2804         /* if no devices were detected, disable this port */
2805         if ((ap->device[0].class == ATA_DEV_NONE) &&
2806             (ap->device[1].class == ATA_DEV_NONE))
2807                 goto err_out;
2808
2809         if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2810                 /* set up device control for ATA_FLAG_SATA_RESET */
2811                 iowrite8(ap->ctl, ioaddr->ctl_addr);
2812         }
2813
2814         DPRINTK("EXIT\n");
2815         return;
2816
2817 err_out:
2818         ata_port_printk(ap, KERN_ERR, "disabling port\n");
2819         ap->ops->port_disable(ap);
2820
2821         DPRINTK("EXIT\n");
2822 }
2823
2824 /**
2825  *      sata_phy_debounce - debounce SATA phy status
2826  *      @ap: ATA port to debounce SATA phy status for
2827  *      @params: timing parameters { interval, duratinon, timeout } in msec
2828  *
2829  *      Make sure SStatus of @ap reaches stable state, determined by
2830  *      holding the same value where DET is not 1 for @duration polled
2831  *      every @interval, before @timeout.  Timeout constraints the
2832  *      beginning of the stable state.  Because, after hot unplugging,
2833  *      DET gets stuck at 1 on some controllers, this functions waits
2834  *      until timeout then returns 0 if DET is stable at 1.
2835  *
2836  *      LOCKING:
2837  *      Kernel thread context (may sleep)
2838  *
2839  *      RETURNS:
2840  *      0 on success, -errno on failure.
2841  */
2842 int sata_phy_debounce(struct ata_port *ap, const unsigned long *params)
2843 {
2844         unsigned long interval_msec = params[0];
2845         unsigned long duration = params[1] * HZ / 1000;
2846         unsigned long timeout = jiffies + params[2] * HZ / 1000;
2847         unsigned long last_jiffies;
2848         u32 last, cur;
2849         int rc;
2850
2851         if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
2852                 return rc;
2853         cur &= 0xf;
2854
2855         last = cur;
2856         last_jiffies = jiffies;
2857
2858         while (1) {
2859                 msleep(interval_msec);
2860                 if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
2861                         return rc;
2862                 cur &= 0xf;
2863
2864                 /* DET stable? */
2865                 if (cur == last) {
2866                         if (cur == 1 && time_before(jiffies, timeout))
2867                                 continue;
2868                         if (time_after(jiffies, last_jiffies + duration))
2869                                 return 0;
2870                         continue;
2871                 }
2872
2873                 /* unstable, start over */
2874                 last = cur;
2875                 last_jiffies = jiffies;
2876
2877                 /* check timeout */
2878                 if (time_after(jiffies, timeout))
2879                         return -EBUSY;
2880         }
2881 }
2882
2883 /**
2884  *      sata_phy_resume - resume SATA phy
2885  *      @ap: ATA port to resume SATA phy for
2886  *      @params: timing parameters { interval, duratinon, timeout } in msec
2887  *
2888  *      Resume SATA phy of @ap and debounce it.
2889  *
2890  *      LOCKING:
2891  *      Kernel thread context (may sleep)
2892  *
2893  *      RETURNS:
2894  *      0 on success, -errno on failure.
2895  */
2896 int sata_phy_resume(struct ata_port *ap, const unsigned long *params)
2897 {
2898         u32 scontrol;
2899         int rc;
2900
2901         if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2902                 return rc;
2903
2904         scontrol = (scontrol & 0x0f0) | 0x300;
2905
2906         if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
2907                 return rc;
2908
2909         /* Some PHYs react badly if SStatus is pounded immediately
2910          * after resuming.  Delay 200ms before debouncing.
2911          */
2912         msleep(200);
2913
2914         return sata_phy_debounce(ap, params);
2915 }
2916
2917 static void ata_wait_spinup(struct ata_port *ap)
2918 {
2919         struct ata_eh_context *ehc = &ap->eh_context;
2920         unsigned long end, secs;
2921         int rc;
2922
2923         /* first, debounce phy if SATA */
2924         if (ap->cbl == ATA_CBL_SATA) {
2925                 rc = sata_phy_debounce(ap, sata_deb_timing_hotplug);
2926
2927                 /* if debounced successfully and offline, no need to wait */
2928                 if ((rc == 0 || rc == -EOPNOTSUPP) && ata_port_offline(ap))
2929                         return;
2930         }
2931
2932         /* okay, let's give the drive time to spin up */
2933         end = ehc->i.hotplug_timestamp + ATA_SPINUP_WAIT * HZ / 1000;
2934         secs = ((end - jiffies) + HZ - 1) / HZ;
2935
2936         if (time_after(jiffies, end))
2937                 return;
2938
2939         if (secs > 5)
2940                 ata_port_printk(ap, KERN_INFO, "waiting for device to spin up "
2941                                 "(%lu secs)\n", secs);
2942
2943         schedule_timeout_uninterruptible(end - jiffies);
2944 }
2945
2946 /**
2947  *      ata_std_prereset - prepare for reset
2948  *      @ap: ATA port to be reset
2949  *
2950  *      @ap is about to be reset.  Initialize it.
2951  *
2952  *      LOCKING:
2953  *      Kernel thread context (may sleep)
2954  *
2955  *      RETURNS:
2956  *      0 on success, -errno otherwise.
2957  */
2958 int ata_std_prereset(struct ata_port *ap)
2959 {
2960         struct ata_eh_context *ehc = &ap->eh_context;
2961         const unsigned long *timing = sata_ehc_deb_timing(ehc);
2962         int rc;
2963
2964         /* handle link resume & hotplug spinup */
2965         if ((ehc->i.flags & ATA_EHI_RESUME_LINK) &&
2966             (ap->flags & ATA_FLAG_HRST_TO_RESUME))
2967                 ehc->i.action |= ATA_EH_HARDRESET;
2968
2969         if ((ehc->i.flags & ATA_EHI_HOTPLUGGED) &&
2970             (ap->flags & ATA_FLAG_SKIP_D2H_BSY))
2971                 ata_wait_spinup(ap);
2972
2973         /* if we're about to do hardreset, nothing more to do */
2974         if (ehc->i.action & ATA_EH_HARDRESET)
2975                 return 0;
2976
2977         /* if SATA, resume phy */
2978         if (ap->cbl == ATA_CBL_SATA) {
2979                 rc = sata_phy_resume(ap, timing);
2980                 if (rc && rc != -EOPNOTSUPP) {
2981                         /* phy resume failed */
2982                         ata_port_printk(ap, KERN_WARNING, "failed to resume "
2983                                         "link for reset (errno=%d)\n", rc);
2984                         return rc;
2985                 }
2986         }
2987
2988         /* Wait for !BSY if the controller can wait for the first D2H
2989          * Reg FIS and we don't know that no device is attached.
2990          */
2991         if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_port_offline(ap))
2992                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2993
2994         return 0;
2995 }
2996
2997 /**
2998  *      ata_std_softreset - reset host port via ATA SRST
2999  *      @ap: port to reset
3000  *      @classes: resulting classes of attached devices
3001  *
3002  *      Reset host port using ATA SRST.
3003  *
3004  *      LOCKING:
3005  *      Kernel thread context (may sleep)
3006  *
3007  *      RETURNS:
3008  *      0 on success, -errno otherwise.
3009  */
3010 int ata_std_softreset(struct ata_port *ap, unsigned int *classes)
3011 {
3012         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
3013         unsigned int devmask = 0, err_mask;
3014         u8 err;
3015
3016         DPRINTK("ENTER\n");
3017
3018         if (ata_port_offline(ap)) {
3019                 classes[0] = ATA_DEV_NONE;
3020                 goto out;
3021         }
3022
3023         /* determine if device 0/1 are present */
3024         if (ata_devchk(ap, 0))
3025                 devmask |= (1 << 0);
3026         if (slave_possible && ata_devchk(ap, 1))
3027                 devmask |= (1 << 1);
3028
3029         /* select device 0 again */
3030         ap->ops->dev_select(ap, 0);
3031
3032         /* issue bus reset */
3033         DPRINTK("about to softreset, devmask=%x\n", devmask);
3034         err_mask = ata_bus_softreset(ap, devmask);
3035         if (err_mask) {
3036                 ata_port_printk(ap, KERN_ERR, "SRST failed (err_mask=0x%x)\n",
3037                                 err_mask);
3038                 return -EIO;
3039         }
3040
3041         /* determine by signature whether we have ATA or ATAPI devices */
3042         classes[0] = ata_dev_try_classify(ap, 0, &err);
3043         if (slave_possible && err != 0x81)
3044                 classes[1] = ata_dev_try_classify(ap, 1, &err);
3045
3046  out:
3047         DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
3048         return 0;
3049 }
3050
3051 /**
3052  *      sata_port_hardreset - reset port via SATA phy reset
3053  *      @ap: port to reset
3054  *      @timing: timing parameters { interval, duratinon, timeout } in msec
3055  *
3056  *      SATA phy-reset host port using DET bits of SControl register.
3057  *
3058  *      LOCKING:
3059  *      Kernel thread context (may sleep)
3060  *
3061  *      RETURNS:
3062  *      0 on success, -errno otherwise.
3063  */
3064 int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing)
3065 {
3066         u32 scontrol;
3067         int rc;
3068
3069         DPRINTK("ENTER\n");
3070
3071         if (sata_set_spd_needed(ap)) {
3072                 /* SATA spec says nothing about how to reconfigure
3073                  * spd.  To be on the safe side, turn off phy during
3074                  * reconfiguration.  This works for at least ICH7 AHCI
3075                  * and Sil3124.
3076                  */
3077                 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
3078                         goto out;
3079
3080                 scontrol = (scontrol & 0x0f0) | 0x304;
3081
3082                 if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
3083                         goto out;
3084
3085                 sata_set_spd(ap);
3086         }
3087
3088         /* issue phy wake/reset */
3089         if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
3090                 goto out;
3091
3092         scontrol = (scontrol & 0x0f0) | 0x301;
3093
3094         if ((rc = sata_scr_write_flush(ap, SCR_CONTROL, scontrol)))
3095                 goto out;
3096
3097         /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
3098          * 10.4.2 says at least 1 ms.
3099          */
3100         msleep(1);
3101
3102         /* bring phy back */
3103         rc = sata_phy_resume(ap, timing);
3104  out:
3105         DPRINTK("EXIT, rc=%d\n", rc);
3106         return rc;
3107 }
3108
3109 /**
3110  *      sata_std_hardreset - reset host port via SATA phy reset
3111  *      @ap: port to reset
3112  *      @class: resulting class of attached device
3113  *
3114  *      SATA phy-reset host port using DET bits of SControl register,
3115  *      wait for !BSY and classify the attached device.
3116  *
3117  *      LOCKING:
3118  *      Kernel thread context (may sleep)
3119  *
3120  *      RETURNS:
3121  *      0 on success, -errno otherwise.
3122  */
3123 int sata_std_hardreset(struct ata_port *ap, unsigned int *class)
3124 {
3125         const unsigned long *timing = sata_ehc_deb_timing(&ap->eh_context);
3126         int rc;
3127
3128         DPRINTK("ENTER\n");
3129
3130         /* do hardreset */
3131         rc = sata_port_hardreset(ap, timing);
3132         if (rc) {
3133                 ata_port_printk(ap, KERN_ERR,
3134                                 "COMRESET failed (errno=%d)\n", rc);
3135                 return rc;
3136         }
3137
3138         /* TODO: phy layer with polling, timeouts, etc. */
3139         if (ata_port_offline(ap)) {
3140                 *class = ATA_DEV_NONE;
3141                 DPRINTK("EXIT, link offline\n");
3142                 return 0;
3143         }
3144
3145         /* wait a while before checking status, see SRST for more info */
3146         msleep(150);
3147
3148         if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
3149                 ata_port_printk(ap, KERN_ERR,
3150                                 "COMRESET failed (device not ready)\n");
3151                 return -EIO;
3152         }
3153
3154         ap->ops->dev_select(ap, 0);     /* probably unnecessary */
3155
3156         *class = ata_dev_try_classify(ap, 0, NULL);
3157
3158         DPRINTK("EXIT, class=%u\n", *class);
3159         return 0;
3160 }
3161
3162 /**
3163  *      ata_std_postreset - standard postreset callback
3164  *      @ap: the target ata_port
3165  *      @classes: classes of attached devices
3166  *
3167  *      This function is invoked after a successful reset.  Note that
3168  *      the device might have been reset more than once using
3169  *      different reset methods before postreset is invoked.
3170  *
3171  *      LOCKING:
3172  *      Kernel thread context (may sleep)
3173  */
3174 void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
3175 {
3176         u32 serror;
3177
3178         DPRINTK("ENTER\n");
3179
3180         /* print link status */
3181         sata_print_link_status(ap);
3182
3183         /* clear SError */
3184         if (sata_scr_read(ap, SCR_ERROR, &serror) == 0)
3185                 sata_scr_write(ap, SCR_ERROR, serror);
3186
3187         /* re-enable interrupts */
3188         if (!ap->ops->error_handler)
3189                 ap->ops->irq_on(ap);
3190
3191         /* is double-select really necessary? */
3192         if (classes[0] != ATA_DEV_NONE)
3193                 ap->ops->dev_select(ap, 1);
3194         if (classes[1] != ATA_DEV_NONE)
3195                 ap->ops->dev_select(ap, 0);
3196
3197         /* bail out if no device is present */
3198         if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
3199                 DPRINTK("EXIT, no device\n");
3200                 return;
3201         }
3202
3203         /* set up device control */
3204         if (ap->ioaddr.ctl_addr)
3205                 iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
3206
3207         DPRINTK("EXIT\n");
3208 }
3209
3210 /**
3211  *      ata_dev_same_device - Determine whether new ID matches configured device
3212  *      @dev: device to compare against
3213  *      @new_class: class of the new device
3214  *      @new_id: IDENTIFY page of the new device
3215  *
3216  *      Compare @new_class and @new_id against @dev and determine
3217  *      whether @dev is the device indicated by @new_class and
3218  *      @new_id.
3219  *
3220  *      LOCKING:
3221  *      None.
3222  *
3223  *      RETURNS:
3224  *      1 if @dev matches @new_class and @new_id, 0 otherwise.
3225  */
3226 static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
3227                                const u16 *new_id)
3228 {
3229         const u16 *old_id = dev->id;
3230         unsigned char model[2][ATA_ID_PROD_LEN + 1];
3231         unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
3232         u64 new_n_sectors;
3233
3234         if (dev->class != new_class) {
3235                 ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n",
3236                                dev->class, new_class);
3237                 return 0;
3238         }
3239
3240         ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
3241         ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
3242         ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
3243         ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
3244         new_n_sectors = ata_id_n_sectors(new_id);
3245
3246         if (strcmp(model[0], model[1])) {
3247                 ata_dev_printk(dev, KERN_INFO, "model number mismatch "
3248                                "'%s' != '%s'\n", model[0], model[1]);
3249                 return 0;
3250         }
3251
3252         if (strcmp(serial[0], serial[1])) {
3253                 ata_dev_printk(dev, KERN_INFO, "serial number mismatch "
3254                                "'%s' != '%s'\n", serial[0], serial[1]);
3255                 return 0;
3256         }
3257
3258         if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
3259                 ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch "
3260                                "%llu != %llu\n",
3261                                (unsigned long long)dev->n_sectors,
3262                                (unsigned long long)new_n_sectors);
3263                 return 0;
3264         }
3265
3266         return 1;
3267 }
3268
3269 /**
3270  *      ata_dev_revalidate - Revalidate ATA device
3271  *      @dev: device to revalidate
3272  *      @readid_flags: read ID flags
3273  *
3274  *      Re-read IDENTIFY page and make sure @dev is still attached to
3275  *      the port.
3276  *
3277  *      LOCKING:
3278  *      Kernel thread context (may sleep)
3279  *
3280  *      RETURNS:
3281  *      0 on success, negative errno otherwise
3282  */
3283 int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags)
3284 {
3285         unsigned int class = dev->class;
3286         u16 *id = (void *)dev->ap->sector_buf;
3287         int rc;
3288
3289         if (!ata_dev_enabled(dev)) {
3290                 rc = -ENODEV;
3291                 goto fail;
3292         }
3293
3294         /* read ID data */
3295         rc = ata_dev_read_id(dev, &class, readid_flags, id);
3296         if (rc)
3297                 goto fail;
3298
3299         /* is the device still there? */
3300         if (!ata_dev_same_device(dev, class, id)) {
3301                 rc = -ENODEV;
3302                 goto fail;
3303         }
3304
3305         memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
3306
3307         /* configure device according to the new ID */
3308         rc = ata_dev_configure(dev);
3309         if (rc == 0)
3310                 return 0;
3311
3312  fail:
3313         ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc);
3314         return rc;
3315 }
3316
3317 struct ata_blacklist_entry {
3318         const char *model_num;
3319         const char *model_rev;
3320         unsigned long horkage;
3321 };
3322
3323 static const struct ata_blacklist_entry ata_device_blacklist [] = {
3324         /* Devices with DMA related problems under Linux */
3325         { "WDC AC11000H",       NULL,           ATA_HORKAGE_NODMA },
3326         { "WDC AC22100H",       NULL,           ATA_HORKAGE_NODMA },
3327         { "WDC AC32500H",       NULL,           ATA_HORKAGE_NODMA },
3328         { "WDC AC33100H",       NULL,           ATA_HORKAGE_NODMA },
3329         { "WDC AC31600H",       NULL,           ATA_HORKAGE_NODMA },
3330         { "WDC AC32100H",       "24.09P07",     ATA_HORKAGE_NODMA },
3331         { "WDC AC23200L",       "21.10N21",     ATA_HORKAGE_NODMA },
3332         { "Compaq CRD-8241B",   NULL,           ATA_HORKAGE_NODMA },
3333         { "CRD-8400B",          NULL,           ATA_HORKAGE_NODMA },
3334         { "CRD-8480B",          NULL,           ATA_HORKAGE_NODMA },
3335         { "CRD-8482B",          NULL,           ATA_HORKAGE_NODMA },
3336         { "CRD-84",             NULL,           ATA_HORKAGE_NODMA },
3337         { "SanDisk SDP3B",      NULL,           ATA_HORKAGE_NODMA },
3338         { "SanDisk SDP3B-64",   NULL,           ATA_HORKAGE_NODMA },
3339         { "SANYO CD-ROM CRD",   NULL,           ATA_HORKAGE_NODMA },
3340         { "HITACHI CDR-8",      NULL,           ATA_HORKAGE_NODMA },
3341         { "HITACHI CDR-8335",   NULL,           ATA_HORKAGE_NODMA },
3342         { "HITACHI CDR-8435",   NULL,           ATA_HORKAGE_NODMA },
3343         { "Toshiba CD-ROM XM-6202B", NULL,      ATA_HORKAGE_NODMA },
3344         { "TOSHIBA CD-ROM XM-1702BC", NULL,     ATA_HORKAGE_NODMA },
3345         { "CD-532E-A",          NULL,           ATA_HORKAGE_NODMA },
3346         { "E-IDE CD-ROM CR-840",NULL,           ATA_HORKAGE_NODMA },
3347         { "CD-ROM Drive/F5A",   NULL,           ATA_HORKAGE_NODMA },
3348         { "WPI CDD-820",        NULL,           ATA_HORKAGE_NODMA },
3349         { "SAMSUNG CD-ROM SC-148C", NULL,       ATA_HORKAGE_NODMA },
3350         { "SAMSUNG CD-ROM SC",  NULL,           ATA_HORKAGE_NODMA },
3351         { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
3352         { "_NEC DV5800A",       NULL,           ATA_HORKAGE_NODMA },
3353         { "SAMSUNG CD-ROM SN-124","N001",       ATA_HORKAGE_NODMA },
3354
3355         /* Devices we expect to fail diagnostics */
3356
3357         /* Devices where NCQ should be avoided */
3358         /* NCQ is slow */
3359         { "WDC WD740ADFD-00",   NULL,           ATA_HORKAGE_NONCQ },
3360         /* http://thread.gmane.org/gmane.linux.ide/14907 */
3361         { "FUJITSU MHT2060BH",  NULL,           ATA_HORKAGE_NONCQ },
3362
3363         /* Devices with NCQ limits */
3364
3365         /* End Marker */
3366         { }
3367 };
3368
3369 unsigned long ata_device_blacklisted(const struct ata_device *dev)
3370 {
3371         unsigned char model_num[ATA_ID_PROD_LEN + 1];
3372         unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
3373         const struct ata_blacklist_entry *ad = ata_device_blacklist;
3374
3375         ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
3376         ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
3377
3378         while (ad->model_num) {
3379                 if (!strcmp(ad->model_num, model_num)) {
3380                         if (ad->model_rev == NULL)
3381                                 return ad->horkage;
3382                         if (!strcmp(ad->model_rev, model_rev))
3383                                 return ad->horkage;
3384                 }
3385                 ad++;
3386         }
3387         return 0;
3388 }
3389
3390 static int ata_dma_blacklisted(const struct ata_device *dev)
3391 {
3392         /* We don't support polling DMA.
3393          * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
3394          * if the LLDD handles only interrupts in the HSM_ST_LAST state.
3395          */
3396         if ((dev->ap->flags & ATA_FLAG_PIO_POLLING) &&
3397             (dev->flags & ATA_DFLAG_CDB_INTR))
3398                 return 1;
3399         return (ata_device_blacklisted(dev) & ATA_HORKAGE_NODMA) ? 1 : 0;
3400 }
3401
3402 /**
3403  *      ata_dev_xfermask - Compute supported xfermask of the given device
3404  *      @dev: Device to compute xfermask for
3405  *
3406  *      Compute supported xfermask of @dev and store it in
3407  *      dev->*_mask.  This function is responsible for applying all
3408  *      known limits including host controller limits, device
3409  *      blacklist, etc...
3410  *
3411  *      LOCKING:
3412  *      None.
3413  */
3414 static void ata_dev_xfermask(struct ata_device *dev)
3415 {
3416         struct ata_port *ap = dev->ap;
3417         struct ata_host *host = ap->host;
3418         unsigned long xfer_mask;
3419
3420         /* controller modes available */
3421         xfer_mask = ata_pack_xfermask(ap->pio_mask,
3422                                       ap->mwdma_mask, ap->udma_mask);
3423
3424         /* Apply cable rule here.  Don't apply it early because when
3425          * we handle hot plug the cable type can itself change.
3426          */
3427         if (ap->cbl == ATA_CBL_PATA40)
3428                 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
3429         /* Apply drive side cable rule. Unknown or 80 pin cables reported
3430          * host side are checked drive side as well. Cases where we know a
3431          * 40wire cable is used safely for 80 are not checked here.
3432          */
3433         if (ata_drive_40wire(dev->id) && (ap->cbl == ATA_CBL_PATA_UNK || ap->cbl == ATA_CBL_PATA80))
3434                 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
3435
3436
3437         xfer_mask &= ata_pack_xfermask(dev->pio_mask,
3438                                        dev->mwdma_mask, dev->udma_mask);
3439         xfer_mask &= ata_id_xfermask(dev->id);
3440
3441         /*
3442          *      CFA Advanced TrueIDE timings are not allowed on a shared
3443          *      cable
3444          */
3445         if (ata_dev_pair(dev)) {
3446                 /* No PIO5 or PIO6 */
3447                 xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
3448                 /* No MWDMA3 or MWDMA 4 */
3449                 xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
3450         }
3451
3452         if (ata_dma_blacklisted(dev)) {
3453                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
3454                 ata_dev_printk(dev, KERN_WARNING,
3455                                "device is on DMA blacklist, disabling DMA\n");
3456         }
3457
3458         if ((host->flags & ATA_HOST_SIMPLEX) &&
3459             host->simplex_claimed && host->simplex_claimed != ap) {
3460                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
3461                 ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by "
3462                                "other device, disabling DMA\n");
3463         }
3464
3465         if (ap->ops->mode_filter)
3466                 xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask);
3467
3468         ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
3469                             &dev->mwdma_mask, &dev->udma_mask);
3470 }
3471
3472 /**
3473  *      ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
3474  *      @dev: Device to which command will be sent
3475  *
3476  *      Issue SET FEATURES - XFER MODE command to device @dev
3477  *      on port @ap.
3478  *
3479  *      LOCKING:
3480  *      PCI/etc. bus probe sem.
3481  *
3482  *      RETURNS:
3483  *      0 on success, AC_ERR_* mask otherwise.
3484  */
3485
3486 static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
3487 {
3488         struct ata_taskfile tf;
3489         unsigned int err_mask;
3490
3491         /* set up set-features taskfile */
3492         DPRINTK("set features - xfer mode\n");
3493
3494         ata_tf_init(dev, &tf);
3495         tf.command = ATA_CMD_SET_FEATURES;
3496         tf.feature = SETFEATURES_XFER;
3497         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3498         tf.protocol = ATA_PROT_NODATA;
3499         tf.nsect = dev->xfer_mode;
3500
3501         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
3502
3503         DPRINTK("EXIT, err_mask=%x\n", err_mask);
3504         return err_mask;
3505 }
3506
3507 /**
3508  *      ata_dev_init_params - Issue INIT DEV PARAMS command
3509  *      @dev: Device to which command will be sent
3510  *      @heads: Number of heads (taskfile parameter)
3511  *      @sectors: Number of sectors (taskfile parameter)
3512  *
3513  *      LOCKING:
3514  *      Kernel thread context (may sleep)
3515  *
3516  *      RETURNS:
3517  *      0 on success, AC_ERR_* mask otherwise.
3518  */
3519 static unsigned int ata_dev_init_params(struct ata_device *dev,
3520                                         u16 heads, u16 sectors)
3521 {
3522         struct ata_taskfile tf;
3523         unsigned int err_mask;
3524
3525         /* Number of sectors per track 1-255. Number of heads 1-16 */
3526         if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
3527                 return AC_ERR_INVALID;
3528
3529         /* set up init dev params taskfile */
3530         DPRINTK("init dev params \n");
3531
3532         ata_tf_init(dev, &tf);
3533         tf.command = ATA_CMD_INIT_DEV_PARAMS;
3534         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3535         tf.protocol = ATA_PROT_NODATA;
3536         tf.nsect = sectors;
3537         tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
3538
3539         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
3540
3541         DPRINTK("EXIT, err_mask=%x\n", err_mask);
3542         return err_mask;
3543 }
3544
3545 /**
3546  *      ata_sg_clean - Unmap DMA memory associated with command
3547  *      @qc: Command containing DMA memory to be released
3548  *
3549  *      Unmap all mapped DMA memory associated with this command.
3550  *
3551  *      LOCKING:
3552  *      spin_lock_irqsave(host lock)
3553  */
3554 void ata_sg_clean(struct ata_queued_cmd *qc)
3555 {
3556         struct ata_port *ap = qc->ap;
3557         struct scatterlist *sg = qc->__sg;
3558         int dir = qc->dma_dir;
3559         void *pad_buf = NULL;
3560
3561         WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
3562         WARN_ON(sg == NULL);
3563
3564         if (qc->flags & ATA_QCFLAG_SINGLE)
3565                 WARN_ON(qc->n_elem > 1);
3566
3567         VPRINTK("unmapping %u sg elements\n", qc->n_elem);
3568
3569         /* if we padded the buffer out to 32-bit bound, and data
3570          * xfer direction is from-device, we must copy from the
3571          * pad buffer back into the supplied buffer
3572          */
3573         if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
3574                 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3575
3576         if (qc->flags & ATA_QCFLAG_SG) {
3577                 if (qc->n_elem)
3578                         dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
3579                 /* restore last sg */
3580                 sg[qc->orig_n_elem - 1].length += qc->pad_len;
3581                 if (pad_buf) {
3582                         struct scatterlist *psg = &qc->pad_sgent;
3583                         void *addr = kmap_atomic(psg->page, KM_IRQ0);
3584                         memcpy(addr + psg->offset, pad_buf, qc->pad_len);
3585                         kunmap_atomic(addr, KM_IRQ0);
3586                 }
3587         } else {
3588                 if (qc->n_elem)
3589                         dma_unmap_single(ap->dev,
3590                                 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
3591                                 dir);
3592                 /* restore sg */
3593                 sg->length += qc->pad_len;
3594                 if (pad_buf)
3595                         memcpy(qc->buf_virt + sg->length - qc->pad_len,
3596                                pad_buf, qc->pad_len);
3597         }
3598
3599         qc->flags &= ~ATA_QCFLAG_DMAMAP;
3600         qc->__sg = NULL;
3601 }
3602
3603 /**
3604  *      ata_fill_sg - Fill PCI IDE PRD table
3605  *      @qc: Metadata associated with taskfile to be transferred
3606  *
3607  *      Fill PCI IDE PRD (scatter-gather) table with segments
3608  *      associated with the current disk command.
3609  *
3610  *      LOCKING:
3611  *      spin_lock_irqsave(host lock)
3612  *
3613  */
3614 static void ata_fill_sg(struct ata_queued_cmd *qc)
3615 {
3616         struct ata_port *ap = qc->ap;
3617         struct scatterlist *sg;
3618         unsigned int idx;
3619
3620         WARN_ON(qc->__sg == NULL);
3621         WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
3622
3623         idx = 0;
3624         ata_for_each_sg(sg, qc) {
3625                 u32 addr, offset;
3626                 u32 sg_len, len;
3627
3628                 /* determine if physical DMA addr spans 64K boundary.
3629                  * Note h/w doesn't support 64-bit, so we unconditionally
3630                  * truncate dma_addr_t to u32.
3631                  */
3632                 addr = (u32) sg_dma_address(sg);
3633                 sg_len = sg_dma_len(sg);
3634
3635                 while (sg_len) {
3636                         offset = addr & 0xffff;
3637                         len = sg_len;
3638                         if ((offset + sg_len) > 0x10000)
3639                                 len = 0x10000 - offset;
3640
3641                         ap->prd[idx].addr = cpu_to_le32(addr);
3642                         ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
3643                         VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
3644
3645                         idx++;
3646                         sg_len -= len;
3647                         addr += len;
3648                 }
3649         }
3650
3651         if (idx)
3652                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
3653 }
3654 /**
3655  *      ata_check_atapi_dma - Check whether ATAPI DMA can be supported
3656  *      @qc: Metadata associated with taskfile to check
3657  *
3658  *      Allow low-level driver to filter ATA PACKET commands, returning
3659  *      a status indicating whether or not it is OK to use DMA for the
3660  *      supplied PACKET command.
3661  *
3662  *      LOCKING:
3663  *      spin_lock_irqsave(host lock)
3664  *
3665  *      RETURNS: 0 when ATAPI DMA can be used
3666  *               nonzero otherwise
3667  */
3668 int ata_check_atapi_dma(struct ata_queued_cmd *qc)
3669 {
3670         struct ata_port *ap = qc->ap;
3671         int rc = 0; /* Assume ATAPI DMA is OK by default */
3672
3673         if (ap->ops->check_atapi_dma)
3674                 rc = ap->ops->check_atapi_dma(qc);
3675
3676         return rc;
3677 }
3678 /**
3679  *      ata_qc_prep - Prepare taskfile for submission
3680  *      @qc: Metadata associated with taskfile to be prepared
3681  *
3682  *      Prepare ATA taskfile for submission.
3683  *
3684  *      LOCKING:
3685  *      spin_lock_irqsave(host lock)
3686  */
3687 void ata_qc_prep(struct ata_queued_cmd *qc)
3688 {
3689         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
3690                 return;
3691
3692         ata_fill_sg(qc);
3693 }
3694
3695 void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
3696
3697 /**
3698  *      ata_sg_init_one - Associate command with memory buffer
3699  *      @qc: Command to be associated
3700  *      @buf: Memory buffer
3701  *      @buflen: Length of memory buffer, in bytes.
3702  *
3703  *      Initialize the data-related elements of queued_cmd @qc
3704  *      to point to a single memory buffer, @buf of byte length @buflen.
3705  *
3706  *      LOCKING:
3707  *      spin_lock_irqsave(host lock)
3708  */
3709
3710 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
3711 {
3712         qc->flags |= ATA_QCFLAG_SINGLE;
3713
3714         qc->__sg = &qc->sgent;
3715         qc->n_elem = 1;
3716         qc->orig_n_elem = 1;
3717         qc->buf_virt = buf;
3718         qc->nbytes = buflen;
3719
3720         sg_init_one(&qc->sgent, buf, buflen);
3721 }
3722
3723 /**
3724  *      ata_sg_init - Associate command with scatter-gather table.
3725  *      @qc: Command to be associated
3726  *      @sg: Scatter-gather table.
3727  *      @n_elem: Number of elements in s/g table.
3728  *
3729  *      Initialize the data-related elements of queued_cmd @qc
3730  *      to point to a scatter-gather table @sg, containing @n_elem
3731  *      elements.
3732  *
3733  *      LOCKING:
3734  *      spin_lock_irqsave(host lock)
3735  */
3736
3737 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
3738                  unsigned int n_elem)
3739 {
3740         qc->flags |= ATA_QCFLAG_SG;
3741         qc->__sg = sg;
3742         qc->n_elem = n_elem;
3743         qc->orig_n_elem = n_elem;
3744 }
3745
3746 /**
3747  *      ata_sg_setup_one - DMA-map the memory buffer associated with a command.
3748  *      @qc: Command with memory buffer to be mapped.
3749  *
3750  *      DMA-map the memory buffer associated with queued_cmd @qc.
3751  *
3752  *      LOCKING:
3753  *      spin_lock_irqsave(host lock)
3754  *
3755  *      RETURNS:
3756  *      Zero on success, negative on error.
3757  */
3758
3759 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
3760 {
3761         struct ata_port *ap = qc->ap;
3762         int dir = qc->dma_dir;
3763         struct scatterlist *sg = qc->__sg;
3764         dma_addr_t dma_address;
3765         int trim_sg = 0;
3766
3767         /* we must lengthen transfers to end on a 32-bit boundary */
3768         qc->pad_len = sg->length & 3;
3769         if (qc->pad_len) {
3770                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3771                 struct scatterlist *psg = &qc->pad_sgent;
3772
3773                 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
3774
3775                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3776
3777                 if (qc->tf.flags & ATA_TFLAG_WRITE)
3778                         memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
3779                                qc->pad_len);
3780
3781                 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3782                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3783                 /* trim sg */
3784                 sg->length -= qc->pad_len;
3785                 if (sg->length == 0)
3786                         trim_sg = 1;
3787
3788                 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
3789                         sg->length, qc->pad_len);
3790         }
3791
3792         if (trim_sg) {
3793                 qc->n_elem--;
3794                 goto skip_map;
3795         }
3796
3797         dma_address = dma_map_single(ap->dev, qc->buf_virt,
3798                                      sg->length, dir);
3799         if (dma_mapping_error(dma_address)) {
3800                 /* restore sg */
3801                 sg->length += qc->pad_len;
3802                 return -1;
3803         }
3804
3805         sg_dma_address(sg) = dma_address;
3806         sg_dma_len(sg) = sg->length;
3807
3808 skip_map:
3809         DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
3810                 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3811
3812         return 0;
3813 }
3814
3815 /**
3816  *      ata_sg_setup - DMA-map the scatter-gather table associated with a command.
3817  *      @qc: Command with scatter-gather table to be mapped.
3818  *
3819  *      DMA-map the scatter-gather table associated with queued_cmd @qc.
3820  *
3821  *      LOCKING:
3822  *      spin_lock_irqsave(host lock)
3823  *
3824  *      RETURNS:
3825  *      Zero on success, negative on error.
3826  *
3827  */
3828
3829 static int ata_sg_setup(struct ata_queued_cmd *qc)
3830 {
3831         struct ata_port *ap = qc->ap;
3832         struct scatterlist *sg = qc->__sg;
3833         struct scatterlist *lsg = &sg[qc->n_elem - 1];
3834         int n_elem, pre_n_elem, dir, trim_sg = 0;
3835
3836         VPRINTK("ENTER, ata%u\n", ap->print_id);
3837         WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
3838
3839         /* we must lengthen transfers to end on a 32-bit boundary */
3840         qc->pad_len = lsg->length & 3;
3841         if (qc->pad_len) {
3842                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3843                 struct scatterlist *psg = &qc->pad_sgent;
3844                 unsigned int offset;
3845
3846                 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
3847
3848                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3849
3850                 /*
3851                  * psg->page/offset are used to copy to-be-written
3852                  * data in this function or read data in ata_sg_clean.
3853                  */
3854                 offset = lsg->offset + lsg->length - qc->pad_len;
3855                 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
3856                 psg->offset = offset_in_page(offset);
3857
3858                 if (qc->tf.flags & ATA_TFLAG_WRITE) {
3859                         void *addr = kmap_atomic(psg->page, KM_IRQ0);
3860                         memcpy(pad_buf, addr + psg->offset, qc->pad_len);
3861                         kunmap_atomic(addr, KM_IRQ0);
3862                 }
3863
3864                 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3865                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3866                 /* trim last sg */
3867                 lsg->length -= qc->pad_len;
3868                 if (lsg->length == 0)
3869                         trim_sg = 1;
3870
3871                 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
3872                         qc->n_elem - 1, lsg->length, qc->pad_len);
3873         }
3874
3875         pre_n_elem = qc->n_elem;
3876         if (trim_sg && pre_n_elem)
3877                 pre_n_elem--;
3878
3879         if (!pre_n_elem) {
3880                 n_elem = 0;
3881                 goto skip_map;
3882         }
3883
3884         dir = qc->dma_dir;
3885         n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
3886         if (n_elem < 1) {
3887                 /* restore last sg */
3888                 lsg->length += qc->pad_len;
3889                 return -1;
3890         }
3891
3892         DPRINTK("%d sg elements mapped\n", n_elem);
3893
3894 skip_map:
3895         qc->n_elem = n_elem;
3896
3897         return 0;
3898 }
3899
3900 /**
3901  *      swap_buf_le16 - swap halves of 16-bit words in place
3902  *      @buf:  Buffer to swap
3903  *      @buf_words:  Number of 16-bit words in buffer.
3904  *
3905  *      Swap halves of 16-bit words if needed to convert from
3906  *      little-endian byte order to native cpu byte order, or
3907  *      vice-versa.
3908  *
3909  *      LOCKING:
3910  *      Inherited from caller.
3911  */
3912 void swap_buf_le16(u16 *buf, unsigned int buf_words)
3913 {
3914 #ifdef __BIG_ENDIAN
3915         unsigned int i;
3916
3917         for (i = 0; i < buf_words; i++)
3918                 buf[i] = le16_to_cpu(buf[i]);
3919 #endif /* __BIG_ENDIAN */
3920 }
3921
3922 /**
3923  *      ata_data_xfer - Transfer data by PIO
3924  *      @adev: device to target
3925  *      @buf: data buffer
3926  *      @buflen: buffer length
3927  *      @write_data: read/write
3928  *
3929  *      Transfer data from/to the device data register by PIO.
3930  *
3931  *      LOCKING:
3932  *      Inherited from caller.
3933  */
3934 void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
3935                    unsigned int buflen, int write_data)
3936 {
3937         struct ata_port *ap = adev->ap;
3938         unsigned int words = buflen >> 1;
3939
3940         /* Transfer multiple of 2 bytes */
3941         if (write_data)
3942                 iowrite16_rep(ap->ioaddr.data_addr, buf, words);
3943         else
3944                 ioread16_rep(ap->ioaddr.data_addr, buf, words);
3945
3946         /* Transfer trailing 1 byte, if any. */
3947         if (unlikely(buflen & 0x01)) {
3948                 u16 align_buf[1] = { 0 };
3949                 unsigned char *trailing_buf = buf + buflen - 1;
3950
3951                 if (write_data) {
3952                         memcpy(align_buf, trailing_buf, 1);
3953                         iowrite16(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
3954                 } else {
3955                         align_buf[0] = cpu_to_le16(ioread16(ap->ioaddr.data_addr));
3956                         memcpy(trailing_buf, align_buf, 1);
3957                 }
3958         }
3959 }
3960
3961 /**
3962  *      ata_data_xfer_noirq - Transfer data by PIO
3963  *      @adev: device to target
3964  *      @buf: data buffer
3965  *      @buflen: buffer length
3966  *      @write_data: read/write
3967  *
3968  *      Transfer data from/to the device data register by PIO. Do the
3969  *      transfer with interrupts disabled.
3970  *
3971  *      LOCKING:
3972  *      Inherited from caller.
3973  */
3974 void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
3975                          unsigned int buflen, int write_data)
3976 {
3977         unsigned long flags;
3978         local_irq_save(flags);
3979         ata_data_xfer(adev, buf, buflen, write_data);
3980         local_irq_restore(flags);
3981 }
3982
3983
3984 /**
3985  *      ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
3986  *      @qc: Command on going
3987  *
3988  *      Transfer ATA_SECT_SIZE of data from/to the ATA device.
3989  *
3990  *      LOCKING:
3991  *      Inherited from caller.
3992  */
3993
3994 static void ata_pio_sector(struct ata_queued_cmd *qc)
3995 {
3996         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3997         struct scatterlist *sg = qc->__sg;
3998         struct ata_port *ap = qc->ap;
3999         struct page *page;
4000         unsigned int offset;
4001         unsigned char *buf;
4002
4003         if (qc->curbytes == qc->nbytes - ATA_SECT_SIZE)
4004                 ap->hsm_task_state = HSM_ST_LAST;
4005
4006         page = sg[qc->cursg].page;
4007         offset = sg[qc->cursg].offset + qc->cursg_ofs;
4008
4009         /* get the current page and offset */
4010         page = nth_page(page, (offset >> PAGE_SHIFT));
4011         offset %= PAGE_SIZE;
4012
4013         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
4014
4015         if (PageHighMem(page)) {
4016                 unsigned long flags;
4017
4018                 /* FIXME: use a bounce buffer */
4019                 local_irq_save(flags);
4020                 buf = kmap_atomic(page, KM_IRQ0);
4021
4022                 /* do the actual data transfer */
4023                 ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write);
4024
4025                 kunmap_atomic(buf, KM_IRQ0);
4026                 local_irq_restore(flags);
4027         } else {
4028                 buf = page_address(page);
4029                 ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write);
4030         }
4031
4032         qc->curbytes += ATA_SECT_SIZE;
4033         qc->cursg_ofs += ATA_SECT_SIZE;
4034
4035         if (qc->cursg_ofs == (&sg[qc->cursg])->length) {
4036                 qc->cursg++;
4037                 qc->cursg_ofs = 0;
4038         }
4039 }
4040
4041 /**
4042  *      ata_pio_sectors - Transfer one or many 512-byte sectors.
4043  *      @qc: Command on going
4044  *
4045  *      Transfer one or many ATA_SECT_SIZE of data from/to the
4046  *      ATA device for the DRQ request.
4047  *
4048  *      LOCKING:
4049  *      Inherited from caller.
4050  */
4051
4052 static void ata_pio_sectors(struct ata_queued_cmd *qc)
4053 {
4054         if (is_multi_taskfile(&qc->tf)) {
4055                 /* READ/WRITE MULTIPLE */
4056                 unsigned int nsect;
4057
4058                 WARN_ON(qc->dev->multi_count == 0);
4059
4060                 nsect = min((qc->nbytes - qc->curbytes) / ATA_SECT_SIZE,
4061                             qc->dev->multi_count);
4062                 while (nsect--)
4063                         ata_pio_sector(qc);
4064         } else
4065                 ata_pio_sector(qc);
4066 }
4067
4068 /**
4069  *      atapi_send_cdb - Write CDB bytes to hardware
4070  *      @ap: Port to which ATAPI device is attached.
4071  *      @qc: Taskfile currently active
4072  *
4073  *      When device has indicated its readiness to accept
4074  *      a CDB, this function is called.  Send the CDB.
4075  *
4076  *      LOCKING:
4077  *      caller.
4078  */
4079
4080 static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
4081 {
4082         /* send SCSI cdb */
4083         DPRINTK("send cdb\n");
4084         WARN_ON(qc->dev->cdb_len < 12);
4085
4086         ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1);
4087         ata_altstatus(ap); /* flush */
4088
4089         switch (qc->tf.protocol) {
4090         case ATA_PROT_ATAPI:
4091                 ap->hsm_task_state = HSM_ST;
4092                 break;
4093         case ATA_PROT_ATAPI_NODATA:
4094                 ap->hsm_task_state = HSM_ST_LAST;
4095                 break;
4096         case ATA_PROT_ATAPI_DMA:
4097                 ap->hsm_task_state = HSM_ST_LAST;
4098                 /* initiate bmdma */
4099                 ap->ops->bmdma_start(qc);
4100                 break;
4101         }
4102 }
4103
4104 /**
4105  *      __atapi_pio_bytes - Transfer data from/to the ATAPI device.
4106  *      @qc: Command on going
4107  *      @bytes: number of bytes
4108  *
4109  *      Transfer Transfer data from/to the ATAPI device.
4110  *
4111  *      LOCKING:
4112  *      Inherited from caller.
4113  *
4114  */
4115
4116 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
4117 {
4118         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
4119         struct scatterlist *sg = qc->__sg;
4120         struct ata_port *ap = qc->ap;
4121         struct page *page;
4122         unsigned char *buf;
4123         unsigned int offset, count;
4124
4125         if (qc->curbytes + bytes >= qc->nbytes)
4126                 ap->hsm_task_state = HSM_ST_LAST;
4127
4128 next_sg:
4129         if (unlikely(qc->cursg >= qc->n_elem)) {
4130                 /*
4131                  * The end of qc->sg is reached and the device expects
4132                  * more data to transfer. In order not to overrun qc->sg
4133                  * and fulfill length specified in the byte count register,
4134                  *    - for read case, discard trailing data from the device
4135                  *    - for write case, padding zero data to the device
4136                  */
4137                 u16 pad_buf[1] = { 0 };
4138                 unsigned int words = bytes >> 1;
4139                 unsigned int i;
4140
4141                 if (words) /* warning if bytes > 1 */
4142                         ata_dev_printk(qc->dev, KERN_WARNING,
4143                                        "%u bytes trailing data\n", bytes);
4144
4145                 for (i = 0; i < words; i++)
4146                         ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write);
4147
4148                 ap->hsm_task_state = HSM_ST_LAST;
4149                 return;
4150         }
4151
4152         sg = &qc->__sg[qc->cursg];
4153
4154         page = sg->page;
4155         offset = sg->offset + qc->cursg_ofs;
4156
4157         /* get the current page and offset */
4158         page = nth_page(page, (offset >> PAGE_SHIFT));
4159         offset %= PAGE_SIZE;
4160
4161         /* don't overrun current sg */
4162         count = min(sg->length - qc->cursg_ofs, bytes);
4163
4164         /* don't cross page boundaries */
4165         count = min(count, (unsigned int)PAGE_SIZE - offset);
4166
4167         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
4168
4169         if (PageHighMem(page)) {
4170                 unsigned long flags;
4171
4172                 /* FIXME: use bounce buffer */
4173                 local_irq_save(flags);
4174                 buf = kmap_atomic(page, KM_IRQ0);
4175
4176                 /* do the actual data transfer */
4177                 ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
4178
4179                 kunmap_atomic(buf, KM_IRQ0);
4180                 local_irq_restore(flags);
4181         } else {
4182                 buf = page_address(page);
4183                 ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
4184         }
4185
4186         bytes -= count;
4187         qc->curbytes += count;
4188         qc->cursg_ofs += count;
4189
4190         if (qc->cursg_ofs == sg->length) {
4191                 qc->cursg++;
4192                 qc->cursg_ofs = 0;
4193         }
4194
4195         if (bytes)
4196                 goto next_sg;
4197 }
4198
4199 /**
4200  *      atapi_pio_bytes - Transfer data from/to the ATAPI device.
4201  *      @qc: Command on going
4202  *
4203  *      Transfer Transfer data from/to the ATAPI device.
4204  *
4205  *      LOCKING:
4206  *      Inherited from caller.
4207  */
4208
4209 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
4210 {
4211         struct ata_port *ap = qc->ap;
4212         struct ata_device *dev = qc->dev;
4213         unsigned int ireason, bc_lo, bc_hi, bytes;
4214         int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
4215
4216         /* Abuse qc->result_tf for temp storage of intermediate TF
4217          * here to save some kernel stack usage.
4218          * For normal completion, qc->result_tf is not relevant. For
4219          * error, qc->result_tf is later overwritten by ata_qc_complete().
4220          * So, the correctness of qc->result_tf is not affected.
4221          */
4222         ap->ops->tf_read(ap, &qc->result_tf);
4223         ireason = qc->result_tf.nsect;
4224         bc_lo = qc->result_tf.lbam;
4225         bc_hi = qc->result_tf.lbah;
4226         bytes = (bc_hi << 8) | bc_lo;
4227
4228         /* shall be cleared to zero, indicating xfer of data */
4229         if (ireason & (1 << 0))
4230                 goto err_out;
4231
4232         /* make sure transfer direction matches expected */
4233         i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
4234         if (do_write != i_write)
4235                 goto err_out;
4236
4237         VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes);
4238
4239         __atapi_pio_bytes(qc, bytes);
4240
4241         return;
4242
4243 err_out:
4244         ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n");
4245         qc->err_mask |= AC_ERR_HSM;
4246         ap->hsm_task_state = HSM_ST_ERR;
4247 }
4248
4249 /**
4250  *      ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue.
4251  *      @ap: the target ata_port
4252  *      @qc: qc on going
4253  *
4254  *      RETURNS:
4255  *      1 if ok in workqueue, 0 otherwise.
4256  */
4257
4258 static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc)
4259 {
4260         if (qc->tf.flags & ATA_TFLAG_POLLING)
4261                 return 1;
4262
4263         if (ap->hsm_task_state == HSM_ST_FIRST) {
4264                 if (qc->tf.protocol == ATA_PROT_PIO &&
4265                     (qc->tf.flags & ATA_TFLAG_WRITE))
4266                     return 1;
4267
4268                 if (is_atapi_taskfile(&qc->tf) &&
4269                     !(qc->dev->flags & ATA_DFLAG_CDB_INTR))
4270                         return 1;
4271         }
4272
4273         return 0;
4274 }
4275
4276 /**
4277  *      ata_hsm_qc_complete - finish a qc running on standard HSM
4278  *      @qc: Command to complete
4279  *      @in_wq: 1 if called from workqueue, 0 otherwise
4280  *
4281  *      Finish @qc which is running on standard HSM.
4282  *
4283  *      LOCKING:
4284  *      If @in_wq is zero, spin_lock_irqsave(host lock).
4285  *      Otherwise, none on entry and grabs host lock.
4286  */
4287 static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq)
4288 {
4289         struct ata_port *ap = qc->ap;
4290         unsigned long flags;
4291
4292         if (ap->ops->error_handler) {
4293                 if (in_wq) {
4294                         spin_lock_irqsave(ap->lock, flags);
4295
4296                         /* EH might have kicked in while host lock is
4297                          * released.
4298                          */
4299                         qc = ata_qc_from_tag(ap, qc->tag);
4300                         if (qc) {
4301                                 if (likely(!(qc->err_mask & AC_ERR_HSM))) {
4302                                         ap->ops->irq_on(ap);
4303                                         ata_qc_complete(qc);
4304                                 } else
4305                                         ata_port_freeze(ap);
4306                         }
4307
4308                         spin_unlock_irqrestore(ap->lock, flags);
4309                 } else {
4310                         if (likely(!(qc->err_mask & AC_ERR_HSM)))
4311                                 ata_qc_complete(qc);
4312                         else
4313                                 ata_port_freeze(ap);
4314                 }
4315         } else {
4316                 if (in_wq) {
4317                         spin_lock_irqsave(ap->lock, flags);
4318                         ap->ops->irq_on(ap);
4319                         ata_qc_complete(qc);
4320                         spin_unlock_irqrestore(ap->lock, flags);
4321                 } else
4322                         ata_qc_complete(qc);
4323         }
4324
4325         ata_altstatus(ap); /* flush */
4326 }
4327
4328 /**
4329  *      ata_hsm_move - move the HSM to the next state.
4330  *      @ap: the target ata_port
4331  *      @qc: qc on going
4332  *      @status: current device status
4333  *      @in_wq: 1 if called from workqueue, 0 otherwise
4334  *
4335  *      RETURNS:
4336  *      1 when poll next status needed, 0 otherwise.
4337  */
4338 int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
4339                  u8 status, int in_wq)
4340 {
4341         unsigned long flags = 0;
4342         int poll_next;
4343
4344         WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0);
4345
4346         /* Make sure ata_qc_issue_prot() does not throw things
4347          * like DMA polling into the workqueue. Notice that
4348          * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING).
4349          */
4350         WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc));
4351
4352 fsm_start:
4353         DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
4354                 ap->print_id, qc->tf.protocol, ap->hsm_task_state, status);
4355
4356         switch (ap->hsm_task_state) {
4357         case HSM_ST_FIRST:
4358                 /* Send first data block or PACKET CDB */
4359
4360                 /* If polling, we will stay in the work queue after
4361                  * sending the data. Otherwise, interrupt handler
4362                  * takes over after sending the data.
4363                  */
4364                 poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);
4365
4366                 /* check device status */
4367                 if (unlikely((status & ATA_DRQ) == 0)) {
4368                         /* handle BSY=0, DRQ=0 as error */
4369                         if (likely(status & (ATA_ERR | ATA_DF)))
4370                                 /* device stops HSM for abort/error */
4371                                 qc->err_mask |= AC_ERR_DEV;
4372                         else
4373                                 /* HSM violation. Let EH handle this */
4374                                 qc->err_mask |= AC_ERR_HSM;
4375
4376                         ap->hsm_task_state = HSM_ST_ERR;
4377                         goto fsm_start;
4378                 }
4379
4380                 /* Device should not ask for data transfer (DRQ=1)
4381                  * when it finds something wrong.
4382                  * We ignore DRQ here and stop the HSM by
4383                  * changing hsm_task_state to HSM_ST_ERR and
4384                  * let the EH abort the command or reset the device.
4385                  */
4386                 if (unlikely(status & (ATA_ERR | ATA_DF))) {
4387                         ata_port_printk(ap, KERN_WARNING, "DRQ=1 with device "
4388                                         "error, dev_stat 0x%X\n", status);
4389                         qc->err_mask |= AC_ERR_HSM;
4390                         ap->hsm_task_state = HSM_ST_ERR;
4391                         goto fsm_start;
4392                 }
4393
4394                 /* Send the CDB (atapi) or the first data block (ata pio out).
4395                  * During the state transition, interrupt handler shouldn't
4396                  * be invoked before the data transfer is complete and
4397                  * hsm_task_state is changed. Hence, the following locking.
4398                  */
4399                 if (in_wq)
4400                         spin_lock_irqsave(ap->lock, flags);
4401
4402                 if (qc->tf.protocol == ATA_PROT_PIO) {
4403                         /* PIO data out protocol.
4404                          * send first data block.
4405                          */
4406
4407                         /* ata_pio_sectors() might change the state
4408                          * to HSM_ST_LAST. so, the state is changed here
4409                          * before ata_pio_sectors().
4410                          */
4411                         ap->hsm_task_state = HSM_ST;
4412                         ata_pio_sectors(qc);
4413                         ata_altstatus(ap); /* flush */
4414                 } else
4415                         /* send CDB */
4416                         atapi_send_cdb(ap, qc);
4417
4418                 if (in_wq)
4419                         spin_unlock_irqrestore(ap->lock, flags);
4420
4421                 /* if polling, ata_pio_task() handles the rest.
4422                  * otherwise, interrupt handler takes over from here.
4423                  */
4424                 break;
4425
4426         case HSM_ST:
4427                 /* complete command or read/write the data register */
4428                 if (qc->tf.protocol == ATA_PROT_ATAPI) {
4429                         /* ATAPI PIO protocol */
4430                         if ((status & ATA_DRQ) == 0) {
4431                                 /* No more data to transfer or device error.
4432                                  * Device error will be tagged in HSM_ST_LAST.
4433                                  */
4434                                 ap->hsm_task_state = HSM_ST_LAST;
4435                                 goto fsm_start;
4436                         }
4437
4438                         /* Device should not ask for data transfer (DRQ=1)
4439                          * when it finds something wrong.
4440                          * We ignore DRQ here and stop the HSM by
4441                          * changing hsm_task_state to HSM_ST_ERR and
4442                          * let the EH abort the command or reset the device.
4443                          */
4444                         if (unlikely(status & (ATA_ERR | ATA_DF))) {
4445                                 ata_port_printk(ap, KERN_WARNING, "DRQ=1 with "
4446                                                 "device error, dev_stat 0x%X\n",
4447                                                 status);
4448                                 qc->err_mask |= AC_ERR_HSM;
4449                                 ap->hsm_task_state = HSM_ST_ERR;
4450                                 goto fsm_start;
4451                         }
4452
4453                         atapi_pio_bytes(qc);
4454
4455                         if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
4456                                 /* bad ireason reported by device */
4457                                 goto fsm_start;
4458
4459                 } else {
4460                         /* ATA PIO protocol */
4461                         if (unlikely((status & ATA_DRQ) == 0)) {
4462                                 /* handle BSY=0, DRQ=0 as error */
4463                                 if (likely(status & (ATA_ERR | ATA_DF)))
4464                                         /* device stops HSM for abort/error */
4465                                         qc->err_mask |= AC_ERR_DEV;
4466                                 else
4467                                         /* HSM violation. Let EH handle this.
4468                                          * Phantom devices also trigger this
4469                                          * condition.  Mark hint.
4470                                          */
4471                                         qc->err_mask |= AC_ERR_HSM |
4472                                                         AC_ERR_NODEV_HINT;
4473
4474                                 ap->hsm_task_state = HSM_ST_ERR;
4475                                 goto fsm_start;
4476                         }
4477
4478                         /* For PIO reads, some devices may ask for
4479                          * data transfer (DRQ=1) alone with ERR=1.
4480                          * We respect DRQ here and transfer one
4481                          * block of junk data before changing the
4482                          * hsm_task_state to HSM_ST_ERR.
4483                          *
4484                          * For PIO writes, ERR=1 DRQ=1 doesn't make
4485                          * sense since the data block has been
4486                          * transferred to the device.
4487                          */
4488                         if (unlikely(status & (ATA_ERR | ATA_DF))) {
4489                                 /* data might be corrputed */
4490                                 qc->err_mask |= AC_ERR_DEV;
4491
4492                                 if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
4493                                         ata_pio_sectors(qc);
4494                                         ata_altstatus(ap);
4495                                         status = ata_wait_idle(ap);
4496                                 }
4497
4498                                 if (status & (ATA_BUSY | ATA_DRQ))
4499                                         qc->err_mask |= AC_ERR_HSM;
4500
4501                                 /* ata_pio_sectors() might change the
4502                                  * state to HSM_ST_LAST. so, the state
4503                                  * is changed after ata_pio_sectors().
4504                                  */
4505                                 ap->hsm_task_state = HSM_ST_ERR;
4506                                 goto fsm_start;
4507                         }
4508
4509                         ata_pio_sectors(qc);
4510
4511                         if (ap->hsm_task_state == HSM_ST_LAST &&
4512                             (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
4513                                 /* all data read */
4514                                 ata_altstatus(ap);
4515                                 status = ata_wait_idle(ap);
4516                                 goto fsm_start;
4517                         }
4518                 }
4519
4520                 ata_altstatus(ap); /* flush */
4521                 poll_next = 1;
4522                 break;
4523
4524         case HSM_ST_LAST:
4525                 if (unlikely(!ata_ok(status))) {
4526                         qc->err_mask |= __ac_err_mask(status);
4527                         ap->hsm_task_state = HSM_ST_ERR;
4528                         goto fsm_start;
4529                 }
4530
4531                 /* no more data to transfer */
4532                 DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n",
4533                         ap->print_id, qc->dev->devno, status);
4534
4535                 WARN_ON(qc->err_mask);
4536
4537                 ap->hsm_task_state = HSM_ST_IDLE;
4538
4539                 /* complete taskfile transaction */
4540                 ata_hsm_qc_complete(qc, in_wq);
4541
4542                 poll_next = 0;
4543                 break;
4544
4545         case HSM_ST_ERR:
4546                 /* make sure qc->err_mask is available to
4547                  * know what's wrong and recover
4548                  */
4549                 WARN_ON(qc->err_mask == 0);
4550
4551                 ap->hsm_task_state = HSM_ST_IDLE;
4552
4553                 /* complete taskfile transaction */
4554                 ata_hsm_qc_complete(qc, in_wq);
4555
4556                 poll_next = 0;
4557                 break;
4558         default:
4559                 poll_next = 0;
4560                 BUG();
4561         }
4562
4563         return poll_next;
4564 }
4565
4566 static void ata_pio_task(struct work_struct *work)
4567 {
4568         struct ata_port *ap =
4569                 container_of(work, struct ata_port, port_task.work);
4570         struct ata_queued_cmd *qc = ap->port_task_data;
4571         u8 status;
4572         int poll_next;
4573
4574 fsm_start:
4575         WARN_ON(ap->hsm_task_state == HSM_ST_IDLE);
4576
4577         /*
4578          * This is purely heuristic.  This is a fast path.
4579          * Sometimes when we enter, BSY will be cleared in
4580          * a chk-status or two.  If not, the drive is probably seeking
4581          * or something.  Snooze for a couple msecs, then
4582          * chk-status again.  If still busy, queue delayed work.
4583          */
4584         status = ata_busy_wait(ap, ATA_BUSY, 5);
4585         if (status & ATA_BUSY) {
4586                 msleep(2);
4587                 status = ata_busy_wait(ap, ATA_BUSY, 10);
4588                 if (status & ATA_BUSY) {
4589                         ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE);
4590                         return;
4591                 }
4592         }
4593
4594         /* move the HSM */
4595         poll_next = ata_hsm_move(ap, qc, status, 1);
4596
4597         /* another command or interrupt handler
4598          * may be running at this point.
4599          */
4600         if (poll_next)
4601                 goto fsm_start;
4602 }
4603
4604 /**
4605  *      ata_qc_new - Request an available ATA command, for queueing
4606  *      @ap: Port associated with device @dev
4607  *      @dev: Device from whom we request an available command structure
4608  *
4609  *      LOCKING:
4610  *      None.
4611  */
4612
4613 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
4614 {
4615         struct ata_queued_cmd *qc = NULL;
4616         unsigned int i;
4617
4618         /* no command while frozen */
4619         if (unlikely(ap->pflags & ATA_PFLAG_FROZEN))
4620                 return NULL;
4621
4622         /* the last tag is reserved for internal command. */
4623         for (i = 0; i < ATA_MAX_QUEUE - 1; i++)
4624                 if (!test_and_set_bit(i, &ap->qc_allocated)) {
4625                         qc = __ata_qc_from_tag(ap, i);
4626                         break;
4627                 }
4628
4629         if (qc)
4630                 qc->tag = i;
4631
4632         return qc;
4633 }
4634
4635 /**
4636  *      ata_qc_new_init - Request an available ATA command, and initialize it
4637  *      @dev: Device from whom we request an available command structure
4638  *
4639  *      LOCKING:
4640  *      None.
4641  */
4642
4643 struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
4644 {
4645         struct ata_port *ap = dev->ap;
4646         struct ata_queued_cmd *qc;
4647
4648         qc = ata_qc_new(ap);
4649         if (qc) {
4650                 qc->scsicmd = NULL;
4651                 qc->ap = ap;
4652                 qc->dev = dev;
4653
4654                 ata_qc_reinit(qc);
4655         }
4656
4657         return qc;
4658 }
4659
4660 /**
4661  *      ata_qc_free - free unused ata_queued_cmd
4662  *      @qc: Command to complete
4663  *
4664  *      Designed to free unused ata_queued_cmd object
4665  *      in case something prevents using it.
4666  *
4667  *      LOCKING:
4668  *      spin_lock_irqsave(host lock)
4669  */
4670 void ata_qc_free(struct ata_queued_cmd *qc)
4671 {
4672         struct ata_port *ap = qc->ap;
4673         unsigned int tag;
4674
4675         WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
4676
4677         qc->flags = 0;
4678         tag = qc->tag;
4679         if (likely(ata_tag_valid(tag))) {
4680                 qc->tag = ATA_TAG_POISON;
4681                 clear_bit(tag, &ap->qc_allocated);
4682         }
4683 }
4684
4685 void __ata_qc_complete(struct ata_queued_cmd *qc)
4686 {
4687         struct ata_port *ap = qc->ap;
4688
4689         WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
4690         WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
4691
4692         if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4693                 ata_sg_clean(qc);
4694
4695         /* command should be marked inactive atomically with qc completion */
4696         if (qc->tf.protocol == ATA_PROT_NCQ)
4697                 ap->sactive &= ~(1 << qc->tag);
4698         else
4699                 ap->active_tag = ATA_TAG_POISON;
4700
4701         /* atapi: mark qc as inactive to prevent the interrupt handler
4702          * from completing the command twice later, before the error handler
4703          * is called. (when rc != 0 and atapi request sense is needed)
4704          */
4705         qc->flags &= ~ATA_QCFLAG_ACTIVE;
4706         ap->qc_active &= ~(1 << qc->tag);
4707
4708         /* call completion callback */
4709         qc->complete_fn(qc);
4710 }
4711
4712 static void fill_result_tf(struct ata_queued_cmd *qc)
4713 {
4714         struct ata_port *ap = qc->ap;
4715
4716         ap->ops->tf_read(ap, &qc->result_tf);
4717         qc->result_tf.flags = qc->tf.flags;
4718 }
4719
4720 /**
4721  *      ata_qc_complete - Complete an active ATA command
4722  *      @qc: Command to complete
4723  *      @err_mask: ATA Status register contents
4724  *
4725  *      Indicate to the mid and upper layers that an ATA
4726  *      command has completed, with either an ok or not-ok status.
4727  *
4728  *      LOCKING:
4729  *      spin_lock_irqsave(host lock)
4730  */
4731 void ata_qc_complete(struct ata_queued_cmd *qc)
4732 {
4733         struct ata_port *ap = qc->ap;
4734
4735         /* XXX: New EH and old EH use different mechanisms to
4736          * synchronize EH with regular execution path.
4737          *
4738          * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED.
4739          * Normal execution path is responsible for not accessing a
4740          * failed qc.  libata core enforces the rule by returning NULL
4741          * from ata_qc_from_tag() for failed qcs.
4742          *
4743          * Old EH depends on ata_qc_complete() nullifying completion
4744          * requests if ATA_QCFLAG_EH_SCHEDULED is set.  Old EH does
4745          * not synchronize with interrupt handler.  Only PIO task is
4746          * taken care of.
4747          */
4748         if (ap->ops->error_handler) {
4749                 WARN_ON(ap->pflags & ATA_PFLAG_FROZEN);
4750
4751                 if (unlikely(qc->err_mask))
4752                         qc->flags |= ATA_QCFLAG_FAILED;
4753
4754                 if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
4755                         if (!ata_tag_internal(qc->tag)) {
4756                                 /* always fill result TF for failed qc */
4757                                 fill_result_tf(qc);
4758                                 ata_qc_schedule_eh(qc);
4759                                 return;
4760                         }
4761                 }
4762
4763                 /* read result TF if requested */
4764                 if (qc->flags & ATA_QCFLAG_RESULT_TF)
4765                         fill_result_tf(qc);
4766
4767                 __ata_qc_complete(qc);
4768         } else {
4769                 if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
4770                         return;
4771
4772                 /* read result TF if failed or requested */
4773                 if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
4774                         fill_result_tf(qc);
4775
4776                 __ata_qc_complete(qc);
4777         }
4778 }
4779
4780 /**
4781  *      ata_qc_complete_multiple - Complete multiple qcs successfully
4782  *      @ap: port in question
4783  *      @qc_active: new qc_active mask
4784  *      @finish_qc: LLDD callback invoked before completing a qc
4785  *
4786  *      Complete in-flight commands.  This functions is meant to be
4787  *      called from low-level driver's interrupt routine to complete
4788  *      requests normally.  ap->qc_active and @qc_active is compared
4789  *      and commands are completed accordingly.
4790  *
4791  *      LOCKING:
4792  *      spin_lock_irqsave(host lock)
4793  *
4794  *      RETURNS:
4795  *      Number of completed commands on success, -errno otherwise.
4796  */
4797 int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
4798                              void (*finish_qc)(struct ata_queued_cmd *))
4799 {
4800         int nr_done = 0;
4801         u32 done_mask;
4802         int i;
4803
4804         done_mask = ap->qc_active ^ qc_active;
4805
4806         if (unlikely(done_mask & qc_active)) {
4807                 ata_port_printk(ap, KERN_ERR, "illegal qc_active transition "
4808                                 "(%08x->%08x)\n", ap->qc_active, qc_active);
4809                 return -EINVAL;
4810         }
4811
4812         for (i = 0; i < ATA_MAX_QUEUE; i++) {
4813                 struct ata_queued_cmd *qc;
4814
4815                 if (!(done_mask & (1 << i)))
4816                         continue;
4817
4818                 if ((qc = ata_qc_from_tag(ap, i))) {
4819                         if (finish_qc)
4820                                 finish_qc(qc);
4821                         ata_qc_complete(qc);
4822                         nr_done++;
4823                 }
4824         }
4825
4826         return nr_done;
4827 }
4828
4829 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
4830 {
4831         struct ata_port *ap = qc->ap;
4832
4833         switch (qc->tf.protocol) {
4834         case ATA_PROT_NCQ:
4835         case ATA_PROT_DMA:
4836         case ATA_PROT_ATAPI_DMA:
4837                 return 1;
4838
4839         case ATA_PROT_ATAPI:
4840         case ATA_PROT_PIO:
4841                 if (ap->flags & ATA_FLAG_PIO_DMA)
4842                         return 1;
4843
4844                 /* fall through */
4845
4846         default:
4847                 return 0;
4848         }
4849
4850         /* never reached */
4851 }
4852
4853 /**
4854  *      ata_qc_issue - issue taskfile to device
4855  *      @qc: command to issue to device
4856  *
4857  *      Prepare an ATA command to submission to device.
4858  *      This includes mapping the data into a DMA-able
4859  *      area, filling in the S/G table, and finally
4860  *      writing the taskfile to hardware, starting the command.
4861  *
4862  *      LOCKING:
4863  *      spin_lock_irqsave(host lock)
4864  */
4865 void ata_qc_issue(struct ata_queued_cmd *qc)
4866 {
4867         struct ata_port *ap = qc->ap;
4868
4869         /* Make sure only one non-NCQ command is outstanding.  The
4870          * check is skipped for old EH because it reuses active qc to
4871          * request ATAPI sense.
4872          */
4873         WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag));
4874
4875         if (qc->tf.protocol == ATA_PROT_NCQ) {
4876                 WARN_ON(ap->sactive & (1 << qc->tag));
4877                 ap->sactive |= 1 << qc->tag;
4878         } else {
4879                 WARN_ON(ap->sactive);
4880                 ap->active_tag = qc->tag;
4881         }
4882
4883         qc->flags |= ATA_QCFLAG_ACTIVE;
4884         ap->qc_active |= 1 << qc->tag;
4885
4886         if (ata_should_dma_map(qc)) {
4887                 if (qc->flags & ATA_QCFLAG_SG) {
4888                         if (ata_sg_setup(qc))
4889                                 goto sg_err;
4890                 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
4891                         if (ata_sg_setup_one(qc))
4892                                 goto sg_err;
4893                 }
4894         } else {
4895                 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4896         }
4897
4898         ap->ops->qc_prep(qc);
4899
4900         qc->err_mask |= ap->ops->qc_issue(qc);
4901         if (unlikely(qc->err_mask))
4902                 goto err;
4903         return;
4904
4905 sg_err:
4906         qc->flags &= ~ATA_QCFLAG_DMAMAP;
4907         qc->err_mask |= AC_ERR_SYSTEM;
4908 err:
4909         ata_qc_complete(qc);
4910 }
4911
4912 /**
4913  *      ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
4914  *      @qc: command to issue to device
4915  *
4916  *      Using various libata functions and hooks, this function
4917  *      starts an ATA command.  ATA commands are grouped into
4918  *      classes called "protocols", and issuing each type of protocol
4919  *      is slightly different.
4920  *
4921  *      May be used as the qc_issue() entry in ata_port_operations.
4922  *
4923  *      LOCKING:
4924  *      spin_lock_irqsave(host lock)
4925  *
4926  *      RETURNS:
4927  *      Zero on success, AC_ERR_* mask on failure
4928  */
4929
4930 unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
4931 {
4932         struct ata_port *ap = qc->ap;
4933
4934         /* Use polling pio if the LLD doesn't handle
4935          * interrupt driven pio and atapi CDB interrupt.
4936          */
4937         if (ap->flags & ATA_FLAG_PIO_POLLING) {
4938                 switch (qc->tf.protocol) {
4939                 case ATA_PROT_PIO:
4940                 case ATA_PROT_NODATA:
4941                 case ATA_PROT_ATAPI:
4942                 case ATA_PROT_ATAPI_NODATA:
4943                         qc->tf.flags |= ATA_TFLAG_POLLING;
4944                         break;
4945                 case ATA_PROT_ATAPI_DMA:
4946                         if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
4947                                 /* see ata_dma_blacklisted() */
4948                                 BUG();
4949                         break;
4950                 default:
4951                         break;
4952                 }
4953         }
4954
4955         /* Some controllers show flaky interrupt behavior after
4956          * setting xfer mode.  Use polling instead.
4957          */
4958         if (unlikely(qc->tf.command == ATA_CMD_SET_FEATURES &&
4959                      qc->tf.feature == SETFEATURES_XFER) &&
4960             (ap->flags & ATA_FLAG_SETXFER_POLLING))
4961                 qc->tf.flags |= ATA_TFLAG_POLLING;
4962
4963         /* select the device */
4964         ata_dev_select(ap, qc->dev->devno, 1, 0);
4965
4966         /* start the command */
4967         switch (qc->tf.protocol) {
4968         case ATA_PROT_NODATA:
4969                 if (qc->tf.flags & ATA_TFLAG_POLLING)
4970                         ata_qc_set_polling(qc);
4971
4972                 ata_tf_to_host(ap, &qc->tf);
4973                 ap->hsm_task_state = HSM_ST_LAST;
4974
4975                 if (qc->tf.flags & ATA_TFLAG_POLLING)
4976                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
4977
4978                 break;
4979
4980         case ATA_PROT_DMA:
4981                 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
4982
4983                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
4984                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
4985                 ap->ops->bmdma_start(qc);           /* initiate bmdma */
4986                 ap->hsm_task_state = HSM_ST_LAST;
4987                 break;
4988
4989         case ATA_PROT_PIO:
4990                 if (qc->tf.flags & ATA_TFLAG_POLLING)
4991                         ata_qc_set_polling(qc);
4992
4993                 ata_tf_to_host(ap, &qc->tf);
4994
4995                 if (qc->tf.flags & ATA_TFLAG_WRITE) {
4996                         /* PIO data out protocol */
4997                         ap->hsm_task_state = HSM_ST_FIRST;
4998                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
4999
5000                         /* always send first data block using
5001                          * the ata_pio_task() codepath.
5002                          */
5003                 } else {
5004                         /* PIO data in protocol */
5005                         ap->hsm_task_state = HSM_ST;
5006
5007                         if (qc->tf.flags & ATA_TFLAG_POLLING)
5008                                 ata_port_queue_task(ap, ata_pio_task, qc, 0);
5009
5010                         /* if polling, ata_pio_task() handles the rest.
5011                          * otherwise, interrupt handler takes over from here.
5012                          */
5013                 }
5014
5015                 break;
5016
5017         case ATA_PROT_ATAPI:
5018         case ATA_PROT_ATAPI_NODATA:
5019                 if (qc->tf.flags & ATA_TFLAG_POLLING)
5020                         ata_qc_set_polling(qc);
5021
5022                 ata_tf_to_host(ap, &qc->tf);
5023
5024                 ap->hsm_task_state = HSM_ST_FIRST;
5025
5026                 /* send cdb by polling if no cdb interrupt */
5027                 if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
5028                     (qc->tf.flags & ATA_TFLAG_POLLING))
5029                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
5030                 break;
5031
5032         case ATA_PROT_ATAPI_DMA:
5033                 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
5034
5035                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
5036                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
5037                 ap->hsm_task_state = HSM_ST_FIRST;
5038
5039                 /* send cdb by polling if no cdb interrupt */
5040                 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
5041                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
5042                 break;
5043
5044         default:
5045                 WARN_ON(1);
5046                 return AC_ERR_SYSTEM;
5047         }
5048
5049         return 0;
5050 }
5051
5052 /**
5053  *      ata_host_intr - Handle host interrupt for given (port, task)
5054  *      @ap: Port on which interrupt arrived (possibly...)
5055  *      @qc: Taskfile currently active in engine
5056  *
5057  *      Handle host interrupt for given queued command.  Currently,
5058  *      only DMA interrupts are handled.  All other commands are
5059  *      handled via polling with interrupts disabled (nIEN bit).
5060  *
5061  *      LOCKING:
5062  *      spin_lock_irqsave(host lock)
5063  *
5064  *      RETURNS:
5065  *      One if interrupt was handled, zero if not (shared irq).
5066  */
5067
5068 inline unsigned int ata_host_intr (struct ata_port *ap,
5069                                    struct ata_queued_cmd *qc)
5070 {
5071         struct ata_eh_info *ehi = &ap->eh_info;
5072         u8 status, host_stat = 0;
5073
5074         VPRINTK("ata%u: protocol %d task_state %d\n",
5075                 ap->print_id, qc->tf.protocol, ap->hsm_task_state);
5076
5077         /* Check whether we are expecting interrupt in this state */
5078         switch (ap->hsm_task_state) {
5079         case HSM_ST_FIRST:
5080                 /* Some pre-ATAPI-4 devices assert INTRQ
5081                  * at this state when ready to receive CDB.
5082                  */
5083
5084                 /* Check the ATA_DFLAG_CDB_INTR flag is enough here.
5085                  * The flag was turned on only for atapi devices.
5086                  * No need to check is_atapi_taskfile(&qc->tf) again.
5087                  */
5088                 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
5089                         goto idle_irq;
5090                 break;
5091         case HSM_ST_LAST:
5092                 if (qc->tf.protocol == ATA_PROT_DMA ||
5093                     qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
5094                         /* check status of DMA engine */
5095                         host_stat = ap->ops->bmdma_status(ap);
5096                         VPRINTK("ata%u: host_stat 0x%X\n",
5097                                 ap->print_id, host_stat);
5098
5099                         /* if it's not our irq... */
5100                         if (!(host_stat & ATA_DMA_INTR))
5101                                 goto idle_irq;
5102
5103                         /* before we do anything else, clear DMA-Start bit */
5104                         ap->ops->bmdma_stop(qc);
5105
5106                         if (unlikely(host_stat & ATA_DMA_ERR)) {
5107                                 /* error when transfering data to/from memory */
5108                                 qc->err_mask |= AC_ERR_HOST_BUS;
5109                                 ap->hsm_task_state = HSM_ST_ERR;
5110                         }
5111                 }
5112                 break;
5113         case HSM_ST:
5114                 break;
5115         default:
5116                 goto idle_irq;
5117         }
5118
5119         /* check altstatus */
5120         status = ata_altstatus(ap);
5121         if (status & ATA_BUSY)
5122                 goto idle_irq;
5123
5124         /* check main status, clearing INTRQ */
5125         status = ata_chk_status(ap);
5126         if (unlikely(status & ATA_BUSY))
5127                 goto idle_irq;
5128
5129         /* ack bmdma irq events */
5130         ap->ops->irq_clear(ap);
5131
5132         ata_hsm_move(ap, qc, status, 0);
5133
5134         if (unlikely(qc->err_mask) && (qc->tf.protocol == ATA_PROT_DMA ||
5135                                        qc->tf.protocol == ATA_PROT_ATAPI_DMA))
5136                 ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);
5137
5138         return 1;       /* irq handled */
5139
5140 idle_irq:
5141         ap->stats.idle_irq++;
5142
5143 #ifdef ATA_IRQ_TRAP
5144         if ((ap->stats.idle_irq % 1000) == 0) {
5145                 ap->ops->irq_ack(ap, 0); /* debug trap */
5146                 ata_port_printk(ap, KERN_WARNING, "irq trap\n");
5147                 return 1;
5148         }
5149 #endif
5150         return 0;       /* irq not handled */
5151 }
5152
5153 /**
5154  *      ata_interrupt - Default ATA host interrupt handler
5155  *      @irq: irq line (unused)
5156  *      @dev_instance: pointer to our ata_host information structure
5157  *
5158  *      Default interrupt handler for PCI IDE devices.  Calls
5159  *      ata_host_intr() for each port that is not disabled.
5160  *
5161  *      LOCKING:
5162  *      Obtains host lock during operation.
5163  *
5164  *      RETURNS:
5165  *      IRQ_NONE or IRQ_HANDLED.
5166  */
5167
5168 irqreturn_t ata_interrupt (int irq, void *dev_instance)
5169 {
5170         struct ata_host *host = dev_instance;
5171         unsigned int i;
5172         unsigned int handled = 0;
5173         unsigned long flags;
5174
5175         /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
5176         spin_lock_irqsave(&host->lock, flags);
5177
5178         for (i = 0; i < host->n_ports; i++) {
5179                 struct ata_port *ap;
5180
5181                 ap = host->ports[i];
5182                 if (ap &&
5183                     !(ap->flags & ATA_FLAG_DISABLED)) {
5184                         struct ata_queued_cmd *qc;
5185
5186                         qc = ata_qc_from_tag(ap, ap->active_tag);
5187                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
5188                             (qc->flags & ATA_QCFLAG_ACTIVE))
5189                                 handled |= ata_host_intr(ap, qc);
5190                 }
5191         }
5192
5193         spin_unlock_irqrestore(&host->lock, flags);
5194
5195         return IRQ_RETVAL(handled);
5196 }
5197
5198 /**
5199  *      sata_scr_valid - test whether SCRs are accessible
5200  *      @ap: ATA port to test SCR accessibility for
5201  *
5202  *      Test whether SCRs are accessible for @ap.
5203  *
5204  *      LOCKING:
5205  *      None.
5206  *
5207  *      RETURNS:
5208  *      1 if SCRs are accessible, 0 otherwise.
5209  */
5210 int sata_scr_valid(struct ata_port *ap)
5211 {
5212         return ap->cbl == ATA_CBL_SATA && ap->ops->scr_read;
5213 }
5214
5215 /**
5216  *      sata_scr_read - read SCR register of the specified port
5217  *      @ap: ATA port to read SCR for
5218  *      @reg: SCR to read
5219  *      @val: Place to store read value
5220  *
5221  *      Read SCR register @reg of @ap into *@val.  This function is
5222  *      guaranteed to succeed if the cable type of the port is SATA
5223  *      and the port implements ->scr_read.
5224  *
5225  *      LOCKING:
5226  *      None.
5227  *
5228  *      RETURNS:
5229  *      0 on success, negative errno on failure.
5230  */
5231 int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
5232 {
5233         if (sata_scr_valid(ap)) {
5234                 *val = ap->ops->scr_read(ap, reg);
5235                 return 0;
5236         }
5237         return -EOPNOTSUPP;
5238 }
5239
5240 /**
5241  *      sata_scr_write - write SCR register of the specified port
5242  *      @ap: ATA port to write SCR for
5243  *      @reg: SCR to write
5244  *      @val: value to write
5245  *
5246  *      Write @val to SCR register @reg of @ap.  This function is
5247  *      guaranteed to succeed if the cable type of the port is SATA
5248  *      and the port implements ->scr_read.
5249  *
5250  *      LOCKING:
5251  *      None.
5252  *
5253  *      RETURNS:
5254  *      0 on success, negative errno on failure.
5255  */
5256 int sata_scr_write(struct ata_port *ap, int reg, u32 val)
5257 {
5258         if (sata_scr_valid(ap)) {
5259                 ap->ops->scr_write(ap, reg, val);
5260                 return 0;
5261         }
5262         return -EOPNOTSUPP;
5263 }
5264
5265 /**
5266  *      sata_scr_write_flush - write SCR register of the specified port and flush
5267  *      @ap: ATA port to write SCR for
5268  *      @reg: SCR to write
5269  *      @val: value to write
5270  *
5271  *      This function is identical to sata_scr_write() except that this
5272  *      function performs flush after writing to the register.
5273  *
5274  *      LOCKING:
5275  *      None.
5276  *
5277  *      RETURNS:
5278  *      0 on success, negative errno on failure.
5279  */
5280 int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
5281 {
5282         if (sata_scr_valid(ap)) {
5283                 ap->ops->scr_write(ap, reg, val);
5284                 ap->ops->scr_read(ap, reg);
5285                 return 0;
5286         }
5287         return -EOPNOTSUPP;
5288 }
5289
5290 /**
5291  *      ata_port_online - test whether the given port is online
5292  *      @ap: ATA port to test
5293  *
5294  *      Test whether @ap is online.  Note that this function returns 0
5295  *      if online status of @ap cannot be obtained, so
5296  *      ata_port_online(ap) != !ata_port_offline(ap).
5297  *
5298  *      LOCKING:
5299  *      None.
5300  *
5301  *      RETURNS:
5302  *      1 if the port online status is available and online.
5303  */
5304 int ata_port_online(struct ata_port *ap)
5305 {
5306         u32 sstatus;
5307
5308         if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) == 0x3)
5309                 return 1;
5310         return 0;
5311 }
5312
5313 /**
5314  *      ata_port_offline - test whether the given port is offline
5315  *      @ap: ATA port to test
5316  *
5317  *      Test whether @ap is offline.  Note that this function returns
5318  *      0 if offline status of @ap cannot be obtained, so
5319  *      ata_port_online(ap) != !ata_port_offline(ap).
5320  *
5321  *      LOCKING:
5322  *      None.
5323  *
5324  *      RETURNS:
5325  *      1 if the port offline status is available and offline.
5326  */
5327 int ata_port_offline(struct ata_port *ap)
5328 {
5329         u32 sstatus;
5330
5331         if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) != 0x3)
5332                 return 1;
5333         return 0;
5334 }
5335
5336 int ata_flush_cache(struct ata_device *dev)
5337 {
5338         unsigned int err_mask;
5339         u8 cmd;
5340
5341         if (!ata_try_flush_cache(dev))
5342                 return 0;
5343
5344         if (dev->flags & ATA_DFLAG_FLUSH_EXT)
5345                 cmd = ATA_CMD_FLUSH_EXT;
5346         else
5347                 cmd = ATA_CMD_FLUSH;
5348
5349         err_mask = ata_do_simple_cmd(dev, cmd);
5350         if (err_mask) {
5351                 ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n");
5352                 return -EIO;
5353         }
5354
5355         return 0;
5356 }
5357
5358 #ifdef CONFIG_PM
5359 static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg,
5360                                unsigned int action, unsigned int ehi_flags,
5361                                int wait)
5362 {
5363         unsigned long flags;
5364         int i, rc;
5365
5366         for (i = 0; i < host->n_ports; i++) {
5367                 struct ata_port *ap = host->ports[i];
5368
5369                 /* Previous resume operation might still be in
5370                  * progress.  Wait for PM_PENDING to clear.
5371                  */
5372                 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
5373                         ata_port_wait_eh(ap);
5374                         WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5375                 }
5376
5377                 /* request PM ops to EH */
5378                 spin_lock_irqsave(ap->lock, flags);
5379
5380                 ap->pm_mesg = mesg;
5381                 if (wait) {
5382                         rc = 0;
5383                         ap->pm_result = &rc;
5384                 }
5385
5386                 ap->pflags |= ATA_PFLAG_PM_PENDING;
5387                 ap->eh_info.action |= action;
5388                 ap->eh_info.flags |= ehi_flags;
5389
5390                 ata_port_schedule_eh(ap);
5391
5392                 spin_unlock_irqrestore(ap->lock, flags);
5393
5394                 /* wait and check result */
5395                 if (wait) {
5396                         ata_port_wait_eh(ap);
5397                         WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5398                         if (rc)
5399                                 return rc;
5400                 }
5401         }
5402
5403         return 0;
5404 }
5405
5406 /**
5407  *      ata_host_suspend - suspend host
5408  *      @host: host to suspend
5409  *      @mesg: PM message
5410  *
5411  *      Suspend @host.  Actual operation is performed by EH.  This
5412  *      function requests EH to perform PM operations and waits for EH
5413  *      to finish.
5414  *
5415  *      LOCKING:
5416  *      Kernel thread context (may sleep).
5417  *
5418  *      RETURNS:
5419  *      0 on success, -errno on failure.
5420  */
5421 int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
5422 {
5423         int i, j, rc;
5424
5425         rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1);
5426         if (rc)
5427                 goto fail;
5428
5429         /* EH is quiescent now.  Fail if we have any ready device.
5430          * This happens if hotplug occurs between completion of device
5431          * suspension and here.
5432          */
5433         for (i = 0; i < host->n_ports; i++) {
5434                 struct ata_port *ap = host->ports[i];
5435
5436                 for (j = 0; j < ATA_MAX_DEVICES; j++) {
5437                         struct ata_device *dev = &ap->device[j];
5438
5439                         if (ata_dev_ready(dev)) {
5440                                 ata_port_printk(ap, KERN_WARNING,
5441                                                 "suspend failed, device %d "
5442                                                 "still active\n", dev->devno);
5443                                 rc = -EBUSY;
5444                                 goto fail;
5445                         }
5446                 }
5447         }
5448
5449         host->dev->power.power_state = mesg;
5450         return 0;
5451
5452  fail:
5453         ata_host_resume(host);
5454         return rc;
5455 }
5456
5457 /**
5458  *      ata_host_resume - resume host
5459  *      @host: host to resume
5460  *
5461  *      Resume @host.  Actual operation is performed by EH.  This
5462  *      function requests EH to perform PM operations and returns.
5463  *      Note that all resume operations are performed parallely.
5464  *
5465  *      LOCKING:
5466  *      Kernel thread context (may sleep).
5467  */
5468 void ata_host_resume(struct ata_host *host)
5469 {
5470         ata_host_request_pm(host, PMSG_ON, ATA_EH_SOFTRESET,
5471                             ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0);
5472         host->dev->power.power_state = PMSG_ON;
5473 }
5474 #endif
5475
5476 /**
5477  *      ata_port_start - Set port up for dma.
5478  *      @ap: Port to initialize
5479  *
5480  *      Called just after data structures for each port are
5481  *      initialized.  Allocates space for PRD table.
5482  *
5483  *      May be used as the port_start() entry in ata_port_operations.
5484  *
5485  *      LOCKING:
5486  *      Inherited from caller.
5487  */
5488 int ata_port_start(struct ata_port *ap)
5489 {
5490         struct device *dev = ap->dev;
5491         int rc;
5492
5493         ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma,
5494                                       GFP_KERNEL);
5495         if (!ap->prd)
5496                 return -ENOMEM;
5497
5498         rc = ata_pad_alloc(ap, dev);
5499         if (rc)
5500                 return rc;
5501
5502         DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd,
5503                 (unsigned long long)ap->prd_dma);
5504         return 0;
5505 }
5506
5507 /**
5508  *      ata_dev_init - Initialize an ata_device structure
5509  *      @dev: Device structure to initialize
5510  *
5511  *      Initialize @dev in preparation for probing.
5512  *
5513  *      LOCKING:
5514  *      Inherited from caller.
5515  */
5516 void ata_dev_init(struct ata_device *dev)
5517 {
5518         struct ata_port *ap = dev->ap;
5519         unsigned long flags;
5520
5521         /* SATA spd limit is bound to the first device */
5522         ap->sata_spd_limit = ap->hw_sata_spd_limit;
5523
5524         /* High bits of dev->flags are used to record warm plug
5525          * requests which occur asynchronously.  Synchronize using
5526          * host lock.
5527          */
5528         spin_lock_irqsave(ap->lock, flags);
5529         dev->flags &= ~ATA_DFLAG_INIT_MASK;
5530         spin_unlock_irqrestore(ap->lock, flags);
5531
5532         memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0,
5533                sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET);
5534         dev->pio_mask = UINT_MAX;
5535         dev->mwdma_mask = UINT_MAX;
5536         dev->udma_mask = UINT_MAX;
5537 }
5538
5539 /**
5540  *      ata_port_init - Initialize an ata_port structure
5541  *      @ap: Structure to initialize
5542  *      @host: Collection of hosts to which @ap belongs
5543  *      @ent: Probe information provided by low-level driver
5544  *      @port_no: Port number associated with this ata_port
5545  *
5546  *      Initialize a new ata_port structure.
5547  *
5548  *      LOCKING:
5549  *      Inherited from caller.
5550  */
5551 void ata_port_init(struct ata_port *ap, struct ata_host *host,
5552                    const struct ata_probe_ent *ent, unsigned int port_no)
5553 {
5554         unsigned int i;
5555
5556         ap->lock = &host->lock;
5557         ap->flags = ATA_FLAG_DISABLED;
5558         ap->print_id = ata_print_id++;
5559         ap->ctl = ATA_DEVCTL_OBS;
5560         ap->host = host;
5561         ap->dev = ent->dev;
5562         ap->port_no = port_no;
5563         if (port_no == 1 && ent->pinfo2) {
5564                 ap->pio_mask = ent->pinfo2->pio_mask;
5565                 ap->mwdma_mask = ent->pinfo2->mwdma_mask;
5566                 ap->udma_mask = ent->pinfo2->udma_mask;
5567                 ap->flags |= ent->pinfo2->flags;
5568                 ap->ops = ent->pinfo2->port_ops;
5569         } else {
5570                 ap->pio_mask = ent->pio_mask;
5571                 ap->mwdma_mask = ent->mwdma_mask;
5572                 ap->udma_mask = ent->udma_mask;
5573                 ap->flags |= ent->port_flags;
5574                 ap->ops = ent->port_ops;
5575         }
5576         ap->hw_sata_spd_limit = UINT_MAX;
5577         ap->active_tag = ATA_TAG_POISON;
5578         ap->last_ctl = 0xFF;
5579
5580 #if defined(ATA_VERBOSE_DEBUG)
5581         /* turn on all debugging levels */
5582         ap->msg_enable = 0x00FF;
5583 #elif defined(ATA_DEBUG)
5584         ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
5585 #else
5586         ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN;
5587 #endif
5588
5589         INIT_DELAYED_WORK(&ap->port_task, NULL);
5590         INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
5591         INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
5592         INIT_LIST_HEAD(&ap->eh_done_q);
5593         init_waitqueue_head(&ap->eh_wait_q);
5594
5595         /* set cable type */
5596         ap->cbl = ATA_CBL_NONE;
5597         if (ap->flags & ATA_FLAG_SATA)
5598                 ap->cbl = ATA_CBL_SATA;
5599
5600         for (i = 0; i < ATA_MAX_DEVICES; i++) {
5601                 struct ata_device *dev = &ap->device[i];
5602                 dev->ap = ap;
5603                 dev->devno = i;
5604                 ata_dev_init(dev);
5605         }
5606
5607 #ifdef ATA_IRQ_TRAP
5608         ap->stats.unhandled_irq = 1;
5609         ap->stats.idle_irq = 1;
5610 #endif
5611
5612         memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
5613 }
5614
5615 /**
5616  *      ata_port_init_shost - Initialize SCSI host associated with ATA port
5617  *      @ap: ATA port to initialize SCSI host for
5618  *      @shost: SCSI host associated with @ap
5619  *
5620  *      Initialize SCSI host @shost associated with ATA port @ap.
5621  *
5622  *      LOCKING:
5623  *      Inherited from caller.
5624  */
5625 static void ata_port_init_shost(struct ata_port *ap, struct Scsi_Host *shost)
5626 {
5627         ap->scsi_host = shost;
5628
5629         shost->unique_id = ap->print_id;
5630         shost->max_id = 16;
5631         shost->max_lun = 1;
5632         shost->max_channel = 1;
5633         shost->max_cmd_len = 12;
5634 }
5635
5636 /**
5637  *      ata_port_add - Attach low-level ATA driver to system
5638  *      @ent: Information provided by low-level driver
5639  *      @host: Collections of ports to which we add
5640  *      @port_no: Port number associated with this host
5641  *
5642  *      Attach low-level ATA driver to system.
5643  *
5644  *      LOCKING:
5645  *      PCI/etc. bus probe sem.
5646  *
5647  *      RETURNS:
5648  *      New ata_port on success, for NULL on error.
5649  */
5650 static struct ata_port * ata_port_add(const struct ata_probe_ent *ent,
5651                                       struct ata_host *host,
5652                                       unsigned int port_no)
5653 {
5654         struct Scsi_Host *shost;
5655         struct ata_port *ap;
5656
5657         DPRINTK("ENTER\n");
5658
5659         if (!ent->port_ops->error_handler &&
5660             !(ent->port_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
5661                 printk(KERN_ERR "ata%u: no reset mechanism available\n",
5662                        port_no);
5663                 return NULL;
5664         }
5665
5666         shost = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
5667         if (!shost)
5668                 return NULL;
5669
5670         shost->transportt = &ata_scsi_transport_template;
5671
5672         ap = ata_shost_to_port(shost);
5673
5674         ata_port_init(ap, host, ent, port_no);
5675         ata_port_init_shost(ap, shost);
5676
5677         return ap;
5678 }
5679
5680 static void ata_host_release(struct device *gendev, void *res)
5681 {
5682         struct ata_host *host = dev_get_drvdata(gendev);
5683         int i;
5684
5685         for (i = 0; i < host->n_ports; i++) {
5686                 struct ata_port *ap = host->ports[i];
5687
5688                 if (ap && ap->ops->port_stop)
5689                         ap->ops->port_stop(ap);
5690         }
5691
5692         if (host->ops->host_stop)
5693                 host->ops->host_stop(host);
5694
5695         for (i = 0; i < host->n_ports; i++) {
5696                 struct ata_port *ap = host->ports[i];
5697
5698                 if (ap)
5699                         scsi_host_put(ap->scsi_host);
5700
5701                 host->ports[i] = NULL;
5702         }
5703
5704         dev_set_drvdata(gendev, NULL);
5705 }
5706
5707 /**
5708  *      ata_sas_host_init - Initialize a host struct
5709  *      @host:  host to initialize
5710  *      @dev:   device host is attached to
5711  *      @flags: host flags
5712  *      @ops:   port_ops
5713  *
5714  *      LOCKING:
5715  *      PCI/etc. bus probe sem.
5716  *
5717  */
5718
5719 void ata_host_init(struct ata_host *host, struct device *dev,
5720                    unsigned long flags, const struct ata_port_operations *ops)
5721 {
5722         spin_lock_init(&host->lock);
5723         host->dev = dev;
5724         host->flags = flags;
5725         host->ops = ops;
5726 }
5727
5728 /**
5729  *      ata_device_add - Register hardware device with ATA and SCSI layers
5730  *      @ent: Probe information describing hardware device to be registered
5731  *
5732  *      This function processes the information provided in the probe
5733  *      information struct @ent, allocates the necessary ATA and SCSI
5734  *      host information structures, initializes them, and registers
5735  *      everything with requisite kernel subsystems.
5736  *
5737  *      This function requests irqs, probes the ATA bus, and probes
5738  *      the SCSI bus.
5739  *
5740  *      LOCKING:
5741  *      PCI/etc. bus probe sem.
5742  *
5743  *      RETURNS:
5744  *      Number of ports registered.  Zero on error (no ports registered).
5745  */
5746 int ata_device_add(const struct ata_probe_ent *ent)
5747 {
5748         unsigned int i;
5749         struct device *dev = ent->dev;
5750         struct ata_host *host;
5751         int rc;
5752
5753         DPRINTK("ENTER\n");
5754
5755         if (ent->irq == 0) {
5756                 dev_printk(KERN_ERR, dev, "is not available: No interrupt assigned.\n");
5757                 return 0;
5758         }
5759
5760         if (!devres_open_group(dev, ata_device_add, GFP_KERNEL))
5761                 return 0;
5762
5763         /* alloc a container for our list of ATA ports (buses) */
5764         host = devres_alloc(ata_host_release, sizeof(struct ata_host) +
5765                             (ent->n_ports * sizeof(void *)), GFP_KERNEL);
5766         if (!host)
5767                 goto err_out;
5768         devres_add(dev, host);
5769         dev_set_drvdata(dev, host);
5770
5771         ata_host_init(host, dev, ent->_host_flags, ent->port_ops);
5772         host->n_ports = ent->n_ports;
5773         host->irq = ent->irq;
5774         host->irq2 = ent->irq2;
5775         host->iomap = ent->iomap;
5776         host->private_data = ent->private_data;
5777
5778         /* register each port bound to this device */
5779         for (i = 0; i < host->n_ports; i++) {
5780                 struct ata_port *ap;
5781                 unsigned long xfer_mode_mask;
5782                 int irq_line = ent->irq;
5783
5784                 ap = ata_port_add(ent, host, i);
5785                 host->ports[i] = ap;
5786                 if (!ap)
5787                         goto err_out;
5788
5789                 /* dummy? */
5790                 if (ent->dummy_port_mask & (1 << i)) {
5791                         ata_port_printk(ap, KERN_INFO, "DUMMY\n");
5792                         ap->ops = &ata_dummy_port_ops;
5793                         continue;
5794                 }
5795
5796                 /* start port */
5797                 rc = ap->ops->port_start(ap);
5798                 if (rc) {
5799                         host->ports[i] = NULL;
5800                         scsi_host_put(ap->scsi_host);
5801                         goto err_out;
5802                 }
5803
5804                 /* Report the secondary IRQ for second channel legacy */
5805                 if (i == 1 && ent->irq2)
5806                         irq_line = ent->irq2;
5807
5808                 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
5809                                 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
5810                                 (ap->pio_mask << ATA_SHIFT_PIO);
5811
5812                 /* print per-port info to dmesg */
5813                 ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%p "
5814                                 "ctl 0x%p bmdma 0x%p irq %d\n",
5815                                 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
5816                                 ata_mode_string(xfer_mode_mask),
5817                                 ap->ioaddr.cmd_addr,
5818                                 ap->ioaddr.ctl_addr,
5819                                 ap->ioaddr.bmdma_addr,
5820                                 irq_line);
5821
5822                 /* freeze port before requesting IRQ */
5823                 ata_eh_freeze_port(ap);
5824         }
5825
5826         /* obtain irq, that may be shared between channels */
5827         rc = devm_request_irq(dev, ent->irq, ent->port_ops->irq_handler,
5828                               ent->irq_flags, DRV_NAME, host);
5829         if (rc) {
5830                 dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n",
5831                            ent->irq, rc);
5832                 goto err_out;
5833         }
5834
5835         /* do we have a second IRQ for the other channel, eg legacy mode */
5836         if (ent->irq2) {
5837                 /* We will get weird core code crashes later if this is true
5838                    so trap it now */
5839                 BUG_ON(ent->irq == ent->irq2);
5840
5841                 rc = devm_request_irq(dev, ent->irq2,
5842                                 ent->port_ops->irq_handler, ent->irq_flags,
5843                                 DRV_NAME, host);
5844                 if (rc) {
5845                         dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n",
5846                                    ent->irq2, rc);
5847                         goto err_out;
5848                 }
5849         }
5850
5851         /* resource acquisition complete */
5852         devres_remove_group(dev, ata_device_add);
5853
5854         /* perform each probe synchronously */
5855         DPRINTK("probe begin\n");
5856         for (i = 0; i < host->n_ports; i++) {
5857                 struct ata_port *ap = host->ports[i];
5858                 u32 scontrol;
5859                 int rc;
5860
5861                 /* init sata_spd_limit to the current value */
5862                 if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
5863                         int spd = (scontrol >> 4) & 0xf;
5864                         ap->hw_sata_spd_limit &= (1 << spd) - 1;
5865                 }
5866                 ap->sata_spd_limit = ap->hw_sata_spd_limit;
5867
5868                 rc = scsi_add_host(ap->scsi_host, dev);
5869                 if (rc) {
5870                         ata_port_printk(ap, KERN_ERR, "scsi_add_host failed\n");
5871                         /* FIXME: do something useful here */
5872                         /* FIXME: handle unconditional calls to
5873                          * scsi_scan_host and ata_host_remove, below,
5874                          * at the very least
5875                          */
5876                 }
5877
5878                 if (ap->ops->error_handler) {
5879                         struct ata_eh_info *ehi = &ap->eh_info;
5880                         unsigned long flags;
5881
5882                         ata_port_probe(ap);
5883
5884                         /* kick EH for boot probing */
5885                         spin_lock_irqsave(ap->lock, flags);
5886
5887                         ehi->probe_mask = (1 << ATA_MAX_DEVICES) - 1;
5888                         ehi->action |= ATA_EH_SOFTRESET;
5889                         ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
5890
5891                         ap->pflags |= ATA_PFLAG_LOADING;
5892                         ata_port_schedule_eh(ap);
5893
5894                         spin_unlock_irqrestore(ap->lock, flags);
5895
5896                         /* wait for EH to finish */
5897                         ata_port_wait_eh(ap);
5898                 } else {
5899                         DPRINTK("ata%u: bus probe begin\n", ap->print_id);
5900                         rc = ata_bus_probe(ap);
5901                         DPRINTK("ata%u: bus probe end\n", ap->print_id);
5902
5903                         if (rc) {
5904                                 /* FIXME: do something useful here?
5905                                  * Current libata behavior will
5906                                  * tear down everything when
5907                                  * the module is removed
5908                                  * or the h/w is unplugged.
5909                                  */
5910                         }
5911                 }
5912         }
5913
5914         /* probes are done, now scan each port's disk(s) */
5915         DPRINTK("host probe begin\n");
5916         for (i = 0; i < host->n_ports; i++) {
5917                 struct ata_port *ap = host->ports[i];
5918
5919                 ata_scsi_scan_host(ap);
5920         }
5921
5922         VPRINTK("EXIT, returning %u\n", ent->n_ports);
5923         return ent->n_ports; /* success */
5924
5925  err_out:
5926         devres_release_group(dev, ata_device_add);
5927         VPRINTK("EXIT, returning %d\n", rc);
5928         return 0;
5929 }
5930
5931 /**
5932  *      ata_port_detach - Detach ATA port in prepration of device removal
5933  *      @ap: ATA port to be detached
5934  *
5935  *      Detach all ATA devices and the associated SCSI devices of @ap;
5936  *      then, remove the associated SCSI host.  @ap is guaranteed to
5937  *      be quiescent on return from this function.
5938  *
5939  *      LOCKING:
5940  *      Kernel thread context (may sleep).
5941  */
5942 void ata_port_detach(struct ata_port *ap)
5943 {
5944         unsigned long flags;
5945         int i;
5946
5947         if (!ap->ops->error_handler)
5948                 goto skip_eh;
5949
5950         /* tell EH we're leaving & flush EH */
5951         spin_lock_irqsave(ap->lock, flags);
5952         ap->pflags |= ATA_PFLAG_UNLOADING;
5953         spin_unlock_irqrestore(ap->lock, flags);
5954
5955         ata_port_wait_eh(ap);
5956
5957         /* EH is now guaranteed to see UNLOADING, so no new device
5958          * will be attached.  Disable all existing devices.
5959          */
5960         spin_lock_irqsave(ap->lock, flags);
5961
5962         for (i = 0; i < ATA_MAX_DEVICES; i++)
5963                 ata_dev_disable(&ap->device[i]);
5964
5965         spin_unlock_irqrestore(ap->lock, flags);
5966
5967         /* Final freeze & EH.  All in-flight commands are aborted.  EH
5968          * will be skipped and retrials will be terminated with bad
5969          * target.
5970          */
5971         spin_lock_irqsave(ap->lock, flags);
5972         ata_port_freeze(ap);    /* won't be thawed */
5973         spin_unlock_irqrestore(ap->lock, flags);
5974
5975         ata_port_wait_eh(ap);
5976
5977         /* Flush hotplug task.  The sequence is similar to
5978          * ata_port_flush_task().
5979          */
5980         flush_workqueue(ata_aux_wq);
5981         cancel_delayed_work(&ap->hotplug_task);
5982         flush_workqueue(ata_aux_wq);
5983
5984  skip_eh:
5985         /* remove the associated SCSI host */
5986         scsi_remove_host(ap->scsi_host);
5987 }
5988
5989 /**
5990  *      ata_host_detach - Detach all ports of an ATA host
5991  *      @host: Host to detach
5992  *
5993  *      Detach all ports of @host.
5994  *
5995  *      LOCKING:
5996  *      Kernel thread context (may sleep).
5997  */
5998 void ata_host_detach(struct ata_host *host)
5999 {
6000         int i;
6001
6002         for (i = 0; i < host->n_ports; i++)
6003                 ata_port_detach(host->ports[i]);
6004 }
6005
6006 struct ata_probe_ent *
6007 ata_probe_ent_alloc(struct device *dev, const struct ata_port_info *port)
6008 {
6009         struct ata_probe_ent *probe_ent;
6010
6011         probe_ent = devm_kzalloc(dev, sizeof(*probe_ent), GFP_KERNEL);
6012         if (!probe_ent) {
6013                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
6014                        kobject_name(&(dev->kobj)));
6015                 return NULL;
6016         }
6017
6018         INIT_LIST_HEAD(&probe_ent->node);
6019         probe_ent->dev = dev;
6020
6021         probe_ent->sht = port->sht;
6022         probe_ent->port_flags = port->flags;
6023         probe_ent->pio_mask = port->pio_mask;
6024         probe_ent->mwdma_mask = port->mwdma_mask;
6025         probe_ent->udma_mask = port->udma_mask;
6026         probe_ent->port_ops = port->port_ops;
6027         probe_ent->private_data = port->private_data;
6028
6029         return probe_ent;
6030 }
6031
6032 /**
6033  *      ata_std_ports - initialize ioaddr with standard port offsets.
6034  *      @ioaddr: IO address structure to be initialized
6035  *
6036  *      Utility function which initializes data_addr, error_addr,
6037  *      feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
6038  *      device_addr, status_addr, and command_addr to standard offsets
6039  *      relative to cmd_addr.
6040  *
6041  *      Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
6042  */
6043
6044 void ata_std_ports(struct ata_ioports *ioaddr)
6045 {
6046         ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
6047         ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
6048         ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
6049         ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
6050         ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
6051         ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
6052         ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
6053         ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
6054         ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
6055         ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
6056 }
6057
6058
6059 #ifdef CONFIG_PCI
6060
6061 /**
6062  *      ata_pci_remove_one - PCI layer callback for device removal
6063  *      @pdev: PCI device that was removed
6064  *
6065  *      PCI layer indicates to libata via this hook that hot-unplug or
6066  *      module unload event has occurred.  Detach all ports.  Resource
6067  *      release is handled via devres.
6068  *
6069  *      LOCKING:
6070  *      Inherited from PCI layer (may sleep).
6071  */
6072 void ata_pci_remove_one(struct pci_dev *pdev)
6073 {
6074         struct device *dev = pci_dev_to_dev(pdev);
6075         struct ata_host *host = dev_get_drvdata(dev);
6076
6077         ata_host_detach(host);
6078 }
6079
6080 /* move to PCI subsystem */
6081 int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
6082 {
6083         unsigned long tmp = 0;
6084
6085         switch (bits->width) {
6086         case 1: {
6087                 u8 tmp8 = 0;
6088                 pci_read_config_byte(pdev, bits->reg, &tmp8);
6089                 tmp = tmp8;
6090                 break;
6091         }
6092         case 2: {
6093                 u16 tmp16 = 0;
6094                 pci_read_config_word(pdev, bits->reg, &tmp16);
6095                 tmp = tmp16;
6096                 break;
6097         }
6098         case 4: {
6099                 u32 tmp32 = 0;
6100                 pci_read_config_dword(pdev, bits->reg, &tmp32);
6101                 tmp = tmp32;
6102                 break;
6103         }
6104
6105         default:
6106                 return -EINVAL;
6107         }
6108
6109         tmp &= bits->mask;
6110
6111         return (tmp == bits->val) ? 1 : 0;
6112 }
6113
6114 #ifdef CONFIG_PM
6115 void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
6116 {
6117         pci_save_state(pdev);
6118         pci_disable_device(pdev);
6119
6120         if (mesg.event == PM_EVENT_SUSPEND)
6121                 pci_set_power_state(pdev, PCI_D3hot);
6122 }
6123
6124 int ata_pci_device_do_resume(struct pci_dev *pdev)
6125 {
6126         int rc;
6127
6128         pci_set_power_state(pdev, PCI_D0);
6129         pci_restore_state(pdev);
6130
6131         rc = pcim_enable_device(pdev);
6132         if (rc) {
6133                 dev_printk(KERN_ERR, &pdev->dev,
6134                            "failed to enable device after resume (%d)\n", rc);
6135                 return rc;
6136         }
6137
6138         pci_set_master(pdev);
6139         return 0;
6140 }
6141
6142 int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
6143 {
6144         struct ata_host *host = dev_get_drvdata(&pdev->dev);
6145         int rc = 0;
6146
6147         rc = ata_host_suspend(host, mesg);
6148         if (rc)
6149                 return rc;
6150
6151         ata_pci_device_do_suspend(pdev, mesg);
6152
6153         return 0;
6154 }
6155
6156 int ata_pci_device_resume(struct pci_dev *pdev)
6157 {
6158         struct ata_host *host = dev_get_drvdata(&pdev->dev);
6159         int rc;
6160
6161         rc = ata_pci_device_do_resume(pdev);
6162         if (rc == 0)
6163                 ata_host_resume(host);
6164         return rc;
6165 }
6166 #endif /* CONFIG_PM */
6167
6168 #endif /* CONFIG_PCI */
6169
6170
6171 static int __init ata_init(void)
6172 {
6173         ata_probe_timeout *= HZ;
6174         ata_wq = create_workqueue("ata");
6175         if (!ata_wq)
6176                 return -ENOMEM;
6177
6178         ata_aux_wq = create_singlethread_workqueue("ata_aux");
6179         if (!ata_aux_wq) {
6180                 destroy_workqueue(ata_wq);
6181                 return -ENOMEM;
6182         }
6183
6184         printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
6185         return 0;
6186 }
6187
6188 static void __exit ata_exit(void)
6189 {
6190         destroy_workqueue(ata_wq);
6191         destroy_workqueue(ata_aux_wq);
6192 }
6193
6194 subsys_initcall(ata_init);
6195 module_exit(ata_exit);
6196
6197 static unsigned long ratelimit_time;
6198 static DEFINE_SPINLOCK(ata_ratelimit_lock);
6199
6200 int ata_ratelimit(void)
6201 {
6202         int rc;
6203         unsigned long flags;
6204
6205         spin_lock_irqsave(&ata_ratelimit_lock, flags);
6206
6207         if (time_after(jiffies, ratelimit_time)) {
6208                 rc = 1;
6209                 ratelimit_time = jiffies + (HZ/5);
6210         } else
6211                 rc = 0;
6212
6213         spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
6214
6215         return rc;
6216 }
6217
6218 /**
6219  *      ata_wait_register - wait until register value changes
6220  *      @reg: IO-mapped register
6221  *      @mask: Mask to apply to read register value
6222  *      @val: Wait condition
6223  *      @interval_msec: polling interval in milliseconds
6224  *      @timeout_msec: timeout in milliseconds
6225  *
6226  *      Waiting for some bits of register to change is a common
6227  *      operation for ATA controllers.  This function reads 32bit LE
6228  *      IO-mapped register @reg and tests for the following condition.
6229  *
6230  *      (*@reg & mask) != val
6231  *
6232  *      If the condition is met, it returns; otherwise, the process is
6233  *      repeated after @interval_msec until timeout.
6234  *
6235  *      LOCKING:
6236  *      Kernel thread context (may sleep)
6237  *
6238  *      RETURNS:
6239  *      The final register value.
6240  */
6241 u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
6242                       unsigned long interval_msec,
6243                       unsigned long timeout_msec)
6244 {
6245         unsigned long timeout;
6246         u32 tmp;
6247
6248         tmp = ioread32(reg);
6249
6250         /* Calculate timeout _after_ the first read to make sure
6251          * preceding writes reach the controller before starting to
6252          * eat away the timeout.
6253          */
6254         timeout = jiffies + (timeout_msec * HZ) / 1000;
6255
6256         while ((tmp & mask) == val && time_before(jiffies, timeout)) {
6257                 msleep(interval_msec);
6258                 tmp = ioread32(reg);
6259         }
6260
6261         return tmp;
6262 }
6263
6264 /*
6265  * Dummy port_ops
6266  */
6267 static void ata_dummy_noret(struct ata_port *ap)        { }
6268 static int ata_dummy_ret0(struct ata_port *ap)          { return 0; }
6269 static void ata_dummy_qc_noret(struct ata_queued_cmd *qc) { }
6270
6271 static u8 ata_dummy_check_status(struct ata_port *ap)
6272 {
6273         return ATA_DRDY;
6274 }
6275
6276 static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
6277 {
6278         return AC_ERR_SYSTEM;
6279 }
6280
6281 const struct ata_port_operations ata_dummy_port_ops = {
6282         .port_disable           = ata_port_disable,
6283         .check_status           = ata_dummy_check_status,
6284         .check_altstatus        = ata_dummy_check_status,
6285         .dev_select             = ata_noop_dev_select,
6286         .qc_prep                = ata_noop_qc_prep,
6287         .qc_issue               = ata_dummy_qc_issue,
6288         .freeze                 = ata_dummy_noret,
6289         .thaw                   = ata_dummy_noret,
6290         .error_handler          = ata_dummy_noret,
6291         .post_internal_cmd      = ata_dummy_qc_noret,
6292         .irq_clear              = ata_dummy_noret,
6293         .port_start             = ata_dummy_ret0,
6294         .port_stop              = ata_dummy_noret,
6295 };
6296
6297 /*
6298  * libata is essentially a library of internal helper functions for
6299  * low-level ATA host controller drivers.  As such, the API/ABI is
6300  * likely to change as new drivers are added and updated.
6301  * Do not depend on ABI/API stability.
6302  */
6303
6304 EXPORT_SYMBOL_GPL(sata_deb_timing_normal);
6305 EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug);
6306 EXPORT_SYMBOL_GPL(sata_deb_timing_long);
6307 EXPORT_SYMBOL_GPL(ata_dummy_port_ops);
6308 EXPORT_SYMBOL_GPL(ata_std_bios_param);
6309 EXPORT_SYMBOL_GPL(ata_std_ports);
6310 EXPORT_SYMBOL_GPL(ata_host_init);
6311 EXPORT_SYMBOL_GPL(ata_device_add);
6312 EXPORT_SYMBOL_GPL(ata_host_detach);
6313 EXPORT_SYMBOL_GPL(ata_sg_init);
6314 EXPORT_SYMBOL_GPL(ata_sg_init_one);
6315 EXPORT_SYMBOL_GPL(ata_hsm_move);
6316 EXPORT_SYMBOL_GPL(ata_qc_complete);
6317 EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
6318 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
6319 EXPORT_SYMBOL_GPL(ata_tf_load);
6320 EXPORT_SYMBOL_GPL(ata_tf_read);
6321 EXPORT_SYMBOL_GPL(ata_noop_dev_select);
6322 EXPORT_SYMBOL_GPL(ata_std_dev_select);
6323 EXPORT_SYMBOL_GPL(ata_tf_to_fis);
6324 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
6325 EXPORT_SYMBOL_GPL(ata_check_status);
6326 EXPORT_SYMBOL_GPL(ata_altstatus);
6327 EXPORT_SYMBOL_GPL(ata_exec_command);
6328 EXPORT_SYMBOL_GPL(ata_port_start);
6329 EXPORT_SYMBOL_GPL(ata_interrupt);
6330 EXPORT_SYMBOL_GPL(ata_data_xfer);
6331 EXPORT_SYMBOL_GPL(ata_data_xfer_noirq);
6332 EXPORT_SYMBOL_GPL(ata_qc_prep);
6333 EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
6334 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
6335 EXPORT_SYMBOL_GPL(ata_bmdma_start);
6336 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
6337 EXPORT_SYMBOL_GPL(ata_bmdma_status);
6338 EXPORT_SYMBOL_GPL(ata_bmdma_stop);
6339 EXPORT_SYMBOL_GPL(ata_bmdma_freeze);
6340 EXPORT_SYMBOL_GPL(ata_bmdma_thaw);
6341 EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh);
6342 EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);
6343 EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
6344 EXPORT_SYMBOL_GPL(ata_port_probe);
6345 EXPORT_SYMBOL_GPL(ata_dev_disable);
6346 EXPORT_SYMBOL_GPL(sata_set_spd);
6347 EXPORT_SYMBOL_GPL(sata_phy_debounce);
6348 EXPORT_SYMBOL_GPL(sata_phy_resume);
6349 EXPORT_SYMBOL_GPL(sata_phy_reset);
6350 EXPORT_SYMBOL_GPL(__sata_phy_reset);
6351 EXPORT_SYMBOL_GPL(ata_bus_reset);
6352 EXPORT_SYMBOL_GPL(ata_std_prereset);
6353 EXPORT_SYMBOL_GPL(ata_std_softreset);
6354 EXPORT_SYMBOL_GPL(sata_port_hardreset);
6355 EXPORT_SYMBOL_GPL(sata_std_hardreset);
6356 EXPORT_SYMBOL_GPL(ata_std_postreset);
6357 EXPORT_SYMBOL_GPL(ata_dev_classify);
6358 EXPORT_SYMBOL_GPL(ata_dev_pair);
6359 EXPORT_SYMBOL_GPL(ata_port_disable);
6360 EXPORT_SYMBOL_GPL(ata_ratelimit);
6361 EXPORT_SYMBOL_GPL(ata_wait_register);
6362 EXPORT_SYMBOL_GPL(ata_busy_sleep);
6363 EXPORT_SYMBOL_GPL(ata_port_queue_task);
6364 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
6365 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
6366 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
6367 EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
6368 EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
6369 EXPORT_SYMBOL_GPL(ata_host_intr);
6370 EXPORT_SYMBOL_GPL(sata_scr_valid);
6371 EXPORT_SYMBOL_GPL(sata_scr_read);
6372 EXPORT_SYMBOL_GPL(sata_scr_write);
6373 EXPORT_SYMBOL_GPL(sata_scr_write_flush);
6374 EXPORT_SYMBOL_GPL(ata_port_online);
6375 EXPORT_SYMBOL_GPL(ata_port_offline);
6376 #ifdef CONFIG_PM
6377 EXPORT_SYMBOL_GPL(ata_host_suspend);
6378 EXPORT_SYMBOL_GPL(ata_host_resume);
6379 #endif /* CONFIG_PM */
6380 EXPORT_SYMBOL_GPL(ata_id_string);
6381 EXPORT_SYMBOL_GPL(ata_id_c_string);
6382 EXPORT_SYMBOL_GPL(ata_id_to_dma_mode);
6383 EXPORT_SYMBOL_GPL(ata_device_blacklisted);
6384 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
6385
6386 EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
6387 EXPORT_SYMBOL_GPL(ata_timing_compute);
6388 EXPORT_SYMBOL_GPL(ata_timing_merge);
6389
6390 #ifdef CONFIG_PCI
6391 EXPORT_SYMBOL_GPL(pci_test_config_bits);
6392 EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
6393 EXPORT_SYMBOL_GPL(ata_pci_init_one);
6394 EXPORT_SYMBOL_GPL(ata_pci_remove_one);
6395 #ifdef CONFIG_PM
6396 EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend);
6397 EXPORT_SYMBOL_GPL(ata_pci_device_do_resume);
6398 EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
6399 EXPORT_SYMBOL_GPL(ata_pci_device_resume);
6400 #endif /* CONFIG_PM */
6401 EXPORT_SYMBOL_GPL(ata_pci_default_filter);
6402 EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
6403 #endif /* CONFIG_PCI */
6404
6405 #ifdef CONFIG_PM
6406 EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
6407 EXPORT_SYMBOL_GPL(ata_scsi_device_resume);
6408 #endif /* CONFIG_PM */
6409
6410 EXPORT_SYMBOL_GPL(ata_eng_timeout);
6411 EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
6412 EXPORT_SYMBOL_GPL(ata_port_abort);
6413 EXPORT_SYMBOL_GPL(ata_port_freeze);
6414 EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
6415 EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
6416 EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
6417 EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
6418 EXPORT_SYMBOL_GPL(ata_do_eh);
6419 EXPORT_SYMBOL_GPL(ata_irq_on);
6420 EXPORT_SYMBOL_GPL(ata_dummy_irq_on);
6421 EXPORT_SYMBOL_GPL(ata_irq_ack);
6422 EXPORT_SYMBOL_GPL(ata_dummy_irq_ack);
6423 EXPORT_SYMBOL_GPL(ata_dev_try_classify);