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