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