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