blob: b046ffa22101ccb3c8cbc9c6d6453abd8ef20e4d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jeff Garzikaf36d7f2005-08-28 20:18:39 -04002 * 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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 */
34
35#include <linux/config.h>
36#include <linux/kernel.h>
37#include <linux/module.h>
38#include <linux/pci.h>
39#include <linux/init.h>
40#include <linux/list.h>
41#include <linux/mm.h>
42#include <linux/highmem.h>
43#include <linux/spinlock.h>
44#include <linux/blkdev.h>
45#include <linux/delay.h>
46#include <linux/timer.h>
47#include <linux/interrupt.h>
48#include <linux/completion.h>
49#include <linux/suspend.h>
50#include <linux/workqueue.h>
Jeff Garzik67846b32005-10-05 02:58:32 -040051#include <linux/jiffies.h>
David Hardeman378f0582005-09-17 17:55:31 +100052#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <scsi/scsi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include "scsi_priv.h"
Jeff Garzik193515d2005-11-07 00:59:37 -050055#include <scsi/scsi_cmnd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <scsi/scsi_host.h>
57#include <linux/libata.h>
58#include <asm/io.h>
59#include <asm/semaphore.h>
60#include <asm/byteorder.h>
61
62#include "libata.h"
63
Tejun Heo6aff8f12006-02-15 18:24:09 +090064static unsigned int ata_dev_init_params(struct ata_port *ap,
Albert Lee00b6f5e2006-03-27 16:39:18 +080065 struct ata_device *dev,
66 u16 heads,
67 u16 sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068static void ata_set_mode(struct ata_port *ap);
Tejun Heo83206a22006-03-24 15:25:31 +090069static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
70 struct ata_device *dev);
Tejun Heoacf356b2006-03-24 14:07:50 +090071static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73static unsigned int ata_unique_id = 1;
74static struct workqueue_struct *ata_wq;
75
Jeff Garzik418dc1f2006-03-11 20:50:08 -050076int atapi_enabled = 1;
Jeff Garzik1623c812005-08-30 03:37:42 -040077module_param(atapi_enabled, int, 0444);
78MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
79
Jeff Garzikc3c013a2006-02-27 22:31:19 -050080int libata_fua = 0;
81module_param_named(fua, libata_fua, int, 0444);
82MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084MODULE_AUTHOR("Jeff Garzik");
85MODULE_DESCRIPTION("Library module for ATA devices");
86MODULE_LICENSE("GPL");
87MODULE_VERSION(DRV_VERSION);
88
Edward Falk0baab862005-06-02 18:17:13 -040089
90/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
92 * @tf: Taskfile to convert
93 * @fis: Buffer into which data will output
94 * @pmp: Port multiplier port
95 *
96 * Converts a standard ATA taskfile to a Serial ATA
97 * FIS structure (Register - Host to Device).
98 *
99 * LOCKING:
100 * Inherited from caller.
101 */
102
Jeff Garzik057ace52005-10-22 14:27:05 -0400103void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104{
105 fis[0] = 0x27; /* Register - Host to Device FIS */
106 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
107 bit 7 indicates Command FIS */
108 fis[2] = tf->command;
109 fis[3] = tf->feature;
110
111 fis[4] = tf->lbal;
112 fis[5] = tf->lbam;
113 fis[6] = tf->lbah;
114 fis[7] = tf->device;
115
116 fis[8] = tf->hob_lbal;
117 fis[9] = tf->hob_lbam;
118 fis[10] = tf->hob_lbah;
119 fis[11] = tf->hob_feature;
120
121 fis[12] = tf->nsect;
122 fis[13] = tf->hob_nsect;
123 fis[14] = 0;
124 fis[15] = tf->ctl;
125
126 fis[16] = 0;
127 fis[17] = 0;
128 fis[18] = 0;
129 fis[19] = 0;
130}
131
132/**
133 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
134 * @fis: Buffer from which data will be input
135 * @tf: Taskfile to output
136 *
Mark Lorde12a1be2005-11-12 18:55:45 -0500137 * Converts a serial ATA FIS structure to a standard ATA taskfile.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 *
139 * LOCKING:
140 * Inherited from caller.
141 */
142
Jeff Garzik057ace52005-10-22 14:27:05 -0400143void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144{
145 tf->command = fis[2]; /* status */
146 tf->feature = fis[3]; /* error */
147
148 tf->lbal = fis[4];
149 tf->lbam = fis[5];
150 tf->lbah = fis[6];
151 tf->device = fis[7];
152
153 tf->hob_lbal = fis[8];
154 tf->hob_lbam = fis[9];
155 tf->hob_lbah = fis[10];
156
157 tf->nsect = fis[12];
158 tf->hob_nsect = fis[13];
159}
160
Albert Lee8cbd6df2005-10-12 15:06:27 +0800161static const u8 ata_rw_cmds[] = {
162 /* pio multi */
163 ATA_CMD_READ_MULTI,
164 ATA_CMD_WRITE_MULTI,
165 ATA_CMD_READ_MULTI_EXT,
166 ATA_CMD_WRITE_MULTI_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100167 0,
168 0,
169 0,
170 ATA_CMD_WRITE_MULTI_FUA_EXT,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800171 /* pio */
172 ATA_CMD_PIO_READ,
173 ATA_CMD_PIO_WRITE,
174 ATA_CMD_PIO_READ_EXT,
175 ATA_CMD_PIO_WRITE_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100176 0,
177 0,
178 0,
179 0,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800180 /* dma */
181 ATA_CMD_READ,
182 ATA_CMD_WRITE,
183 ATA_CMD_READ_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100184 ATA_CMD_WRITE_EXT,
185 0,
186 0,
187 0,
188 ATA_CMD_WRITE_FUA_EXT
Albert Lee8cbd6df2005-10-12 15:06:27 +0800189};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191/**
Albert Lee8cbd6df2005-10-12 15:06:27 +0800192 * ata_rwcmd_protocol - set taskfile r/w commands and protocol
193 * @qc: command to examine and configure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500195 * Examine the device configuration and tf->flags to calculate
Albert Lee8cbd6df2005-10-12 15:06:27 +0800196 * the proper read/write commands and protocol to use.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 *
198 * LOCKING:
199 * caller.
200 */
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100201int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{
Albert Lee8cbd6df2005-10-12 15:06:27 +0800203 struct ata_taskfile *tf = &qc->tf;
204 struct ata_device *dev = qc->dev;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100205 u8 cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100207 int index, fua, lba48, write;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500208
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100209 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800210 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
211 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
Albert Lee8cbd6df2005-10-12 15:06:27 +0800213 if (dev->flags & ATA_DFLAG_PIO) {
214 tf->protocol = ATA_PROT_PIO;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100215 index = dev->multi_count ? 0 : 8;
Alan Cox8d238e02006-01-17 20:50:31 +0000216 } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
217 /* Unable to use DMA due to host limitation */
218 tf->protocol = ATA_PROT_PIO;
Albert Lee0565c262006-02-13 18:55:25 +0800219 index = dev->multi_count ? 0 : 8;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800220 } else {
221 tf->protocol = ATA_PROT_DMA;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100222 index = 16;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800223 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100225 cmd = ata_rw_cmds[index + fua + lba48 + write];
226 if (cmd) {
227 tf->command = cmd;
228 return 0;
229 }
230 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231}
232
Tejun Heocb95d562006-03-06 04:31:56 +0900233/**
234 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
235 * @pio_mask: pio_mask
236 * @mwdma_mask: mwdma_mask
237 * @udma_mask: udma_mask
238 *
239 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
240 * unsigned int xfer_mask.
241 *
242 * LOCKING:
243 * None.
244 *
245 * RETURNS:
246 * Packed xfer_mask.
247 */
248static unsigned int ata_pack_xfermask(unsigned int pio_mask,
249 unsigned int mwdma_mask,
250 unsigned int udma_mask)
251{
252 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
253 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
254 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
255}
256
Tejun Heoc0489e42006-03-24 14:07:49 +0900257/**
258 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
259 * @xfer_mask: xfer_mask to unpack
260 * @pio_mask: resulting pio_mask
261 * @mwdma_mask: resulting mwdma_mask
262 * @udma_mask: resulting udma_mask
263 *
264 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
265 * Any NULL distination masks will be ignored.
266 */
267static void ata_unpack_xfermask(unsigned int xfer_mask,
268 unsigned int *pio_mask,
269 unsigned int *mwdma_mask,
270 unsigned int *udma_mask)
271{
272 if (pio_mask)
273 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
274 if (mwdma_mask)
275 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
276 if (udma_mask)
277 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
278}
279
Tejun Heocb95d562006-03-06 04:31:56 +0900280static const struct ata_xfer_ent {
Tejun Heobe9a50c2006-03-31 22:48:52 +0900281 int shift, bits;
Tejun Heocb95d562006-03-06 04:31:56 +0900282 u8 base;
283} ata_xfer_tbl[] = {
284 { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
285 { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
286 { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
287 { -1, },
288};
289
290/**
291 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
292 * @xfer_mask: xfer_mask of interest
293 *
294 * Return matching XFER_* value for @xfer_mask. Only the highest
295 * bit of @xfer_mask is considered.
296 *
297 * LOCKING:
298 * None.
299 *
300 * RETURNS:
301 * Matching XFER_* value, 0 if no match found.
302 */
303static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
304{
305 int highbit = fls(xfer_mask) - 1;
306 const struct ata_xfer_ent *ent;
307
308 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
309 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
310 return ent->base + highbit - ent->shift;
311 return 0;
312}
313
314/**
315 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
316 * @xfer_mode: XFER_* of interest
317 *
318 * Return matching xfer_mask for @xfer_mode.
319 *
320 * LOCKING:
321 * None.
322 *
323 * RETURNS:
324 * Matching xfer_mask, 0 if no match found.
325 */
326static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
327{
328 const struct ata_xfer_ent *ent;
329
330 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
331 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
332 return 1 << (ent->shift + xfer_mode - ent->base);
333 return 0;
334}
335
336/**
337 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
338 * @xfer_mode: XFER_* of interest
339 *
340 * Return matching xfer_shift for @xfer_mode.
341 *
342 * LOCKING:
343 * None.
344 *
345 * RETURNS:
346 * Matching xfer_shift, -1 if no match found.
347 */
348static int ata_xfer_mode2shift(unsigned int xfer_mode)
349{
350 const struct ata_xfer_ent *ent;
351
352 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
353 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
354 return ent->shift;
355 return -1;
356}
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358/**
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900359 * ata_mode_string - convert xfer_mask to string
360 * @xfer_mask: mask of bits supported; only highest bit counts.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 *
362 * Determine string which represents the highest speed
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900363 * (highest bit in @modemask).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 *
365 * LOCKING:
366 * None.
367 *
368 * RETURNS:
369 * Constant C string representing highest speed listed in
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900370 * @mode_mask, or the constant C string "<n/a>".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 */
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900372static const char *ata_mode_string(unsigned int xfer_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
Tejun Heo75f554b2006-03-06 04:31:57 +0900374 static const char * const xfer_mode_str[] = {
375 "PIO0",
376 "PIO1",
377 "PIO2",
378 "PIO3",
379 "PIO4",
380 "MWDMA0",
381 "MWDMA1",
382 "MWDMA2",
383 "UDMA/16",
384 "UDMA/25",
385 "UDMA/33",
386 "UDMA/44",
387 "UDMA/66",
388 "UDMA/100",
389 "UDMA/133",
390 "UDMA7",
391 };
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900392 int highbit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900394 highbit = fls(xfer_mask) - 1;
395 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
396 return xfer_mode_str[highbit];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 return "<n/a>";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398}
399
Tejun Heo0b8efb02006-03-24 15:25:31 +0900400static void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
401{
402 if (ata_dev_present(dev)) {
403 printk(KERN_WARNING "ata%u: dev %u disabled\n",
404 ap->id, dev->devno);
405 dev->class++;
406 }
407}
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409/**
410 * ata_pio_devchk - PATA device presence detection
411 * @ap: ATA channel to examine
412 * @device: Device to examine (starting at zero)
413 *
414 * This technique was originally described in
415 * Hale Landis's ATADRVR (www.ata-atapi.com), and
416 * later found its way into the ATA/ATAPI spec.
417 *
418 * Write a pattern to the ATA shadow registers,
419 * and if a device is present, it will respond by
420 * correctly storing and echoing back the
421 * ATA shadow register contents.
422 *
423 * LOCKING:
424 * caller.
425 */
426
427static unsigned int ata_pio_devchk(struct ata_port *ap,
428 unsigned int device)
429{
430 struct ata_ioports *ioaddr = &ap->ioaddr;
431 u8 nsect, lbal;
432
433 ap->ops->dev_select(ap, device);
434
435 outb(0x55, ioaddr->nsect_addr);
436 outb(0xaa, ioaddr->lbal_addr);
437
438 outb(0xaa, ioaddr->nsect_addr);
439 outb(0x55, ioaddr->lbal_addr);
440
441 outb(0x55, ioaddr->nsect_addr);
442 outb(0xaa, ioaddr->lbal_addr);
443
444 nsect = inb(ioaddr->nsect_addr);
445 lbal = inb(ioaddr->lbal_addr);
446
447 if ((nsect == 0x55) && (lbal == 0xaa))
448 return 1; /* we found a device */
449
450 return 0; /* nothing found */
451}
452
453/**
454 * ata_mmio_devchk - PATA device presence detection
455 * @ap: ATA channel to examine
456 * @device: Device to examine (starting at zero)
457 *
458 * This technique was originally described in
459 * Hale Landis's ATADRVR (www.ata-atapi.com), and
460 * later found its way into the ATA/ATAPI spec.
461 *
462 * Write a pattern to the ATA shadow registers,
463 * and if a device is present, it will respond by
464 * correctly storing and echoing back the
465 * ATA shadow register contents.
466 *
467 * LOCKING:
468 * caller.
469 */
470
471static unsigned int ata_mmio_devchk(struct ata_port *ap,
472 unsigned int device)
473{
474 struct ata_ioports *ioaddr = &ap->ioaddr;
475 u8 nsect, lbal;
476
477 ap->ops->dev_select(ap, device);
478
479 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
480 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
481
482 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
483 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
484
485 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
486 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
487
488 nsect = readb((void __iomem *) ioaddr->nsect_addr);
489 lbal = readb((void __iomem *) ioaddr->lbal_addr);
490
491 if ((nsect == 0x55) && (lbal == 0xaa))
492 return 1; /* we found a device */
493
494 return 0; /* nothing found */
495}
496
497/**
498 * ata_devchk - PATA device presence detection
499 * @ap: ATA channel to examine
500 * @device: Device to examine (starting at zero)
501 *
502 * Dispatch ATA device presence detection, depending
503 * on whether we are using PIO or MMIO to talk to the
504 * ATA shadow registers.
505 *
506 * LOCKING:
507 * caller.
508 */
509
510static unsigned int ata_devchk(struct ata_port *ap,
511 unsigned int device)
512{
513 if (ap->flags & ATA_FLAG_MMIO)
514 return ata_mmio_devchk(ap, device);
515 return ata_pio_devchk(ap, device);
516}
517
518/**
519 * ata_dev_classify - determine device type based on ATA-spec signature
520 * @tf: ATA taskfile register set for device to be identified
521 *
522 * Determine from taskfile register contents whether a device is
523 * ATA or ATAPI, as per "Signature and persistence" section
524 * of ATA/PI spec (volume 1, sect 5.14).
525 *
526 * LOCKING:
527 * None.
528 *
529 * RETURNS:
530 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
531 * the event of failure.
532 */
533
Jeff Garzik057ace52005-10-22 14:27:05 -0400534unsigned int ata_dev_classify(const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
536 /* Apple's open source Darwin code hints that some devices only
537 * put a proper signature into the LBA mid/high registers,
538 * So, we only check those. It's sufficient for uniqueness.
539 */
540
541 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
542 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
543 DPRINTK("found ATA device by sig\n");
544 return ATA_DEV_ATA;
545 }
546
547 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
548 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
549 DPRINTK("found ATAPI device by sig\n");
550 return ATA_DEV_ATAPI;
551 }
552
553 DPRINTK("unknown device\n");
554 return ATA_DEV_UNKNOWN;
555}
556
557/**
558 * ata_dev_try_classify - Parse returned ATA device signature
559 * @ap: ATA channel to examine
560 * @device: Device to examine (starting at zero)
Tejun Heob4dc7622006-01-24 17:05:22 +0900561 * @r_err: Value of error register on completion
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 *
563 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
564 * an ATA/ATAPI-defined set of values is placed in the ATA
565 * shadow registers, indicating the results of device detection
566 * and diagnostics.
567 *
568 * Select the ATA device, and read the values from the ATA shadow
569 * registers. Then parse according to the Error register value,
570 * and the spec-defined values examined by ata_dev_classify().
571 *
572 * LOCKING:
573 * caller.
Tejun Heob4dc7622006-01-24 17:05:22 +0900574 *
575 * RETURNS:
576 * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 */
578
Tejun Heob4dc7622006-01-24 17:05:22 +0900579static unsigned int
580ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 struct ata_taskfile tf;
583 unsigned int class;
584 u8 err;
585
586 ap->ops->dev_select(ap, device);
587
588 memset(&tf, 0, sizeof(tf));
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 ap->ops->tf_read(ap, &tf);
Jeff Garzik0169e282005-10-29 21:25:10 -0400591 err = tf.feature;
Tejun Heob4dc7622006-01-24 17:05:22 +0900592 if (r_err)
593 *r_err = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
595 /* see if device passed diags */
596 if (err == 1)
597 /* do nothing */ ;
598 else if ((device == 0) && (err == 0x81))
599 /* do nothing */ ;
600 else
Tejun Heob4dc7622006-01-24 17:05:22 +0900601 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Tejun Heob4dc7622006-01-24 17:05:22 +0900603 /* determine if device is ATA or ATAPI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 class = ata_dev_classify(&tf);
Tejun Heob4dc7622006-01-24 17:05:22 +0900605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 if (class == ATA_DEV_UNKNOWN)
Tejun Heob4dc7622006-01-24 17:05:22 +0900607 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
Tejun Heob4dc7622006-01-24 17:05:22 +0900609 return ATA_DEV_NONE;
610 return class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611}
612
613/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900614 * ata_id_string - Convert IDENTIFY DEVICE page into string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 * @id: IDENTIFY DEVICE results we will examine
616 * @s: string into which data is output
617 * @ofs: offset into identify device page
618 * @len: length of string to return. must be an even number.
619 *
620 * The strings in the IDENTIFY DEVICE page are broken up into
621 * 16-bit chunks. Run through the string, and output each
622 * 8-bit chunk linearly, regardless of platform.
623 *
624 * LOCKING:
625 * caller.
626 */
627
Tejun Heo6a62a042006-02-13 10:02:46 +0900628void ata_id_string(const u16 *id, unsigned char *s,
629 unsigned int ofs, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630{
631 unsigned int c;
632
633 while (len > 0) {
634 c = id[ofs] >> 8;
635 *s = c;
636 s++;
637
638 c = id[ofs] & 0xff;
639 *s = c;
640 s++;
641
642 ofs++;
643 len -= 2;
644 }
645}
646
Tejun Heo0e949ff2006-02-12 22:47:04 +0900647/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900648 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
Tejun Heo0e949ff2006-02-12 22:47:04 +0900649 * @id: IDENTIFY DEVICE results we will examine
650 * @s: string into which data is output
651 * @ofs: offset into identify device page
652 * @len: length of string to return. must be an odd number.
653 *
Tejun Heo6a62a042006-02-13 10:02:46 +0900654 * This function is identical to ata_id_string except that it
Tejun Heo0e949ff2006-02-12 22:47:04 +0900655 * trims trailing spaces and terminates the resulting string with
656 * null. @len must be actual maximum length (even number) + 1.
657 *
658 * LOCKING:
659 * caller.
660 */
Tejun Heo6a62a042006-02-13 10:02:46 +0900661void ata_id_c_string(const u16 *id, unsigned char *s,
662 unsigned int ofs, unsigned int len)
Tejun Heo0e949ff2006-02-12 22:47:04 +0900663{
664 unsigned char *p;
665
666 WARN_ON(!(len & 1));
667
Tejun Heo6a62a042006-02-13 10:02:46 +0900668 ata_id_string(id, s, ofs, len - 1);
Tejun Heo0e949ff2006-02-12 22:47:04 +0900669
670 p = s + strnlen(s, len - 1);
671 while (p > s && p[-1] == ' ')
672 p--;
673 *p = '\0';
674}
Edward Falk0baab862005-06-02 18:17:13 -0400675
Tejun Heo29407402006-02-12 22:47:04 +0900676static u64 ata_id_n_sectors(const u16 *id)
677{
678 if (ata_id_has_lba(id)) {
679 if (ata_id_has_lba48(id))
680 return ata_id_u64(id, 100);
681 else
682 return ata_id_u32(id, 60);
683 } else {
684 if (ata_id_current_chs_valid(id))
685 return ata_id_u32(id, 57);
686 else
687 return id[1] * id[3] * id[6];
688 }
689}
690
Edward Falk0baab862005-06-02 18:17:13 -0400691/**
692 * ata_noop_dev_select - Select device 0/1 on ATA bus
693 * @ap: ATA channel to manipulate
694 * @device: ATA device (numbered from zero) to select
695 *
696 * This function performs no actual function.
697 *
698 * May be used as the dev_select() entry in ata_port_operations.
699 *
700 * LOCKING:
701 * caller.
702 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
704{
705}
706
Edward Falk0baab862005-06-02 18:17:13 -0400707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708/**
709 * ata_std_dev_select - Select device 0/1 on ATA bus
710 * @ap: ATA channel to manipulate
711 * @device: ATA device (numbered from zero) to select
712 *
713 * Use the method defined in the ATA specification to
714 * make either device 0, or device 1, active on the
Edward Falk0baab862005-06-02 18:17:13 -0400715 * ATA channel. Works with both PIO and MMIO.
716 *
717 * May be used as the dev_select() entry in ata_port_operations.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 *
719 * LOCKING:
720 * caller.
721 */
722
723void ata_std_dev_select (struct ata_port *ap, unsigned int device)
724{
725 u8 tmp;
726
727 if (device == 0)
728 tmp = ATA_DEVICE_OBS;
729 else
730 tmp = ATA_DEVICE_OBS | ATA_DEV1;
731
732 if (ap->flags & ATA_FLAG_MMIO) {
733 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
734 } else {
735 outb(tmp, ap->ioaddr.device_addr);
736 }
737 ata_pause(ap); /* needed; also flushes, for mmio */
738}
739
740/**
741 * ata_dev_select - Select device 0/1 on ATA bus
742 * @ap: ATA channel to manipulate
743 * @device: ATA device (numbered from zero) to select
744 * @wait: non-zero to wait for Status register BSY bit to clear
745 * @can_sleep: non-zero if context allows sleeping
746 *
747 * Use the method defined in the ATA specification to
748 * make either device 0, or device 1, active on the
749 * ATA channel.
750 *
751 * This is a high-level version of ata_std_dev_select(),
752 * which additionally provides the services of inserting
753 * the proper pauses and status polling, where needed.
754 *
755 * LOCKING:
756 * caller.
757 */
758
759void ata_dev_select(struct ata_port *ap, unsigned int device,
760 unsigned int wait, unsigned int can_sleep)
761{
762 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
763 ap->id, device, wait);
764
765 if (wait)
766 ata_wait_idle(ap);
767
768 ap->ops->dev_select(ap, device);
769
770 if (wait) {
771 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
772 msleep(150);
773 ata_wait_idle(ap);
774 }
775}
776
777/**
778 * ata_dump_id - IDENTIFY DEVICE info debugging output
Tejun Heo0bd33002006-02-12 22:47:05 +0900779 * @id: IDENTIFY DEVICE page to dump
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 *
Tejun Heo0bd33002006-02-12 22:47:05 +0900781 * Dump selected 16-bit words from the given IDENTIFY DEVICE
782 * page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 *
784 * LOCKING:
785 * caller.
786 */
787
Tejun Heo0bd33002006-02-12 22:47:05 +0900788static inline void ata_dump_id(const u16 *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
790 DPRINTK("49==0x%04x "
791 "53==0x%04x "
792 "63==0x%04x "
793 "64==0x%04x "
794 "75==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900795 id[49],
796 id[53],
797 id[63],
798 id[64],
799 id[75]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 DPRINTK("80==0x%04x "
801 "81==0x%04x "
802 "82==0x%04x "
803 "83==0x%04x "
804 "84==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900805 id[80],
806 id[81],
807 id[82],
808 id[83],
809 id[84]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 DPRINTK("88==0x%04x "
811 "93==0x%04x\n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900812 id[88],
813 id[93]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814}
815
Tejun Heocb95d562006-03-06 04:31:56 +0900816/**
817 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
818 * @id: IDENTIFY data to compute xfer mask from
819 *
820 * Compute the xfermask for this device. This is not as trivial
821 * as it seems if we must consider early devices correctly.
822 *
823 * FIXME: pre IDE drive timing (do we care ?).
824 *
825 * LOCKING:
826 * None.
827 *
828 * RETURNS:
829 * Computed xfermask
830 */
831static unsigned int ata_id_xfermask(const u16 *id)
832{
833 unsigned int pio_mask, mwdma_mask, udma_mask;
834
835 /* Usual case. Word 53 indicates word 64 is valid */
836 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
837 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
838 pio_mask <<= 3;
839 pio_mask |= 0x7;
840 } else {
841 /* If word 64 isn't valid then Word 51 high byte holds
842 * the PIO timing number for the maximum. Turn it into
843 * a mask.
844 */
845 pio_mask = (2 << (id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
846
847 /* But wait.. there's more. Design your standards by
848 * committee and you too can get a free iordy field to
849 * process. However its the speeds not the modes that
850 * are supported... Note drivers using the timing API
851 * will get this right anyway
852 */
853 }
854
855 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
Tejun Heofb21f0d2006-03-12 12:34:35 +0900856
857 udma_mask = 0;
858 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
859 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
Tejun Heocb95d562006-03-06 04:31:56 +0900860
861 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
862}
863
Tejun Heo86e45b62006-03-05 15:29:09 +0900864/**
865 * ata_port_queue_task - Queue port_task
866 * @ap: The ata_port to queue port_task for
Randy Dunlape2a7f772006-05-18 10:50:18 -0700867 * @fn: workqueue function to be scheduled
868 * @data: data value to pass to workqueue function
869 * @delay: delay time for workqueue function
Tejun Heo86e45b62006-03-05 15:29:09 +0900870 *
871 * Schedule @fn(@data) for execution after @delay jiffies using
872 * port_task. There is one port_task per port and it's the
873 * user(low level driver)'s responsibility to make sure that only
874 * one task is active at any given time.
875 *
876 * libata core layer takes care of synchronization between
877 * port_task and EH. ata_port_queue_task() may be ignored for EH
878 * synchronization.
879 *
880 * LOCKING:
881 * Inherited from caller.
882 */
883void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *), void *data,
884 unsigned long delay)
885{
886 int rc;
887
Tejun Heo2e755f62006-03-05 15:29:09 +0900888 if (ap->flags & ATA_FLAG_FLUSH_PORT_TASK)
Tejun Heo86e45b62006-03-05 15:29:09 +0900889 return;
890
891 PREPARE_WORK(&ap->port_task, fn, data);
892
893 if (!delay)
894 rc = queue_work(ata_wq, &ap->port_task);
895 else
896 rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
897
898 /* rc == 0 means that another user is using port task */
899 WARN_ON(rc == 0);
900}
901
902/**
903 * ata_port_flush_task - Flush port_task
904 * @ap: The ata_port to flush port_task for
905 *
906 * After this function completes, port_task is guranteed not to
907 * be running or scheduled.
908 *
909 * LOCKING:
910 * Kernel thread context (may sleep)
911 */
912void ata_port_flush_task(struct ata_port *ap)
913{
914 unsigned long flags;
915
916 DPRINTK("ENTER\n");
917
918 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900919 ap->flags |= ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heo86e45b62006-03-05 15:29:09 +0900920 spin_unlock_irqrestore(&ap->host_set->lock, flags);
921
922 DPRINTK("flush #1\n");
923 flush_workqueue(ata_wq);
924
925 /*
926 * At this point, if a task is running, it's guaranteed to see
927 * the FLUSH flag; thus, it will never queue pio tasks again.
928 * Cancel and flush.
929 */
930 if (!cancel_delayed_work(&ap->port_task)) {
931 DPRINTK("flush #2\n");
932 flush_workqueue(ata_wq);
933 }
934
935 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900936 ap->flags &= ~ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heo86e45b62006-03-05 15:29:09 +0900937 spin_unlock_irqrestore(&ap->host_set->lock, flags);
938
939 DPRINTK("EXIT\n");
940}
941
Tejun Heo77853bf2006-01-23 13:09:36 +0900942void ata_qc_complete_internal(struct ata_queued_cmd *qc)
Tejun Heoa2a7a662005-12-13 14:48:31 +0900943{
Tejun Heo77853bf2006-01-23 13:09:36 +0900944 struct completion *waiting = qc->private_data;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900945
Tejun Heo77853bf2006-01-23 13:09:36 +0900946 qc->ap->ops->tf_read(qc->ap, &qc->tf);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900947 complete(waiting);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900948}
949
950/**
951 * ata_exec_internal - execute libata internal command
952 * @ap: Port to which the command is sent
953 * @dev: Device to which the command is sent
954 * @tf: Taskfile registers for the command and the result
955 * @dma_dir: Data tranfer direction of the command
956 * @buf: Data buffer of the command
957 * @buflen: Length of data buffer
958 *
959 * Executes libata internal command with timeout. @tf contains
960 * command on entry and result on return. Timeout and error
961 * conditions are reported via return value. No recovery action
962 * is taken after a command times out. It's caller's duty to
963 * clean up after timeout.
964 *
965 * LOCKING:
966 * None. Should be called with kernel context, might sleep.
967 */
968
969static unsigned
970ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
971 struct ata_taskfile *tf,
972 int dma_dir, void *buf, unsigned int buflen)
973{
974 u8 command = tf->command;
975 struct ata_queued_cmd *qc;
976 DECLARE_COMPLETION(wait);
977 unsigned long flags;
Tejun Heo77853bf2006-01-23 13:09:36 +0900978 unsigned int err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900979
980 spin_lock_irqsave(&ap->host_set->lock, flags);
981
982 qc = ata_qc_new_init(ap, dev);
983 BUG_ON(qc == NULL);
984
985 qc->tf = *tf;
986 qc->dma_dir = dma_dir;
987 if (dma_dir != DMA_NONE) {
988 ata_sg_init_one(qc, buf, buflen);
989 qc->nsect = buflen / ATA_SECT_SIZE;
990 }
991
Tejun Heo77853bf2006-01-23 13:09:36 +0900992 qc->private_data = &wait;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900993 qc->complete_fn = ata_qc_complete_internal;
994
Tejun Heo8e0e6942006-03-31 20:41:11 +0900995 ata_qc_issue(qc);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900996
997 spin_unlock_irqrestore(&ap->host_set->lock, flags);
998
999 if (!wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL)) {
Albert Lee41ade502006-03-14 11:19:04 +08001000 ata_port_flush_task(ap);
1001
Tejun Heoa2a7a662005-12-13 14:48:31 +09001002 spin_lock_irqsave(&ap->host_set->lock, flags);
1003
1004 /* We're racing with irq here. If we lose, the
1005 * following test prevents us from completing the qc
1006 * again. If completion irq occurs after here but
1007 * before the caller cleans up, it will result in a
1008 * spurious interrupt. We can live with that.
1009 */
Tejun Heo77853bf2006-01-23 13:09:36 +09001010 if (qc->flags & ATA_QCFLAG_ACTIVE) {
Tejun Heo11a56d22006-01-23 13:09:36 +09001011 qc->err_mask = AC_ERR_TIMEOUT;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001012 ata_qc_complete(qc);
1013 printk(KERN_WARNING "ata%u: qc timeout (cmd 0x%x)\n",
1014 ap->id, command);
1015 }
1016
1017 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1018 }
1019
Tejun Heo77853bf2006-01-23 13:09:36 +09001020 *tf = qc->tf;
1021 err_mask = qc->err_mask;
1022
1023 ata_qc_free(qc);
1024
Tejun Heo1f7dd3e92006-03-24 15:25:30 +09001025 /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1026 * Until those drivers are fixed, we detect the condition
1027 * here, fail the command with AC_ERR_SYSTEM and reenable the
1028 * port.
1029 *
1030 * Note that this doesn't change any behavior as internal
1031 * command failure results in disabling the device in the
1032 * higher layer for LLDDs without new reset/EH callbacks.
1033 *
1034 * Kill the following code as soon as those drivers are fixed.
1035 */
1036 if (ap->flags & ATA_FLAG_PORT_DISABLED) {
1037 err_mask |= AC_ERR_SYSTEM;
1038 ata_port_probe(ap);
1039 }
1040
Tejun Heo77853bf2006-01-23 13:09:36 +09001041 return err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001042}
1043
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044/**
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001045 * ata_pio_need_iordy - check if iordy needed
1046 * @adev: ATA device
1047 *
1048 * Check if the current speed of the device requires IORDY. Used
1049 * by various controllers for chip configuration.
1050 */
1051
1052unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1053{
1054 int pio;
1055 int speed = adev->pio_mode - XFER_PIO_0;
1056
1057 if (speed < 2)
1058 return 0;
1059 if (speed > 2)
1060 return 1;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001061
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001062 /* If we have no drive specific rule, then PIO 2 is non IORDY */
1063
1064 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1065 pio = adev->id[ATA_ID_EIDE_PIO];
1066 /* Is the speed faster than the drive allows non IORDY ? */
1067 if (pio) {
1068 /* This is cycle times not frequency - watch the logic! */
1069 if (pio > 240) /* PIO2 is 240nS per cycle */
1070 return 1;
1071 return 0;
1072 }
1073 }
1074 return 0;
1075}
1076
1077/**
Tejun Heo49016ac2006-02-21 02:12:11 +09001078 * ata_dev_read_id - Read ID data from the specified device
1079 * @ap: port on which target device resides
1080 * @dev: target device
1081 * @p_class: pointer to class of the target device (may be changed)
1082 * @post_reset: is this read ID post-reset?
Tejun Heod9572b12006-03-01 16:09:35 +09001083 * @p_id: read IDENTIFY page (newly allocated)
Tejun Heo49016ac2006-02-21 02:12:11 +09001084 *
1085 * Read ID data from the specified device. ATA_CMD_ID_ATA is
1086 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
Tejun Heoaec5c3c2006-03-25 01:33:34 +09001087 * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS
1088 * for pre-ATA4 drives.
Tejun Heo49016ac2006-02-21 02:12:11 +09001089 *
1090 * LOCKING:
1091 * Kernel thread context (may sleep)
1092 *
1093 * RETURNS:
1094 * 0 on success, -errno otherwise.
1095 */
1096static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
Tejun Heod9572b12006-03-01 16:09:35 +09001097 unsigned int *p_class, int post_reset, u16 **p_id)
Tejun Heo49016ac2006-02-21 02:12:11 +09001098{
1099 unsigned int class = *p_class;
Tejun Heo49016ac2006-02-21 02:12:11 +09001100 struct ata_taskfile tf;
1101 unsigned int err_mask = 0;
Tejun Heod9572b12006-03-01 16:09:35 +09001102 u16 *id;
Tejun Heo49016ac2006-02-21 02:12:11 +09001103 const char *reason;
1104 int rc;
1105
1106 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1107
Tejun Heo49016ac2006-02-21 02:12:11 +09001108 ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1109
Tejun Heod9572b12006-03-01 16:09:35 +09001110 id = kmalloc(sizeof(id[0]) * ATA_ID_WORDS, GFP_KERNEL);
1111 if (id == NULL) {
1112 rc = -ENOMEM;
1113 reason = "out of memory";
1114 goto err_out;
1115 }
1116
Tejun Heo49016ac2006-02-21 02:12:11 +09001117 retry:
1118 ata_tf_init(ap, &tf, dev->devno);
1119
1120 switch (class) {
1121 case ATA_DEV_ATA:
1122 tf.command = ATA_CMD_ID_ATA;
1123 break;
1124 case ATA_DEV_ATAPI:
1125 tf.command = ATA_CMD_ID_ATAPI;
1126 break;
1127 default:
1128 rc = -ENODEV;
1129 reason = "unsupported class";
1130 goto err_out;
1131 }
1132
1133 tf.protocol = ATA_PROT_PIO;
1134
1135 err_mask = ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE,
1136 id, sizeof(id[0]) * ATA_ID_WORDS);
Tejun Heo49016ac2006-02-21 02:12:11 +09001137 if (err_mask) {
1138 rc = -EIO;
1139 reason = "I/O error";
Tejun Heo49016ac2006-02-21 02:12:11 +09001140 goto err_out;
1141 }
1142
1143 swap_buf_le16(id, ATA_ID_WORDS);
1144
Tejun Heo49016ac2006-02-21 02:12:11 +09001145 /* sanity check */
Alan Cox692785e2006-03-27 18:49:19 +01001146 if ((class == ATA_DEV_ATA) != (ata_id_is_ata(id) | ata_id_is_cfa(id))) {
Tejun Heo49016ac2006-02-21 02:12:11 +09001147 rc = -EINVAL;
1148 reason = "device reports illegal type";
1149 goto err_out;
1150 }
1151
1152 if (post_reset && class == ATA_DEV_ATA) {
1153 /*
1154 * The exact sequence expected by certain pre-ATA4 drives is:
1155 * SRST RESET
1156 * IDENTIFY
1157 * INITIALIZE DEVICE PARAMETERS
1158 * anything else..
1159 * Some drives were very specific about that exact sequence.
1160 */
1161 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
Albert Lee00b6f5e2006-03-27 16:39:18 +08001162 err_mask = ata_dev_init_params(ap, dev, id[3], id[6]);
Tejun Heo49016ac2006-02-21 02:12:11 +09001163 if (err_mask) {
1164 rc = -EIO;
1165 reason = "INIT_DEV_PARAMS failed";
1166 goto err_out;
1167 }
1168
1169 /* current CHS translation info (id[53-58]) might be
1170 * changed. reread the identify device info.
1171 */
1172 post_reset = 0;
1173 goto retry;
1174 }
1175 }
1176
1177 *p_class = class;
Tejun Heod9572b12006-03-01 16:09:35 +09001178 *p_id = id;
Tejun Heo49016ac2006-02-21 02:12:11 +09001179 return 0;
1180
1181 err_out:
1182 printk(KERN_WARNING "ata%u: dev %u failed to IDENTIFY (%s)\n",
1183 ap->id, dev->devno, reason);
Tejun Heod9572b12006-03-01 16:09:35 +09001184 kfree(id);
Tejun Heo49016ac2006-02-21 02:12:11 +09001185 return rc;
1186}
1187
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001188static inline u8 ata_dev_knobble(const struct ata_port *ap,
1189 struct ata_device *dev)
1190{
1191 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
1192}
1193
Tejun Heo49016ac2006-02-21 02:12:11 +09001194/**
Tejun Heoffeae412006-03-01 16:09:35 +09001195 * ata_dev_configure - Configure the specified ATA/ATAPI device
1196 * @ap: Port on which target device resides
1197 * @dev: Target device to configure
Tejun Heo4c2d7212006-03-05 17:55:58 +09001198 * @print_info: Enable device info printout
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 *
Tejun Heoffeae412006-03-01 16:09:35 +09001200 * Configure @dev according to @dev->id. Generic and low-level
1201 * driver specific fixups are also applied.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 *
1203 * LOCKING:
Tejun Heoffeae412006-03-01 16:09:35 +09001204 * Kernel thread context (may sleep)
1205 *
1206 * RETURNS:
1207 * 0 on success, -errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001209static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
1210 int print_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211{
Tejun Heo1148c3a2006-03-13 19:48:04 +09001212 const u16 *id = dev->id;
Tejun Heoff8854b2006-03-06 04:31:56 +09001213 unsigned int xfer_mask;
Tejun Heo6e7846e2006-02-12 23:32:58 +09001214 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
1216 if (!ata_dev_present(dev)) {
1217 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
Tejun Heoffeae412006-03-01 16:09:35 +09001218 ap->id, dev->devno);
1219 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 }
1221
Tejun Heoffeae412006-03-01 16:09:35 +09001222 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223
Tejun Heoc39f5eb2006-03-13 19:51:19 +09001224 /* print device capabilities */
1225 if (print_info)
1226 printk(KERN_DEBUG "ata%u: dev %u cfg 49:%04x 82:%04x 83:%04x "
1227 "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1228 ap->id, dev->devno, id[49], id[82], id[83],
1229 id[84], id[85], id[86], id[87], id[88]);
1230
Tejun Heo208a9932006-03-05 17:55:58 +09001231 /* initialize to-be-configured parameters */
1232 dev->flags = 0;
1233 dev->max_sectors = 0;
1234 dev->cdb_len = 0;
1235 dev->n_sectors = 0;
1236 dev->cylinders = 0;
1237 dev->heads = 0;
1238 dev->sectors = 0;
1239
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 /*
1241 * common ATA, ATAPI feature tests
1242 */
1243
Tejun Heoff8854b2006-03-06 04:31:56 +09001244 /* find max transfer mode; for printk only */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001245 xfer_mask = ata_id_xfermask(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246
Tejun Heo1148c3a2006-03-13 19:48:04 +09001247 ata_dump_id(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248
1249 /* ATA-specific feature tests */
1250 if (dev->class == ATA_DEV_ATA) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001251 dev->n_sectors = ata_id_n_sectors(id);
Tejun Heo29407402006-02-12 22:47:04 +09001252
Tejun Heo1148c3a2006-03-13 19:48:04 +09001253 if (ata_id_has_lba(id)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001254 const char *lba_desc;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001255
Tejun Heo4c2d7212006-03-05 17:55:58 +09001256 lba_desc = "LBA";
1257 dev->flags |= ATA_DFLAG_LBA;
Tejun Heo1148c3a2006-03-13 19:48:04 +09001258 if (ata_id_has_lba48(id)) {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001259 dev->flags |= ATA_DFLAG_LBA48;
Tejun Heo4c2d7212006-03-05 17:55:58 +09001260 lba_desc = "LBA48";
1261 }
Albert Lee8bf62ece2005-05-12 15:29:42 -04001262
1263 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001264 if (print_info)
1265 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1266 "max %s, %Lu sectors: %s\n",
1267 ap->id, dev->devno,
Tejun Heo1148c3a2006-03-13 19:48:04 +09001268 ata_id_major_version(id),
Tejun Heoff8854b2006-03-06 04:31:56 +09001269 ata_mode_string(xfer_mask),
Tejun Heo4c2d7212006-03-05 17:55:58 +09001270 (unsigned long long)dev->n_sectors,
1271 lba_desc);
Tejun Heoffeae412006-03-01 16:09:35 +09001272 } else {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001273 /* CHS */
1274
1275 /* Default translation */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001276 dev->cylinders = id[1];
1277 dev->heads = id[3];
1278 dev->sectors = id[6];
Albert Lee8bf62ece2005-05-12 15:29:42 -04001279
Tejun Heo1148c3a2006-03-13 19:48:04 +09001280 if (ata_id_current_chs_valid(id)) {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001281 /* Current CHS translation is valid. */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001282 dev->cylinders = id[54];
1283 dev->heads = id[55];
1284 dev->sectors = id[56];
Albert Lee8bf62ece2005-05-12 15:29:42 -04001285 }
1286
1287 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001288 if (print_info)
1289 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1290 "max %s, %Lu sectors: CHS %u/%u/%u\n",
1291 ap->id, dev->devno,
Tejun Heo1148c3a2006-03-13 19:48:04 +09001292 ata_id_major_version(id),
Tejun Heoff8854b2006-03-06 04:31:56 +09001293 ata_mode_string(xfer_mask),
Tejun Heo4c2d7212006-03-05 17:55:58 +09001294 (unsigned long long)dev->n_sectors,
1295 dev->cylinders, dev->heads, dev->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 }
1297
Tejun Heo6e7846e2006-02-12 23:32:58 +09001298 dev->cdb_len = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
1300
1301 /* ATAPI-specific feature tests */
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05001302 else if (dev->class == ATA_DEV_ATAPI) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001303 rc = atapi_cdb_len(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1305 printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
Tejun Heoffeae412006-03-01 16:09:35 +09001306 rc = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 goto err_out_nosup;
1308 }
Tejun Heo6e7846e2006-02-12 23:32:58 +09001309 dev->cdb_len = (unsigned int) rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
1311 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001312 if (print_info)
1313 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
Tejun Heoff8854b2006-03-06 04:31:56 +09001314 ap->id, dev->devno, ata_mode_string(xfer_mask));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 }
1316
Tejun Heo6e7846e2006-02-12 23:32:58 +09001317 ap->host->max_cmd_len = 0;
1318 for (i = 0; i < ATA_MAX_DEVICES; i++)
1319 ap->host->max_cmd_len = max_t(unsigned int,
1320 ap->host->max_cmd_len,
1321 ap->device[i].cdb_len);
1322
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001323 /* limit bridge transfers to udma5, 200 sectors */
1324 if (ata_dev_knobble(ap, dev)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001325 if (print_info)
1326 printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
1327 ap->id, dev->devno);
Tejun Heo5a529132006-03-24 14:07:50 +09001328 dev->udma_mask &= ATA_UDMA5;
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001329 dev->max_sectors = ATA_MAX_SECTORS;
1330 }
1331
1332 if (ap->ops->dev_config)
1333 ap->ops->dev_config(ap, dev);
1334
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
Tejun Heoffeae412006-03-01 16:09:35 +09001336 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
1338err_out_nosup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 DPRINTK("EXIT, err\n");
Tejun Heoffeae412006-03-01 16:09:35 +09001340 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341}
1342
1343/**
1344 * ata_bus_probe - Reset and probe ATA bus
1345 * @ap: Bus to probe
1346 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001347 * Master ATA bus probing function. Initiates a hardware-dependent
1348 * bus reset, then attempts to identify any devices found on
1349 * the bus.
1350 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001352 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 *
1354 * RETURNS:
1355 * Zero on success, non-zero on error.
1356 */
1357
1358static int ata_bus_probe(struct ata_port *ap)
1359{
Tejun Heo28ca5c52006-03-01 16:09:36 +09001360 unsigned int classes[ATA_MAX_DEVICES];
1361 unsigned int i, rc, found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
Tejun Heo28ca5c52006-03-01 16:09:36 +09001363 ata_port_probe(ap);
1364
Tejun Heo20444702006-03-13 01:57:01 +09001365 /* reset and determine device classes */
1366 for (i = 0; i < ATA_MAX_DEVICES; i++)
1367 classes[i] = ATA_DEV_UNKNOWN;
Tejun Heo2061a472006-03-12 00:57:39 +09001368
Tejun Heo20444702006-03-13 01:57:01 +09001369 if (ap->ops->probe_reset) {
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001370 rc = ap->ops->probe_reset(ap, classes);
Tejun Heo28ca5c52006-03-01 16:09:36 +09001371 if (rc) {
1372 printk("ata%u: reset failed (errno=%d)\n", ap->id, rc);
1373 return rc;
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001374 }
Tejun Heo28ca5c52006-03-01 16:09:36 +09001375 } else {
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001376 ap->ops->phy_reset(ap);
1377
Tejun Heo20444702006-03-13 01:57:01 +09001378 if (!(ap->flags & ATA_FLAG_PORT_DISABLED))
1379 for (i = 0; i < ATA_MAX_DEVICES; i++)
Tejun Heo28ca5c52006-03-01 16:09:36 +09001380 classes[i] = ap->device[i].class;
Tejun Heo20444702006-03-13 01:57:01 +09001381
Tejun Heo28ca5c52006-03-01 16:09:36 +09001382 ata_port_probe(ap);
1383 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
Tejun Heo20444702006-03-13 01:57:01 +09001385 for (i = 0; i < ATA_MAX_DEVICES; i++)
1386 if (classes[i] == ATA_DEV_UNKNOWN)
1387 classes[i] = ATA_DEV_NONE;
1388
Tejun Heo28ca5c52006-03-01 16:09:36 +09001389 /* read IDENTIFY page and configure devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoffeae412006-03-01 16:09:35 +09001391 struct ata_device *dev = &ap->device[i];
1392
Tejun Heo28ca5c52006-03-01 16:09:36 +09001393 dev->class = classes[i];
1394
Tejun Heoffeae412006-03-01 16:09:35 +09001395 if (!ata_dev_present(dev))
1396 continue;
1397
1398 WARN_ON(dev->id != NULL);
1399 if (ata_dev_read_id(ap, dev, &dev->class, 1, &dev->id)) {
1400 dev->class = ATA_DEV_NONE;
1401 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 }
Tejun Heoffeae412006-03-01 16:09:35 +09001403
Tejun Heo4c2d7212006-03-05 17:55:58 +09001404 if (ata_dev_configure(ap, dev, 1)) {
Tejun Heofcef9782006-03-24 15:25:31 +09001405 ata_dev_disable(ap, dev);
Tejun Heoffeae412006-03-01 16:09:35 +09001406 continue;
1407 }
1408
Tejun Heoffeae412006-03-01 16:09:35 +09001409 found = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 }
1411
Tejun Heo28ca5c52006-03-01 16:09:36 +09001412 if (!found)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 goto err_out_disable;
1414
Alan Coxe35a9e02006-03-27 18:46:37 +01001415 if (ap->ops->set_mode)
1416 ap->ops->set_mode(ap);
1417 else
1418 ata_set_mode(ap);
1419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1421 goto err_out_disable;
1422
1423 return 0;
1424
1425err_out_disable:
1426 ap->ops->port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 return -1;
1428}
1429
1430/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04001431 * ata_port_probe - Mark port as enabled
1432 * @ap: Port for which we indicate enablement
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001434 * Modify @ap data structure such that the system
1435 * thinks that the entire port is enabled.
1436 *
1437 * LOCKING: host_set lock, or some other form of
1438 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 */
1440
1441void ata_port_probe(struct ata_port *ap)
1442{
1443 ap->flags &= ~ATA_FLAG_PORT_DISABLED;
1444}
1445
1446/**
Tejun Heo3be680b2005-12-19 22:35:02 +09001447 * sata_print_link_status - Print SATA link status
1448 * @ap: SATA port to printk link status about
1449 *
1450 * This function prints link speed and status of a SATA link.
1451 *
1452 * LOCKING:
1453 * None.
1454 */
1455static void sata_print_link_status(struct ata_port *ap)
1456{
1457 u32 sstatus, tmp;
1458 const char *speed;
1459
1460 if (!ap->ops->scr_read)
1461 return;
1462
1463 sstatus = scr_read(ap, SCR_STATUS);
1464
1465 if (sata_dev_present(ap)) {
1466 tmp = (sstatus >> 4) & 0xf;
1467 if (tmp & (1 << 0))
1468 speed = "1.5";
1469 else if (tmp & (1 << 1))
1470 speed = "3.0";
1471 else
1472 speed = "<unknown>";
1473 printk(KERN_INFO "ata%u: SATA link up %s Gbps (SStatus %X)\n",
1474 ap->id, speed, sstatus);
1475 } else {
1476 printk(KERN_INFO "ata%u: SATA link down (SStatus %X)\n",
1477 ap->id, sstatus);
1478 }
1479}
1480
1481/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001482 * __sata_phy_reset - Wake/reset a low-level SATA PHY
1483 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001485 * This function issues commands to standard SATA Sxxx
1486 * PHY registers, to wake up the phy (and device), and
1487 * clear any reset condition.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 *
1489 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001490 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 *
1492 */
1493void __sata_phy_reset(struct ata_port *ap)
1494{
1495 u32 sstatus;
1496 unsigned long timeout = jiffies + (HZ * 5);
1497
1498 if (ap->flags & ATA_FLAG_SATA_RESET) {
Brett Russcdcca89e2005-03-28 15:10:27 -05001499 /* issue phy wake/reset */
1500 scr_write_flush(ap, SCR_CONTROL, 0x301);
Tejun Heo62ba2842005-06-26 23:27:19 +09001501 /* Couldn't find anything in SATA I/II specs, but
1502 * AHCI-1.1 10.4.2 says at least 1 ms. */
1503 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 }
Brett Russcdcca89e2005-03-28 15:10:27 -05001505 scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
1507 /* wait for phy to become ready, if necessary */
1508 do {
1509 msleep(200);
1510 sstatus = scr_read(ap, SCR_STATUS);
1511 if ((sstatus & 0xf) != 1)
1512 break;
1513 } while (time_before(jiffies, timeout));
1514
Tejun Heo3be680b2005-12-19 22:35:02 +09001515 /* print link status */
1516 sata_print_link_status(ap);
Jeff Garzik656563e2005-11-20 03:36:45 -05001517
Tejun Heo3be680b2005-12-19 22:35:02 +09001518 /* TODO: phy layer with polling, timeouts, etc. */
1519 if (sata_dev_present(ap))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 ata_port_probe(ap);
Tejun Heo3be680b2005-12-19 22:35:02 +09001521 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 ata_port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523
1524 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1525 return;
1526
1527 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1528 ata_port_disable(ap);
1529 return;
1530 }
1531
1532 ap->cbl = ATA_CBL_SATA;
1533}
1534
1535/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001536 * sata_phy_reset - Reset SATA bus.
1537 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001539 * This function resets the SATA bus, and then probes
1540 * the bus for devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 *
1542 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001543 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 *
1545 */
1546void sata_phy_reset(struct ata_port *ap)
1547{
1548 __sata_phy_reset(ap);
1549 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1550 return;
1551 ata_bus_reset(ap);
1552}
1553
1554/**
Alan Coxebdfca62006-03-23 15:38:34 +00001555 * ata_dev_pair - return other device on cable
1556 * @ap: port
1557 * @adev: device
1558 *
1559 * Obtain the other device on the same cable, or if none is
1560 * present NULL is returned
1561 */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001562
Alan Coxebdfca62006-03-23 15:38:34 +00001563struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
1564{
1565 struct ata_device *pair = &ap->device[1 - adev->devno];
1566 if (!ata_dev_present(pair))
1567 return NULL;
1568 return pair;
1569}
1570
1571/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001572 * ata_port_disable - Disable port.
1573 * @ap: Port to be disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001575 * Modify @ap data structure such that the system
1576 * thinks that the entire port is disabled, and should
1577 * never attempt to probe or communicate with devices
1578 * on this port.
1579 *
1580 * LOCKING: host_set lock, or some other form of
1581 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 */
1583
1584void ata_port_disable(struct ata_port *ap)
1585{
1586 ap->device[0].class = ATA_DEV_NONE;
1587 ap->device[1].class = ATA_DEV_NONE;
1588 ap->flags |= ATA_FLAG_PORT_DISABLED;
1589}
1590
Alan Cox452503f2005-10-21 19:01:32 -04001591/*
1592 * This mode timing computation functionality is ported over from
1593 * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
1594 */
1595/*
1596 * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
1597 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
1598 * for PIO 5, which is a nonstandard extension and UDMA6, which
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001599 * is currently supported only by Maxtor drives.
Alan Cox452503f2005-10-21 19:01:32 -04001600 */
1601
1602static const struct ata_timing ata_timing[] = {
1603
1604 { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 },
1605 { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 },
1606 { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 },
1607 { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 },
1608
1609 { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 },
1610 { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 },
1611 { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 },
1612
1613/* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001614
Alan Cox452503f2005-10-21 19:01:32 -04001615 { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 },
1616 { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 },
1617 { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 },
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001618
Alan Cox452503f2005-10-21 19:01:32 -04001619 { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 },
1620 { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 },
1621 { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 },
1622
1623/* { XFER_PIO_5, 20, 50, 30, 100, 50, 30, 100, 0 }, */
1624 { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 },
1625 { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 },
1626
1627 { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 },
1628 { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 },
1629 { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 },
1630
1631/* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */
1632
1633 { 0xFF }
1634};
1635
1636#define ENOUGH(v,unit) (((v)-1)/(unit)+1)
1637#define EZ(v,unit) ((v)?ENOUGH(v,unit):0)
1638
1639static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
1640{
1641 q->setup = EZ(t->setup * 1000, T);
1642 q->act8b = EZ(t->act8b * 1000, T);
1643 q->rec8b = EZ(t->rec8b * 1000, T);
1644 q->cyc8b = EZ(t->cyc8b * 1000, T);
1645 q->active = EZ(t->active * 1000, T);
1646 q->recover = EZ(t->recover * 1000, T);
1647 q->cycle = EZ(t->cycle * 1000, T);
1648 q->udma = EZ(t->udma * 1000, UT);
1649}
1650
1651void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
1652 struct ata_timing *m, unsigned int what)
1653{
1654 if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup);
1655 if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b);
1656 if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b);
1657 if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b);
1658 if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active);
1659 if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
1660 if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle);
1661 if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma);
1662}
1663
1664static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
1665{
1666 const struct ata_timing *t;
1667
1668 for (t = ata_timing; t->mode != speed; t++)
Alan Cox91190752005-10-26 12:17:46 -04001669 if (t->mode == 0xFF)
Alan Cox452503f2005-10-21 19:01:32 -04001670 return NULL;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001671 return t;
Alan Cox452503f2005-10-21 19:01:32 -04001672}
1673
1674int ata_timing_compute(struct ata_device *adev, unsigned short speed,
1675 struct ata_timing *t, int T, int UT)
1676{
1677 const struct ata_timing *s;
1678 struct ata_timing p;
1679
1680 /*
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001681 * Find the mode.
Albert Lee75b1f2f2005-11-16 17:06:18 +08001682 */
Alan Cox452503f2005-10-21 19:01:32 -04001683
1684 if (!(s = ata_timing_find_mode(speed)))
1685 return -EINVAL;
1686
Albert Lee75b1f2f2005-11-16 17:06:18 +08001687 memcpy(t, s, sizeof(*s));
1688
Alan Cox452503f2005-10-21 19:01:32 -04001689 /*
1690 * If the drive is an EIDE drive, it can tell us it needs extended
1691 * PIO/MW_DMA cycle timing.
1692 */
1693
1694 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
1695 memset(&p, 0, sizeof(p));
1696 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
1697 if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
1698 else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
1699 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
1700 p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
1701 }
1702 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
1703 }
1704
1705 /*
1706 * Convert the timing to bus clock counts.
1707 */
1708
Albert Lee75b1f2f2005-11-16 17:06:18 +08001709 ata_timing_quantize(t, t, T, UT);
Alan Cox452503f2005-10-21 19:01:32 -04001710
1711 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001712 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
1713 * S.M.A.R.T * and some other commands. We have to ensure that the
1714 * DMA cycle timing is slower/equal than the fastest PIO timing.
Alan Cox452503f2005-10-21 19:01:32 -04001715 */
1716
1717 if (speed > XFER_PIO_4) {
1718 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
1719 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
1720 }
1721
1722 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001723 * Lengthen active & recovery time so that cycle time is correct.
Alan Cox452503f2005-10-21 19:01:32 -04001724 */
1725
1726 if (t->act8b + t->rec8b < t->cyc8b) {
1727 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
1728 t->rec8b = t->cyc8b - t->act8b;
1729 }
1730
1731 if (t->active + t->recover < t->cycle) {
1732 t->active += (t->cycle - (t->active + t->recover)) / 2;
1733 t->recover = t->cycle - t->active;
1734 }
1735
1736 return 0;
1737}
1738
Tejun Heo83206a22006-03-24 15:25:31 +09001739static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740{
Tejun Heo83206a22006-03-24 15:25:31 +09001741 unsigned int err_mask;
1742 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743
1744 if (dev->xfer_shift == ATA_SHIFT_PIO)
1745 dev->flags |= ATA_DFLAG_PIO;
1746
Tejun Heo83206a22006-03-24 15:25:31 +09001747 err_mask = ata_dev_set_xfermode(ap, dev);
1748 if (err_mask) {
1749 printk(KERN_ERR
1750 "ata%u: failed to set xfermode (err_mask=0x%x)\n",
1751 ap->id, err_mask);
1752 return -EIO;
1753 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
Tejun Heo83206a22006-03-24 15:25:31 +09001755 rc = ata_dev_revalidate(ap, dev, 0);
1756 if (rc) {
1757 printk(KERN_ERR
1758 "ata%u: failed to revalidate after set xfermode\n",
1759 ap->id);
1760 return rc;
Tejun Heo48a8a142006-03-05 17:55:58 +09001761 }
1762
Tejun Heo23e71c32006-03-06 04:31:57 +09001763 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
1764 dev->xfer_shift, (int)dev->xfer_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765
1766 printk(KERN_INFO "ata%u: dev %u configured for %s\n",
Tejun Heo23e71c32006-03-06 04:31:57 +09001767 ap->id, dev->devno,
1768 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
Tejun Heo83206a22006-03-24 15:25:31 +09001769 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770}
1771
1772static int ata_host_set_pio(struct ata_port *ap)
1773{
Tejun Heoa6d5a512006-03-06 04:31:57 +09001774 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775
1776 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1777 struct ata_device *dev = &ap->device[i];
Tejun Heoa6d5a512006-03-06 04:31:57 +09001778
1779 if (!ata_dev_present(dev))
1780 continue;
1781
1782 if (!dev->pio_mode) {
Alan Cox88f93a32006-03-21 16:04:12 +00001783 printk(KERN_WARNING "ata%u: no PIO support for device %d.\n", ap->id, i);
Tejun Heoa6d5a512006-03-06 04:31:57 +09001784 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 }
Tejun Heoa6d5a512006-03-06 04:31:57 +09001786
1787 dev->xfer_mode = dev->pio_mode;
1788 dev->xfer_shift = ATA_SHIFT_PIO;
1789 if (ap->ops->set_piomode)
1790 ap->ops->set_piomode(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 }
1792
1793 return 0;
1794}
1795
Tejun Heoa6d5a512006-03-06 04:31:57 +09001796static void ata_host_set_dma(struct ata_port *ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797{
1798 int i;
1799
1800 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1801 struct ata_device *dev = &ap->device[i];
Tejun Heoa6d5a512006-03-06 04:31:57 +09001802
1803 if (!ata_dev_present(dev) || !dev->dma_mode)
1804 continue;
1805
1806 dev->xfer_mode = dev->dma_mode;
1807 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
1808 if (ap->ops->set_dmamode)
1809 ap->ops->set_dmamode(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 }
1811}
1812
1813/**
1814 * ata_set_mode - Program timings and issue SET FEATURES - XFER
1815 * @ap: port on which timings will be programmed
1816 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001817 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.).
1818 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001820 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 */
1822static void ata_set_mode(struct ata_port *ap)
1823{
Alan Cox5444a6f2006-03-27 18:58:20 +01001824 int i, rc, used_dma = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825
Tejun Heoa6d5a512006-03-06 04:31:57 +09001826 /* step 1: calculate xfer_mask */
1827 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1828 struct ata_device *dev = &ap->device[i];
Tejun Heoacf356b2006-03-24 14:07:50 +09001829 unsigned int pio_mask, dma_mask;
Tejun Heoa6d5a512006-03-06 04:31:57 +09001830
1831 if (!ata_dev_present(dev))
1832 continue;
1833
Tejun Heoacf356b2006-03-24 14:07:50 +09001834 ata_dev_xfermask(ap, dev);
Tejun Heoa6d5a512006-03-06 04:31:57 +09001835
Tejun Heoacf356b2006-03-24 14:07:50 +09001836 /* TODO: let LLDD filter dev->*_mask here */
1837
1838 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
1839 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
1840 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
1841 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
Alan Cox5444a6f2006-03-27 18:58:20 +01001842
1843 if (dev->dma_mode)
1844 used_dma = 1;
Tejun Heoa6d5a512006-03-06 04:31:57 +09001845 }
1846
1847 /* step 2: always set host PIO timings */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 rc = ata_host_set_pio(ap);
1849 if (rc)
1850 goto err_out;
1851
Tejun Heoa6d5a512006-03-06 04:31:57 +09001852 /* step 3: set host DMA timings */
1853 ata_host_set_dma(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854
1855 /* step 4: update devices' xfer mode */
Tejun Heo83206a22006-03-24 15:25:31 +09001856 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1857 struct ata_device *dev = &ap->device[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858
Tejun Heo83206a22006-03-24 15:25:31 +09001859 if (!ata_dev_present(dev))
1860 continue;
1861
1862 if (ata_dev_set_mode(ap, dev))
1863 goto err_out;
1864 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
Alan Cox5444a6f2006-03-27 18:58:20 +01001866 /*
1867 * Record simplex status. If we selected DMA then the other
1868 * host channels are not permitted to do so.
1869 */
1870
1871 if (used_dma && (ap->host_set->flags & ATA_HOST_SIMPLEX))
1872 ap->host_set->simplex_claimed = 1;
1873
1874 /*
1875 * Chip specific finalisation
1876 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 if (ap->ops->post_set_mode)
1878 ap->ops->post_set_mode(ap);
1879
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 return;
1881
1882err_out:
1883 ata_port_disable(ap);
1884}
1885
1886/**
Jeff Garzik1fdffbc2006-02-09 05:15:27 -05001887 * ata_tf_to_host - issue ATA taskfile to host controller
1888 * @ap: port to which command is being issued
1889 * @tf: ATA taskfile register set
1890 *
1891 * Issues ATA taskfile register set to ATA host controller,
1892 * with proper synchronization with interrupt handler and
1893 * other threads.
1894 *
1895 * LOCKING:
1896 * spin_lock_irqsave(host_set lock)
1897 */
1898
1899static inline void ata_tf_to_host(struct ata_port *ap,
1900 const struct ata_taskfile *tf)
1901{
1902 ap->ops->tf_load(ap, tf);
1903 ap->ops->exec_command(ap, tf);
1904}
1905
1906/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 * ata_busy_sleep - sleep until BSY clears, or timeout
1908 * @ap: port containing status register to be polled
1909 * @tmout_pat: impatience timeout
1910 * @tmout: overall timeout
1911 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001912 * Sleep until ATA Status register bit BSY clears,
1913 * or a timeout occurs.
1914 *
1915 * LOCKING: None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 */
1917
Tejun Heo6f8b9952006-01-24 17:05:21 +09001918unsigned int ata_busy_sleep (struct ata_port *ap,
1919 unsigned long tmout_pat, unsigned long tmout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920{
1921 unsigned long timer_start, timeout;
1922 u8 status;
1923
1924 status = ata_busy_wait(ap, ATA_BUSY, 300);
1925 timer_start = jiffies;
1926 timeout = timer_start + tmout_pat;
1927 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1928 msleep(50);
1929 status = ata_busy_wait(ap, ATA_BUSY, 3);
1930 }
1931
1932 if (status & ATA_BUSY)
1933 printk(KERN_WARNING "ata%u is slow to respond, "
1934 "please be patient\n", ap->id);
1935
1936 timeout = timer_start + tmout;
1937 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1938 msleep(50);
1939 status = ata_chk_status(ap);
1940 }
1941
1942 if (status & ATA_BUSY) {
1943 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
1944 ap->id, tmout / HZ);
1945 return 1;
1946 }
1947
1948 return 0;
1949}
1950
1951static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
1952{
1953 struct ata_ioports *ioaddr = &ap->ioaddr;
1954 unsigned int dev0 = devmask & (1 << 0);
1955 unsigned int dev1 = devmask & (1 << 1);
1956 unsigned long timeout;
1957
1958 /* if device 0 was found in ata_devchk, wait for its
1959 * BSY bit to clear
1960 */
1961 if (dev0)
1962 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1963
1964 /* if device 1 was found in ata_devchk, wait for
1965 * register access, then wait for BSY to clear
1966 */
1967 timeout = jiffies + ATA_TMOUT_BOOT;
1968 while (dev1) {
1969 u8 nsect, lbal;
1970
1971 ap->ops->dev_select(ap, 1);
1972 if (ap->flags & ATA_FLAG_MMIO) {
1973 nsect = readb((void __iomem *) ioaddr->nsect_addr);
1974 lbal = readb((void __iomem *) ioaddr->lbal_addr);
1975 } else {
1976 nsect = inb(ioaddr->nsect_addr);
1977 lbal = inb(ioaddr->lbal_addr);
1978 }
1979 if ((nsect == 1) && (lbal == 1))
1980 break;
1981 if (time_after(jiffies, timeout)) {
1982 dev1 = 0;
1983 break;
1984 }
1985 msleep(50); /* give drive a breather */
1986 }
1987 if (dev1)
1988 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1989
1990 /* is all this really necessary? */
1991 ap->ops->dev_select(ap, 0);
1992 if (dev1)
1993 ap->ops->dev_select(ap, 1);
1994 if (dev0)
1995 ap->ops->dev_select(ap, 0);
1996}
1997
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998static unsigned int ata_bus_softreset(struct ata_port *ap,
1999 unsigned int devmask)
2000{
2001 struct ata_ioports *ioaddr = &ap->ioaddr;
2002
2003 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
2004
2005 /* software reset. causes dev0 to be selected */
2006 if (ap->flags & ATA_FLAG_MMIO) {
2007 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2008 udelay(20); /* FIXME: flush */
2009 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
2010 udelay(20); /* FIXME: flush */
2011 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2012 } else {
2013 outb(ap->ctl, ioaddr->ctl_addr);
2014 udelay(10);
2015 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2016 udelay(10);
2017 outb(ap->ctl, ioaddr->ctl_addr);
2018 }
2019
2020 /* spec mandates ">= 2ms" before checking status.
2021 * We wait 150ms, because that was the magic delay used for
2022 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
2023 * between when the ATA command register is written, and then
2024 * status is checked. Because waiting for "a while" before
2025 * checking status is fine, post SRST, we perform this magic
2026 * delay here as well.
Alan Cox09c7ad72006-03-22 15:52:40 +00002027 *
2028 * Old drivers/ide uses the 2mS rule and then waits for ready
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 */
2030 msleep(150);
2031
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002032 /* Before we perform post reset processing we want to see if
Tejun Heo298a41c2006-03-25 02:58:13 +09002033 * the bus shows 0xFF because the odd clown forgets the D7
2034 * pulldown resistor.
2035 */
Alan Cox09c7ad72006-03-22 15:52:40 +00002036 if (ata_check_status(ap) == 0xFF)
Tejun Heo298a41c2006-03-25 02:58:13 +09002037 return AC_ERR_OTHER;
Alan Cox09c7ad72006-03-22 15:52:40 +00002038
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 ata_bus_post_reset(ap, devmask);
2040
2041 return 0;
2042}
2043
2044/**
2045 * ata_bus_reset - reset host port and associated ATA channel
2046 * @ap: port to reset
2047 *
2048 * This is typically the first time we actually start issuing
2049 * commands to the ATA channel. We wait for BSY to clear, then
2050 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
2051 * result. Determine what devices, if any, are on the channel
2052 * by looking at the device 0/1 error register. Look at the signature
2053 * stored in each device's taskfile registers, to determine if
2054 * the device is ATA or ATAPI.
2055 *
2056 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002057 * PCI/etc. bus probe sem.
2058 * Obtains host_set lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 *
2060 * SIDE EFFECTS:
2061 * Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
2062 */
2063
2064void ata_bus_reset(struct ata_port *ap)
2065{
2066 struct ata_ioports *ioaddr = &ap->ioaddr;
2067 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2068 u8 err;
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002069 unsigned int dev0, dev1 = 0, devmask = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070
2071 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
2072
2073 /* determine if device 0/1 are present */
2074 if (ap->flags & ATA_FLAG_SATA_RESET)
2075 dev0 = 1;
2076 else {
2077 dev0 = ata_devchk(ap, 0);
2078 if (slave_possible)
2079 dev1 = ata_devchk(ap, 1);
2080 }
2081
2082 if (dev0)
2083 devmask |= (1 << 0);
2084 if (dev1)
2085 devmask |= (1 << 1);
2086
2087 /* select device 0 again */
2088 ap->ops->dev_select(ap, 0);
2089
2090 /* issue bus reset */
2091 if (ap->flags & ATA_FLAG_SRST)
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002092 if (ata_bus_softreset(ap, devmask))
2093 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094
2095 /*
2096 * determine by signature whether we have ATA or ATAPI devices
2097 */
Tejun Heob4dc7622006-01-24 17:05:22 +09002098 ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 if ((slave_possible) && (err != 0x81))
Tejun Heob4dc7622006-01-24 17:05:22 +09002100 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101
2102 /* re-enable interrupts */
2103 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2104 ata_irq_on(ap);
2105
2106 /* is double-select really necessary? */
2107 if (ap->device[1].class != ATA_DEV_NONE)
2108 ap->ops->dev_select(ap, 1);
2109 if (ap->device[0].class != ATA_DEV_NONE)
2110 ap->ops->dev_select(ap, 0);
2111
2112 /* if no devices were detected, disable this port */
2113 if ((ap->device[0].class == ATA_DEV_NONE) &&
2114 (ap->device[1].class == ATA_DEV_NONE))
2115 goto err_out;
2116
2117 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2118 /* set up device control for ATA_FLAG_SATA_RESET */
2119 if (ap->flags & ATA_FLAG_MMIO)
2120 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2121 else
2122 outb(ap->ctl, ioaddr->ctl_addr);
2123 }
2124
2125 DPRINTK("EXIT\n");
2126 return;
2127
2128err_out:
2129 printk(KERN_ERR "ata%u: disabling port\n", ap->id);
2130 ap->ops->port_disable(ap);
2131
2132 DPRINTK("EXIT\n");
2133}
2134
Tejun Heo7a7921e2006-02-02 18:20:00 +09002135static int sata_phy_resume(struct ata_port *ap)
2136{
2137 unsigned long timeout = jiffies + (HZ * 5);
2138 u32 sstatus;
2139
2140 scr_write_flush(ap, SCR_CONTROL, 0x300);
2141
2142 /* Wait for phy to become ready, if necessary. */
2143 do {
2144 msleep(200);
2145 sstatus = scr_read(ap, SCR_STATUS);
2146 if ((sstatus & 0xf) != 1)
2147 return 0;
2148 } while (time_before(jiffies, timeout));
2149
2150 return -1;
2151}
2152
Tejun Heoc2bd5802006-01-24 17:05:22 +09002153/**
Tejun Heo8a19ac82006-02-02 18:20:00 +09002154 * ata_std_probeinit - initialize probing
2155 * @ap: port to be probed
2156 *
2157 * @ap is about to be probed. Initialize it. This function is
2158 * to be used as standard callback for ata_drive_probe_reset().
Tejun Heo3a397462006-02-10 23:58:48 +09002159 *
2160 * NOTE!!! Do not use this function as probeinit if a low level
2161 * driver implements only hardreset. Just pass NULL as probeinit
2162 * in that case. Using this function is probably okay but doing
2163 * so makes reset sequence different from the original
2164 * ->phy_reset implementation and Jeff nervous. :-P
Tejun Heo8a19ac82006-02-02 18:20:00 +09002165 */
Alan Cox17efc5f2006-03-27 19:01:32 +01002166void ata_std_probeinit(struct ata_port *ap)
Tejun Heo8a19ac82006-02-02 18:20:00 +09002167{
Alan Cox17efc5f2006-03-27 19:01:32 +01002168 if ((ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read) {
Tejun Heo8a19ac82006-02-02 18:20:00 +09002169 sata_phy_resume(ap);
Tejun Heo3a397462006-02-10 23:58:48 +09002170 if (sata_dev_present(ap))
2171 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2172 }
Tejun Heo8a19ac82006-02-02 18:20:00 +09002173}
2174
2175/**
Tejun Heoc2bd5802006-01-24 17:05:22 +09002176 * ata_std_softreset - reset host port via ATA SRST
2177 * @ap: port to reset
2178 * @verbose: fail verbosely
2179 * @classes: resulting classes of attached devices
2180 *
2181 * Reset host port using ATA SRST. This function is to be used
2182 * as standard callback for ata_drive_*_reset() functions.
2183 *
2184 * LOCKING:
2185 * Kernel thread context (may sleep)
2186 *
2187 * RETURNS:
2188 * 0 on success, -errno otherwise.
2189 */
2190int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
2191{
2192 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2193 unsigned int devmask = 0, err_mask;
2194 u8 err;
2195
2196 DPRINTK("ENTER\n");
2197
Tejun Heo3a397462006-02-10 23:58:48 +09002198 if (ap->ops->scr_read && !sata_dev_present(ap)) {
2199 classes[0] = ATA_DEV_NONE;
2200 goto out;
2201 }
2202
Tejun Heoc2bd5802006-01-24 17:05:22 +09002203 /* determine if device 0/1 are present */
2204 if (ata_devchk(ap, 0))
2205 devmask |= (1 << 0);
2206 if (slave_possible && ata_devchk(ap, 1))
2207 devmask |= (1 << 1);
2208
Tejun Heoc2bd5802006-01-24 17:05:22 +09002209 /* select device 0 again */
2210 ap->ops->dev_select(ap, 0);
2211
2212 /* issue bus reset */
2213 DPRINTK("about to softreset, devmask=%x\n", devmask);
2214 err_mask = ata_bus_softreset(ap, devmask);
2215 if (err_mask) {
2216 if (verbose)
2217 printk(KERN_ERR "ata%u: SRST failed (err_mask=0x%x)\n",
2218 ap->id, err_mask);
2219 else
2220 DPRINTK("EXIT, softreset failed (err_mask=0x%x)\n",
2221 err_mask);
2222 return -EIO;
2223 }
2224
2225 /* determine by signature whether we have ATA or ATAPI devices */
2226 classes[0] = ata_dev_try_classify(ap, 0, &err);
2227 if (slave_possible && err != 0x81)
2228 classes[1] = ata_dev_try_classify(ap, 1, &err);
2229
Tejun Heo3a397462006-02-10 23:58:48 +09002230 out:
Tejun Heoc2bd5802006-01-24 17:05:22 +09002231 DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
2232 return 0;
2233}
2234
2235/**
2236 * sata_std_hardreset - reset host port via SATA phy reset
2237 * @ap: port to reset
2238 * @verbose: fail verbosely
2239 * @class: resulting class of attached device
2240 *
2241 * SATA phy-reset host port using DET bits of SControl register.
2242 * This function is to be used as standard callback for
2243 * ata_drive_*_reset().
2244 *
2245 * LOCKING:
2246 * Kernel thread context (may sleep)
2247 *
2248 * RETURNS:
2249 * 0 on success, -errno otherwise.
2250 */
2251int sata_std_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
2252{
Tejun Heoc2bd5802006-01-24 17:05:22 +09002253 DPRINTK("ENTER\n");
2254
2255 /* Issue phy wake/reset */
2256 scr_write_flush(ap, SCR_CONTROL, 0x301);
2257
2258 /*
2259 * Couldn't find anything in SATA I/II specs, but AHCI-1.1
2260 * 10.4.2 says at least 1 ms.
2261 */
2262 msleep(1);
2263
Tejun Heo7a7921e2006-02-02 18:20:00 +09002264 /* Bring phy back */
2265 sata_phy_resume(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002266
Tejun Heoc2bd5802006-01-24 17:05:22 +09002267 /* TODO: phy layer with polling, timeouts, etc. */
2268 if (!sata_dev_present(ap)) {
2269 *class = ATA_DEV_NONE;
2270 DPRINTK("EXIT, link offline\n");
2271 return 0;
2272 }
2273
2274 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
2275 if (verbose)
2276 printk(KERN_ERR "ata%u: COMRESET failed "
2277 "(device not ready)\n", ap->id);
2278 else
2279 DPRINTK("EXIT, device not ready\n");
2280 return -EIO;
2281 }
2282
Tejun Heo3a397462006-02-10 23:58:48 +09002283 ap->ops->dev_select(ap, 0); /* probably unnecessary */
2284
Tejun Heoc2bd5802006-01-24 17:05:22 +09002285 *class = ata_dev_try_classify(ap, 0, NULL);
2286
2287 DPRINTK("EXIT, class=%u\n", *class);
2288 return 0;
2289}
2290
2291/**
2292 * ata_std_postreset - standard postreset callback
2293 * @ap: the target ata_port
2294 * @classes: classes of attached devices
2295 *
2296 * This function is invoked after a successful reset. Note that
2297 * the device might have been reset more than once using
2298 * different reset methods before postreset is invoked.
Tejun Heoc2bd5802006-01-24 17:05:22 +09002299 *
2300 * This function is to be used as standard callback for
2301 * ata_drive_*_reset().
2302 *
2303 * LOCKING:
2304 * Kernel thread context (may sleep)
2305 */
2306void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
2307{
2308 DPRINTK("ENTER\n");
2309
Tejun Heo56497bd2006-02-15 15:01:42 +09002310 /* set cable type if it isn't already set */
Tejun Heoc2bd5802006-01-24 17:05:22 +09002311 if (ap->cbl == ATA_CBL_NONE && ap->flags & ATA_FLAG_SATA)
2312 ap->cbl = ATA_CBL_SATA;
2313
2314 /* print link status */
2315 if (ap->cbl == ATA_CBL_SATA)
2316 sata_print_link_status(ap);
2317
Tejun Heo3a397462006-02-10 23:58:48 +09002318 /* re-enable interrupts */
2319 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2320 ata_irq_on(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002321
2322 /* is double-select really necessary? */
2323 if (classes[0] != ATA_DEV_NONE)
2324 ap->ops->dev_select(ap, 1);
2325 if (classes[1] != ATA_DEV_NONE)
2326 ap->ops->dev_select(ap, 0);
2327
Tejun Heo3a397462006-02-10 23:58:48 +09002328 /* bail out if no device is present */
2329 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2330 DPRINTK("EXIT, no device\n");
2331 return;
2332 }
2333
2334 /* set up device control */
2335 if (ap->ioaddr.ctl_addr) {
2336 if (ap->flags & ATA_FLAG_MMIO)
2337 writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
2338 else
2339 outb(ap->ctl, ap->ioaddr.ctl_addr);
2340 }
Tejun Heoc2bd5802006-01-24 17:05:22 +09002341
2342 DPRINTK("EXIT\n");
2343}
2344
2345/**
2346 * ata_std_probe_reset - standard probe reset method
2347 * @ap: prot to perform probe-reset
2348 * @classes: resulting classes of attached devices
2349 *
2350 * The stock off-the-shelf ->probe_reset method.
2351 *
2352 * LOCKING:
2353 * Kernel thread context (may sleep)
2354 *
2355 * RETURNS:
2356 * 0 on success, -errno otherwise.
2357 */
2358int ata_std_probe_reset(struct ata_port *ap, unsigned int *classes)
2359{
2360 ata_reset_fn_t hardreset;
2361
2362 hardreset = NULL;
Tejun Heob911fc32006-02-02 18:20:00 +09002363 if (ap->flags & ATA_FLAG_SATA && ap->ops->scr_read)
Tejun Heoc2bd5802006-01-24 17:05:22 +09002364 hardreset = sata_std_hardreset;
2365
Tejun Heo8a19ac82006-02-02 18:20:00 +09002366 return ata_drive_probe_reset(ap, ata_std_probeinit,
Tejun Heo7944ea92006-02-02 18:20:00 +09002367 ata_std_softreset, hardreset,
Tejun Heoc2bd5802006-01-24 17:05:22 +09002368 ata_std_postreset, classes);
2369}
2370
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002371static int do_probe_reset(struct ata_port *ap, ata_reset_fn_t reset,
2372 ata_postreset_fn_t postreset,
2373 unsigned int *classes)
2374{
2375 int i, rc;
2376
2377 for (i = 0; i < ATA_MAX_DEVICES; i++)
2378 classes[i] = ATA_DEV_UNKNOWN;
2379
2380 rc = reset(ap, 0, classes);
2381 if (rc)
2382 return rc;
2383
2384 /* If any class isn't ATA_DEV_UNKNOWN, consider classification
2385 * is complete and convert all ATA_DEV_UNKNOWN to
2386 * ATA_DEV_NONE.
2387 */
2388 for (i = 0; i < ATA_MAX_DEVICES; i++)
2389 if (classes[i] != ATA_DEV_UNKNOWN)
2390 break;
2391
2392 if (i < ATA_MAX_DEVICES)
2393 for (i = 0; i < ATA_MAX_DEVICES; i++)
2394 if (classes[i] == ATA_DEV_UNKNOWN)
2395 classes[i] = ATA_DEV_NONE;
2396
2397 if (postreset)
2398 postreset(ap, classes);
2399
2400 return classes[0] != ATA_DEV_UNKNOWN ? 0 : -ENODEV;
2401}
2402
2403/**
2404 * ata_drive_probe_reset - Perform probe reset with given methods
2405 * @ap: port to reset
Tejun Heo7944ea92006-02-02 18:20:00 +09002406 * @probeinit: probeinit method (can be NULL)
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002407 * @softreset: softreset method (can be NULL)
2408 * @hardreset: hardreset method (can be NULL)
2409 * @postreset: postreset method (can be NULL)
2410 * @classes: resulting classes of attached devices
2411 *
2412 * Reset the specified port and classify attached devices using
2413 * given methods. This function prefers softreset but tries all
2414 * possible reset sequences to reset and classify devices. This
2415 * function is intended to be used for constructing ->probe_reset
2416 * callback by low level drivers.
2417 *
2418 * Reset methods should follow the following rules.
2419 *
2420 * - Return 0 on sucess, -errno on failure.
2421 * - If classification is supported, fill classes[] with
2422 * recognized class codes.
2423 * - If classification is not supported, leave classes[] alone.
2424 * - If verbose is non-zero, print error message on failure;
2425 * otherwise, shut up.
2426 *
2427 * LOCKING:
2428 * Kernel thread context (may sleep)
2429 *
2430 * RETURNS:
2431 * 0 on success, -EINVAL if no reset method is avaliable, -ENODEV
2432 * if classification fails, and any error code from reset
2433 * methods.
2434 */
Tejun Heo7944ea92006-02-02 18:20:00 +09002435int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002436 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2437 ata_postreset_fn_t postreset, unsigned int *classes)
2438{
2439 int rc = -EINVAL;
2440
Tejun Heo7944ea92006-02-02 18:20:00 +09002441 if (probeinit)
2442 probeinit(ap);
2443
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002444 if (softreset) {
2445 rc = do_probe_reset(ap, softreset, postreset, classes);
2446 if (rc == 0)
2447 return 0;
2448 }
2449
2450 if (!hardreset)
2451 return rc;
2452
2453 rc = do_probe_reset(ap, hardreset, postreset, classes);
2454 if (rc == 0 || rc != -ENODEV)
2455 return rc;
2456
2457 if (softreset)
2458 rc = do_probe_reset(ap, softreset, postreset, classes);
2459
2460 return rc;
2461}
2462
Tejun Heo623a3122006-03-05 17:55:58 +09002463/**
2464 * ata_dev_same_device - Determine whether new ID matches configured device
2465 * @ap: port on which the device to compare against resides
2466 * @dev: device to compare against
2467 * @new_class: class of the new device
2468 * @new_id: IDENTIFY page of the new device
2469 *
2470 * Compare @new_class and @new_id against @dev and determine
2471 * whether @dev is the device indicated by @new_class and
2472 * @new_id.
2473 *
2474 * LOCKING:
2475 * None.
2476 *
2477 * RETURNS:
2478 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
2479 */
2480static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
2481 unsigned int new_class, const u16 *new_id)
2482{
2483 const u16 *old_id = dev->id;
2484 unsigned char model[2][41], serial[2][21];
2485 u64 new_n_sectors;
2486
2487 if (dev->class != new_class) {
2488 printk(KERN_INFO
2489 "ata%u: dev %u class mismatch %d != %d\n",
2490 ap->id, dev->devno, dev->class, new_class);
2491 return 0;
2492 }
2493
2494 ata_id_c_string(old_id, model[0], ATA_ID_PROD_OFS, sizeof(model[0]));
2495 ata_id_c_string(new_id, model[1], ATA_ID_PROD_OFS, sizeof(model[1]));
2496 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO_OFS, sizeof(serial[0]));
2497 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO_OFS, sizeof(serial[1]));
2498 new_n_sectors = ata_id_n_sectors(new_id);
2499
2500 if (strcmp(model[0], model[1])) {
2501 printk(KERN_INFO
2502 "ata%u: dev %u model number mismatch '%s' != '%s'\n",
2503 ap->id, dev->devno, model[0], model[1]);
2504 return 0;
2505 }
2506
2507 if (strcmp(serial[0], serial[1])) {
2508 printk(KERN_INFO
2509 "ata%u: dev %u serial number mismatch '%s' != '%s'\n",
2510 ap->id, dev->devno, serial[0], serial[1]);
2511 return 0;
2512 }
2513
2514 if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
2515 printk(KERN_INFO
2516 "ata%u: dev %u n_sectors mismatch %llu != %llu\n",
2517 ap->id, dev->devno, (unsigned long long)dev->n_sectors,
2518 (unsigned long long)new_n_sectors);
2519 return 0;
2520 }
2521
2522 return 1;
2523}
2524
2525/**
2526 * ata_dev_revalidate - Revalidate ATA device
2527 * @ap: port on which the device to revalidate resides
2528 * @dev: device to revalidate
2529 * @post_reset: is this revalidation after reset?
2530 *
2531 * Re-read IDENTIFY page and make sure @dev is still attached to
2532 * the port.
2533 *
2534 * LOCKING:
2535 * Kernel thread context (may sleep)
2536 *
2537 * RETURNS:
2538 * 0 on success, negative errno otherwise
2539 */
2540int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
2541 int post_reset)
2542{
2543 unsigned int class;
2544 u16 *id;
2545 int rc;
2546
2547 if (!ata_dev_present(dev))
2548 return -ENODEV;
2549
2550 class = dev->class;
2551 id = NULL;
2552
2553 /* allocate & read ID data */
2554 rc = ata_dev_read_id(ap, dev, &class, post_reset, &id);
2555 if (rc)
2556 goto fail;
2557
2558 /* is the device still there? */
2559 if (!ata_dev_same_device(ap, dev, class, id)) {
2560 rc = -ENODEV;
2561 goto fail;
2562 }
2563
2564 kfree(dev->id);
2565 dev->id = id;
2566
2567 /* configure device according to the new ID */
2568 return ata_dev_configure(ap, dev, 0);
2569
2570 fail:
2571 printk(KERN_ERR "ata%u: dev %u revalidation failed (errno=%d)\n",
2572 ap->id, dev->devno, rc);
2573 kfree(id);
2574 return rc;
2575}
2576
Arjan van de Ven98ac62d2005-11-28 10:06:23 +01002577static const char * const ata_dma_blacklist [] = {
Alan Coxf4b15fe2006-03-22 15:54:04 +00002578 "WDC AC11000H", NULL,
2579 "WDC AC22100H", NULL,
2580 "WDC AC32500H", NULL,
2581 "WDC AC33100H", NULL,
2582 "WDC AC31600H", NULL,
2583 "WDC AC32100H", "24.09P07",
2584 "WDC AC23200L", "21.10N21",
2585 "Compaq CRD-8241B", NULL,
2586 "CRD-8400B", NULL,
2587 "CRD-8480B", NULL,
2588 "CRD-8482B", NULL,
2589 "CRD-84", NULL,
2590 "SanDisk SDP3B", NULL,
2591 "SanDisk SDP3B-64", NULL,
2592 "SANYO CD-ROM CRD", NULL,
2593 "HITACHI CDR-8", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002594 "HITACHI CDR-8335", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002595 "HITACHI CDR-8435", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002596 "Toshiba CD-ROM XM-6202B", NULL,
2597 "TOSHIBA CD-ROM XM-1702BC", NULL,
2598 "CD-532E-A", NULL,
2599 "E-IDE CD-ROM CR-840", NULL,
2600 "CD-ROM Drive/F5A", NULL,
2601 "WPI CDD-820", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002602 "SAMSUNG CD-ROM SC-148C", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002603 "SAMSUNG CD-ROM SC", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002604 "SanDisk SDP3B-64", NULL,
2605 "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
2606 "_NEC DV5800A", NULL,
2607 "SAMSUNG CD-ROM SN-124", "N001"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608};
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002609
Alan Coxf4b15fe2006-03-22 15:54:04 +00002610static int ata_strim(char *s, size_t len)
2611{
2612 len = strnlen(s, len);
2613
2614 /* ATAPI specifies that empty space is blank-filled; remove blanks */
2615 while ((len > 0) && (s[len - 1] == ' ')) {
2616 len--;
2617 s[len] = 0;
2618 }
2619 return len;
2620}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002621
Jeff Garzik057ace52005-10-22 14:27:05 -04002622static int ata_dma_blacklisted(const struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623{
Alan Coxf4b15fe2006-03-22 15:54:04 +00002624 unsigned char model_num[40];
2625 unsigned char model_rev[16];
2626 unsigned int nlen, rlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 int i;
2628
Alan Coxf4b15fe2006-03-22 15:54:04 +00002629 ata_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
2630 sizeof(model_num));
2631 ata_id_string(dev->id, model_rev, ATA_ID_FW_REV_OFS,
2632 sizeof(model_rev));
2633 nlen = ata_strim(model_num, sizeof(model_num));
2634 rlen = ata_strim(model_rev, sizeof(model_rev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635
Alan Coxf4b15fe2006-03-22 15:54:04 +00002636 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i += 2) {
2637 if (!strncmp(ata_dma_blacklist[i], model_num, nlen)) {
2638 if (ata_dma_blacklist[i+1] == NULL)
2639 return 1;
2640 if (!strncmp(ata_dma_blacklist[i], model_rev, rlen))
2641 return 1;
2642 }
2643 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 return 0;
2645}
2646
Tejun Heoa6d5a512006-03-06 04:31:57 +09002647/**
2648 * ata_dev_xfermask - Compute supported xfermask of the given device
2649 * @ap: Port on which the device to compute xfermask for resides
2650 * @dev: Device to compute xfermask for
2651 *
Tejun Heoacf356b2006-03-24 14:07:50 +09002652 * Compute supported xfermask of @dev and store it in
2653 * dev->*_mask. This function is responsible for applying all
2654 * known limits including host controller limits, device
2655 * blacklist, etc...
Tejun Heoa6d5a512006-03-06 04:31:57 +09002656 *
Tejun Heo600511e2006-03-25 11:14:07 +09002657 * FIXME: The current implementation limits all transfer modes to
2658 * the fastest of the lowested device on the port. This is not
Tejun Heo05c8e0a2006-03-25 14:28:57 +09002659 * required on most controllers.
Tejun Heo600511e2006-03-25 11:14:07 +09002660 *
Tejun Heoa6d5a512006-03-06 04:31:57 +09002661 * LOCKING:
2662 * None.
Tejun Heoa6d5a512006-03-06 04:31:57 +09002663 */
Tejun Heoacf356b2006-03-24 14:07:50 +09002664static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665{
Alan Cox5444a6f2006-03-27 18:58:20 +01002666 struct ata_host_set *hs = ap->host_set;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002667 unsigned long xfer_mask;
2668 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669
Tejun Heoa6d5a512006-03-06 04:31:57 +09002670 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
2671 ap->udma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672
Alan Cox5444a6f2006-03-27 18:58:20 +01002673 /* FIXME: Use port-wide xfermask for now */
Tejun Heoa6d5a512006-03-06 04:31:57 +09002674 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2675 struct ata_device *d = &ap->device[i];
2676 if (!ata_dev_present(d))
2677 continue;
Tejun Heoacf356b2006-03-24 14:07:50 +09002678 xfer_mask &= ata_pack_xfermask(d->pio_mask, d->mwdma_mask,
2679 d->udma_mask);
Tejun Heoa6d5a512006-03-06 04:31:57 +09002680 xfer_mask &= ata_id_xfermask(d->id);
2681 if (ata_dma_blacklisted(d))
2682 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
Alan Cox5444a6f2006-03-27 18:58:20 +01002683 /* Apply cable rule here. Don't apply it early because when
2684 we handle hot plug the cable type can itself change */
2685 if (ap->cbl == ATA_CBL_PATA40)
2686 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687 }
2688
Tejun Heoa6d5a512006-03-06 04:31:57 +09002689 if (ata_dma_blacklisted(dev))
2690 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, "
2691 "disabling DMA\n", ap->id, dev->devno);
2692
Alan Cox5444a6f2006-03-27 18:58:20 +01002693 if (hs->flags & ATA_HOST_SIMPLEX) {
2694 if (hs->simplex_claimed)
2695 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
2696 }
2697 if (ap->ops->mode_filter)
2698 xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask);
2699
Tejun Heoacf356b2006-03-24 14:07:50 +09002700 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
2701 &dev->udma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702}
2703
Linus Torvalds1da177e2005-04-16 15:20:36 -07002704/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
2706 * @ap: Port associated with device @dev
2707 * @dev: Device to which command will be sent
2708 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002709 * Issue SET FEATURES - XFER MODE command to device @dev
2710 * on port @ap.
2711 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002713 * PCI/etc. bus probe sem.
Tejun Heo83206a22006-03-24 15:25:31 +09002714 *
2715 * RETURNS:
2716 * 0 on success, AC_ERR_* mask otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 */
2718
Tejun Heo83206a22006-03-24 15:25:31 +09002719static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
2720 struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721{
Tejun Heoa0123702005-12-13 14:49:31 +09002722 struct ata_taskfile tf;
Tejun Heo83206a22006-03-24 15:25:31 +09002723 unsigned int err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724
2725 /* set up set-features taskfile */
2726 DPRINTK("set features - xfer mode\n");
2727
Tejun Heoa0123702005-12-13 14:49:31 +09002728 ata_tf_init(ap, &tf, dev->devno);
2729 tf.command = ATA_CMD_SET_FEATURES;
2730 tf.feature = SETFEATURES_XFER;
2731 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2732 tf.protocol = ATA_PROT_NODATA;
2733 tf.nsect = dev->xfer_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734
Tejun Heo83206a22006-03-24 15:25:31 +09002735 err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736
Tejun Heo83206a22006-03-24 15:25:31 +09002737 DPRINTK("EXIT, err_mask=%x\n", err_mask);
2738 return err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739}
2740
2741/**
Albert Lee8bf62ece2005-05-12 15:29:42 -04002742 * ata_dev_init_params - Issue INIT DEV PARAMS command
2743 * @ap: Port associated with device @dev
2744 * @dev: Device to which command will be sent
Randy Dunlape2a7f772006-05-18 10:50:18 -07002745 * @heads: Number of heads (taskfile parameter)
2746 * @sectors: Number of sectors (taskfile parameter)
Albert Lee8bf62ece2005-05-12 15:29:42 -04002747 *
2748 * LOCKING:
Tejun Heo6aff8f12006-02-15 18:24:09 +09002749 * Kernel thread context (may sleep)
2750 *
2751 * RETURNS:
2752 * 0 on success, AC_ERR_* mask otherwise.
Albert Lee8bf62ece2005-05-12 15:29:42 -04002753 */
2754
Tejun Heo6aff8f12006-02-15 18:24:09 +09002755static unsigned int ata_dev_init_params(struct ata_port *ap,
Albert Lee00b6f5e2006-03-27 16:39:18 +08002756 struct ata_device *dev,
2757 u16 heads,
2758 u16 sectors)
Albert Lee8bf62ece2005-05-12 15:29:42 -04002759{
Tejun Heoa0123702005-12-13 14:49:31 +09002760 struct ata_taskfile tf;
Tejun Heo6aff8f12006-02-15 18:24:09 +09002761 unsigned int err_mask;
Albert Lee8bf62ece2005-05-12 15:29:42 -04002762
2763 /* Number of sectors per track 1-255. Number of heads 1-16 */
2764 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
Albert Lee00b6f5e2006-03-27 16:39:18 +08002765 return AC_ERR_INVALID;
Albert Lee8bf62ece2005-05-12 15:29:42 -04002766
2767 /* set up init dev params taskfile */
2768 DPRINTK("init dev params \n");
2769
Tejun Heoa0123702005-12-13 14:49:31 +09002770 ata_tf_init(ap, &tf, dev->devno);
2771 tf.command = ATA_CMD_INIT_DEV_PARAMS;
2772 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2773 tf.protocol = ATA_PROT_NODATA;
2774 tf.nsect = sectors;
2775 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
Albert Lee8bf62ece2005-05-12 15:29:42 -04002776
Tejun Heo6aff8f12006-02-15 18:24:09 +09002777 err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
Albert Lee8bf62ece2005-05-12 15:29:42 -04002778
Tejun Heo6aff8f12006-02-15 18:24:09 +09002779 DPRINTK("EXIT, err_mask=%x\n", err_mask);
2780 return err_mask;
Albert Lee8bf62ece2005-05-12 15:29:42 -04002781}
2782
2783/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04002784 * ata_sg_clean - Unmap DMA memory associated with command
2785 * @qc: Command containing DMA memory to be released
2786 *
2787 * Unmap all mapped DMA memory associated with this command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 *
2789 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002790 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 */
2792
2793static void ata_sg_clean(struct ata_queued_cmd *qc)
2794{
2795 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002796 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002798 void *pad_buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799
Tejun Heoa46314742006-02-11 19:11:13 +09002800 WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
2801 WARN_ON(sg == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802
2803 if (qc->flags & ATA_QCFLAG_SINGLE)
Jeff Garzikf1318832006-02-20 16:55:56 -05002804 WARN_ON(qc->n_elem > 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05002806 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002808 /* if we padded the buffer out to 32-bit bound, and data
2809 * xfer direction is from-device, we must copy from the
2810 * pad buffer back into the supplied buffer
2811 */
2812 if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
2813 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
2814
2815 if (qc->flags & ATA_QCFLAG_SG) {
Jeff Garzike1410f22005-11-14 14:06:26 -05002816 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06002817 dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002818 /* restore last sg */
2819 sg[qc->orig_n_elem - 1].length += qc->pad_len;
2820 if (pad_buf) {
2821 struct scatterlist *psg = &qc->pad_sgent;
2822 void *addr = kmap_atomic(psg->page, KM_IRQ0);
2823 memcpy(addr + psg->offset, pad_buf, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05002824 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002825 }
2826 } else {
Tejun Heo2e242fa2006-02-20 23:48:38 +09002827 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06002828 dma_unmap_single(ap->dev,
Jeff Garzike1410f22005-11-14 14:06:26 -05002829 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
2830 dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002831 /* restore sg */
2832 sg->length += qc->pad_len;
2833 if (pad_buf)
2834 memcpy(qc->buf_virt + sg->length - qc->pad_len,
2835 pad_buf, qc->pad_len);
2836 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837
2838 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002839 qc->__sg = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840}
2841
2842/**
2843 * ata_fill_sg - Fill PCI IDE PRD table
2844 * @qc: Metadata associated with taskfile to be transferred
2845 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002846 * Fill PCI IDE PRD (scatter-gather) table with segments
2847 * associated with the current disk command.
2848 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 * LOCKING:
Jeff Garzik780a87f2005-05-30 15:41:05 -04002850 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 *
2852 */
2853static void ata_fill_sg(struct ata_queued_cmd *qc)
2854{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002856 struct scatterlist *sg;
2857 unsigned int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858
Tejun Heoa46314742006-02-11 19:11:13 +09002859 WARN_ON(qc->__sg == NULL);
Jeff Garzikf1318832006-02-20 16:55:56 -05002860 WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861
2862 idx = 0;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002863 ata_for_each_sg(sg, qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864 u32 addr, offset;
2865 u32 sg_len, len;
2866
2867 /* determine if physical DMA addr spans 64K boundary.
2868 * Note h/w doesn't support 64-bit, so we unconditionally
2869 * truncate dma_addr_t to u32.
2870 */
2871 addr = (u32) sg_dma_address(sg);
2872 sg_len = sg_dma_len(sg);
2873
2874 while (sg_len) {
2875 offset = addr & 0xffff;
2876 len = sg_len;
2877 if ((offset + sg_len) > 0x10000)
2878 len = 0x10000 - offset;
2879
2880 ap->prd[idx].addr = cpu_to_le32(addr);
2881 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
2882 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
2883
2884 idx++;
2885 sg_len -= len;
2886 addr += len;
2887 }
2888 }
2889
2890 if (idx)
2891 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2892}
2893/**
2894 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
2895 * @qc: Metadata associated with taskfile to check
2896 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002897 * Allow low-level driver to filter ATA PACKET commands, returning
2898 * a status indicating whether or not it is OK to use DMA for the
2899 * supplied PACKET command.
2900 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002902 * spin_lock_irqsave(host_set lock)
2903 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904 * RETURNS: 0 when ATAPI DMA can be used
2905 * nonzero otherwise
2906 */
2907int ata_check_atapi_dma(struct ata_queued_cmd *qc)
2908{
2909 struct ata_port *ap = qc->ap;
2910 int rc = 0; /* Assume ATAPI DMA is OK by default */
2911
2912 if (ap->ops->check_atapi_dma)
2913 rc = ap->ops->check_atapi_dma(qc);
2914
2915 return rc;
2916}
2917/**
2918 * ata_qc_prep - Prepare taskfile for submission
2919 * @qc: Metadata associated with taskfile to be prepared
2920 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002921 * Prepare ATA taskfile for submission.
2922 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 * LOCKING:
2924 * spin_lock_irqsave(host_set lock)
2925 */
2926void ata_qc_prep(struct ata_queued_cmd *qc)
2927{
2928 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2929 return;
2930
2931 ata_fill_sg(qc);
2932}
2933
Brian Kinge46834c2006-03-17 17:04:03 -06002934void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
2935
Jeff Garzik0cba6322005-05-30 19:49:12 -04002936/**
2937 * ata_sg_init_one - Associate command with memory buffer
2938 * @qc: Command to be associated
2939 * @buf: Memory buffer
2940 * @buflen: Length of memory buffer, in bytes.
2941 *
2942 * Initialize the data-related elements of queued_cmd @qc
2943 * to point to a single memory buffer, @buf of byte length @buflen.
2944 *
2945 * LOCKING:
2946 * spin_lock_irqsave(host_set lock)
2947 */
2948
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
2950{
2951 struct scatterlist *sg;
2952
2953 qc->flags |= ATA_QCFLAG_SINGLE;
2954
2955 memset(&qc->sgent, 0, sizeof(qc->sgent));
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002956 qc->__sg = &qc->sgent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957 qc->n_elem = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002958 qc->orig_n_elem = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959 qc->buf_virt = buf;
2960
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002961 sg = qc->__sg;
Jeff Garzikf0612bb2005-10-30 01:58:18 -05002962 sg_init_one(sg, buf, buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963}
2964
Jeff Garzik0cba6322005-05-30 19:49:12 -04002965/**
2966 * ata_sg_init - Associate command with scatter-gather table.
2967 * @qc: Command to be associated
2968 * @sg: Scatter-gather table.
2969 * @n_elem: Number of elements in s/g table.
2970 *
2971 * Initialize the data-related elements of queued_cmd @qc
2972 * to point to a scatter-gather table @sg, containing @n_elem
2973 * elements.
2974 *
2975 * LOCKING:
2976 * spin_lock_irqsave(host_set lock)
2977 */
2978
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
2980 unsigned int n_elem)
2981{
2982 qc->flags |= ATA_QCFLAG_SG;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002983 qc->__sg = sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 qc->n_elem = n_elem;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002985 qc->orig_n_elem = n_elem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986}
2987
2988/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04002989 * ata_sg_setup_one - DMA-map the memory buffer associated with a command.
2990 * @qc: Command with memory buffer to be mapped.
2991 *
2992 * DMA-map the memory buffer associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 *
2994 * LOCKING:
2995 * spin_lock_irqsave(host_set lock)
2996 *
2997 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002998 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999 */
3000
3001static int ata_sg_setup_one(struct ata_queued_cmd *qc)
3002{
3003 struct ata_port *ap = qc->ap;
3004 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003005 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006 dma_addr_t dma_address;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003007 int trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003009 /* we must lengthen transfers to end on a 32-bit boundary */
3010 qc->pad_len = sg->length & 3;
3011 if (qc->pad_len) {
3012 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3013 struct scatterlist *psg = &qc->pad_sgent;
3014
Tejun Heoa46314742006-02-11 19:11:13 +09003015 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003016
3017 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3018
3019 if (qc->tf.flags & ATA_TFLAG_WRITE)
3020 memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
3021 qc->pad_len);
3022
3023 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3024 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3025 /* trim sg */
3026 sg->length -= qc->pad_len;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003027 if (sg->length == 0)
3028 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003029
3030 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
3031 sg->length, qc->pad_len);
3032 }
3033
Tejun Heo2e242fa2006-02-20 23:48:38 +09003034 if (trim_sg) {
3035 qc->n_elem--;
Jeff Garzike1410f22005-11-14 14:06:26 -05003036 goto skip_map;
3037 }
3038
Brian King2f1f6102006-03-23 17:30:15 -06003039 dma_address = dma_map_single(ap->dev, qc->buf_virt,
Albert Lee32529e02005-05-26 03:49:42 -04003040 sg->length, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003041 if (dma_mapping_error(dma_address)) {
3042 /* restore sg */
3043 sg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003045 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046
3047 sg_dma_address(sg) = dma_address;
Albert Lee32529e02005-05-26 03:49:42 -04003048 sg_dma_len(sg) = sg->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049
Tejun Heo2e242fa2006-02-20 23:48:38 +09003050skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
3052 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3053
3054 return 0;
3055}
3056
3057/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003058 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
3059 * @qc: Command with scatter-gather table to be mapped.
3060 *
3061 * DMA-map the scatter-gather table associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062 *
3063 * LOCKING:
3064 * spin_lock_irqsave(host_set lock)
3065 *
3066 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003067 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003068 *
3069 */
3070
3071static int ata_sg_setup(struct ata_queued_cmd *qc)
3072{
3073 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003074 struct scatterlist *sg = qc->__sg;
3075 struct scatterlist *lsg = &sg[qc->n_elem - 1];
Jeff Garzike1410f22005-11-14 14:06:26 -05003076 int n_elem, pre_n_elem, dir, trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077
3078 VPRINTK("ENTER, ata%u\n", ap->id);
Tejun Heoa46314742006-02-11 19:11:13 +09003079 WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003081 /* we must lengthen transfers to end on a 32-bit boundary */
3082 qc->pad_len = lsg->length & 3;
3083 if (qc->pad_len) {
3084 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3085 struct scatterlist *psg = &qc->pad_sgent;
3086 unsigned int offset;
3087
Tejun Heoa46314742006-02-11 19:11:13 +09003088 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003089
3090 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3091
3092 /*
3093 * psg->page/offset are used to copy to-be-written
3094 * data in this function or read data in ata_sg_clean.
3095 */
3096 offset = lsg->offset + lsg->length - qc->pad_len;
3097 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
3098 psg->offset = offset_in_page(offset);
3099
3100 if (qc->tf.flags & ATA_TFLAG_WRITE) {
3101 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3102 memcpy(pad_buf, addr + psg->offset, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05003103 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003104 }
3105
3106 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3107 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3108 /* trim last sg */
3109 lsg->length -= qc->pad_len;
Jeff Garzike1410f22005-11-14 14:06:26 -05003110 if (lsg->length == 0)
3111 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003112
3113 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
3114 qc->n_elem - 1, lsg->length, qc->pad_len);
3115 }
3116
Jeff Garzike1410f22005-11-14 14:06:26 -05003117 pre_n_elem = qc->n_elem;
3118 if (trim_sg && pre_n_elem)
3119 pre_n_elem--;
3120
3121 if (!pre_n_elem) {
3122 n_elem = 0;
3123 goto skip_map;
3124 }
3125
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126 dir = qc->dma_dir;
Brian King2f1f6102006-03-23 17:30:15 -06003127 n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003128 if (n_elem < 1) {
3129 /* restore last sg */
3130 lsg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003132 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003133
3134 DPRINTK("%d sg elements mapped\n", n_elem);
3135
Jeff Garzike1410f22005-11-14 14:06:26 -05003136skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 qc->n_elem = n_elem;
3138
3139 return 0;
3140}
3141
3142/**
Tejun Heo40e8c822005-08-22 17:12:45 +09003143 * ata_poll_qc_complete - turn irq back on and finish qc
3144 * @qc: Command to complete
Randy Dunlap8e8b77d2005-11-01 21:29:27 -08003145 * @err_mask: ATA status register content
Tejun Heo40e8c822005-08-22 17:12:45 +09003146 *
3147 * LOCKING:
3148 * None. (grabs host lock)
3149 */
3150
Albert Leea22e2eb2005-12-05 15:38:02 +08003151void ata_poll_qc_complete(struct ata_queued_cmd *qc)
Tejun Heo40e8c822005-08-22 17:12:45 +09003152{
3153 struct ata_port *ap = qc->ap;
Jeff Garzikb8f61532005-08-25 22:01:20 -04003154 unsigned long flags;
Tejun Heo40e8c822005-08-22 17:12:45 +09003155
Jeff Garzikb8f61532005-08-25 22:01:20 -04003156 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo40e8c822005-08-22 17:12:45 +09003157 ap->flags &= ~ATA_FLAG_NOINTR;
3158 ata_irq_on(ap);
Albert Leea22e2eb2005-12-05 15:38:02 +08003159 ata_qc_complete(qc);
Jeff Garzikb8f61532005-08-25 22:01:20 -04003160 spin_unlock_irqrestore(&ap->host_set->lock, flags);
Tejun Heo40e8c822005-08-22 17:12:45 +09003161}
3162
3163/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003164 * ata_pio_poll - poll using PIO, depending on current state
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003165 * @ap: the target ata_port
Linus Torvalds1da177e2005-04-16 15:20:36 -07003166 *
3167 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003168 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 *
3170 * RETURNS:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003171 * timeout value to use
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 */
3173
3174static unsigned long ata_pio_poll(struct ata_port *ap)
3175{
Albert Leec14b8332005-12-05 15:36:08 +08003176 struct ata_queued_cmd *qc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177 u8 status;
Albert Lee14be71f2005-09-27 17:36:35 +08003178 unsigned int poll_state = HSM_ST_UNKNOWN;
3179 unsigned int reg_state = HSM_ST_UNKNOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180
Albert Leec14b8332005-12-05 15:36:08 +08003181 qc = ata_qc_from_tag(ap, ap->active_tag);
Tejun Heoa46314742006-02-11 19:11:13 +09003182 WARN_ON(qc == NULL);
Albert Leec14b8332005-12-05 15:36:08 +08003183
Albert Lee14be71f2005-09-27 17:36:35 +08003184 switch (ap->hsm_task_state) {
3185 case HSM_ST:
3186 case HSM_ST_POLL:
3187 poll_state = HSM_ST_POLL;
3188 reg_state = HSM_ST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 break;
Albert Lee14be71f2005-09-27 17:36:35 +08003190 case HSM_ST_LAST:
3191 case HSM_ST_LAST_POLL:
3192 poll_state = HSM_ST_LAST_POLL;
3193 reg_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003194 break;
3195 default:
3196 BUG();
3197 break;
3198 }
3199
3200 status = ata_chk_status(ap);
3201 if (status & ATA_BUSY) {
3202 if (time_after(jiffies, ap->pio_task_timeout)) {
Tejun Heo11a56d22006-01-23 13:09:36 +09003203 qc->err_mask |= AC_ERR_TIMEOUT;
Albert Lee7c398332005-11-09 13:03:30 +08003204 ap->hsm_task_state = HSM_ST_TMOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205 return 0;
3206 }
Albert Lee14be71f2005-09-27 17:36:35 +08003207 ap->hsm_task_state = poll_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208 return ATA_SHORT_PAUSE;
3209 }
3210
Albert Lee14be71f2005-09-27 17:36:35 +08003211 ap->hsm_task_state = reg_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212 return 0;
3213}
3214
3215/**
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003216 * ata_pio_complete - check if drive is busy or idle
3217 * @ap: the target ata_port
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218 *
3219 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003220 * None. (executing in kernel thread context)
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003221 *
3222 * RETURNS:
3223 * Non-zero if qc completed, zero otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224 */
3225
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003226static int ata_pio_complete (struct ata_port *ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003227{
3228 struct ata_queued_cmd *qc;
3229 u8 drv_stat;
3230
3231 /*
Alan Cox31433ea2005-08-26 15:56:47 +01003232 * This is purely heuristic. This is a fast path. Sometimes when
3233 * we enter, BSY will be cleared in a chk-status or two. If not,
3234 * the drive is probably seeking or something. Snooze for a couple
3235 * msecs, then chk-status again. If still busy, fall back to
Albert Lee14be71f2005-09-27 17:36:35 +08003236 * HSM_ST_POLL state.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 */
Albert Leefe79e682005-12-06 11:34:59 +08003238 drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
3239 if (drv_stat & ATA_BUSY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240 msleep(2);
Albert Leefe79e682005-12-06 11:34:59 +08003241 drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
3242 if (drv_stat & ATA_BUSY) {
Albert Lee14be71f2005-09-27 17:36:35 +08003243 ap->hsm_task_state = HSM_ST_LAST_POLL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003245 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246 }
3247 }
3248
Albert Leec14b8332005-12-05 15:36:08 +08003249 qc = ata_qc_from_tag(ap, ap->active_tag);
Tejun Heoa46314742006-02-11 19:11:13 +09003250 WARN_ON(qc == NULL);
Albert Leec14b8332005-12-05 15:36:08 +08003251
Linus Torvalds1da177e2005-04-16 15:20:36 -07003252 drv_stat = ata_wait_idle(ap);
3253 if (!ata_ok(drv_stat)) {
Albert Lee1c848982005-12-05 15:40:15 +08003254 qc->err_mask |= __ac_err_mask(drv_stat);
Albert Lee14be71f2005-09-27 17:36:35 +08003255 ap->hsm_task_state = HSM_ST_ERR;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003256 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257 }
3258
Albert Lee14be71f2005-09-27 17:36:35 +08003259 ap->hsm_task_state = HSM_ST_IDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260
Tejun Heoa46314742006-02-11 19:11:13 +09003261 WARN_ON(qc->err_mask);
Albert Leea22e2eb2005-12-05 15:38:02 +08003262 ata_poll_qc_complete(qc);
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003263
3264 /* another command may start at this point */
3265
3266 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003267}
3268
Edward Falk0baab862005-06-02 18:17:13 -04003269
3270/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003271 * swap_buf_le16 - swap halves of 16-bit words in place
Edward Falk0baab862005-06-02 18:17:13 -04003272 * @buf: Buffer to swap
3273 * @buf_words: Number of 16-bit words in buffer.
3274 *
3275 * Swap halves of 16-bit words if needed to convert from
3276 * little-endian byte order to native cpu byte order, or
3277 * vice-versa.
3278 *
3279 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003280 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04003281 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003282void swap_buf_le16(u16 *buf, unsigned int buf_words)
3283{
3284#ifdef __BIG_ENDIAN
3285 unsigned int i;
3286
3287 for (i = 0; i < buf_words; i++)
3288 buf[i] = le16_to_cpu(buf[i]);
3289#endif /* __BIG_ENDIAN */
3290}
3291
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003292/**
3293 * ata_mmio_data_xfer - Transfer data by MMIO
3294 * @ap: port to read/write
3295 * @buf: data buffer
3296 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003297 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003298 *
3299 * Transfer data from/to the device data register by MMIO.
3300 *
3301 * LOCKING:
3302 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003303 */
3304
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
3306 unsigned int buflen, int write_data)
3307{
3308 unsigned int i;
3309 unsigned int words = buflen >> 1;
3310 u16 *buf16 = (u16 *) buf;
3311 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
3312
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003313 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 if (write_data) {
3315 for (i = 0; i < words; i++)
3316 writew(le16_to_cpu(buf16[i]), mmio);
3317 } else {
3318 for (i = 0; i < words; i++)
3319 buf16[i] = cpu_to_le16(readw(mmio));
3320 }
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003321
3322 /* Transfer trailing 1 byte, if any. */
3323 if (unlikely(buflen & 0x01)) {
3324 u16 align_buf[1] = { 0 };
3325 unsigned char *trailing_buf = buf + buflen - 1;
3326
3327 if (write_data) {
3328 memcpy(align_buf, trailing_buf, 1);
3329 writew(le16_to_cpu(align_buf[0]), mmio);
3330 } else {
3331 align_buf[0] = cpu_to_le16(readw(mmio));
3332 memcpy(trailing_buf, align_buf, 1);
3333 }
3334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335}
3336
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003337/**
3338 * ata_pio_data_xfer - Transfer data by PIO
3339 * @ap: port to read/write
3340 * @buf: data buffer
3341 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003342 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003343 *
3344 * Transfer data from/to the device data register by PIO.
3345 *
3346 * LOCKING:
3347 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003348 */
3349
Linus Torvalds1da177e2005-04-16 15:20:36 -07003350static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
3351 unsigned int buflen, int write_data)
3352{
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003353 unsigned int words = buflen >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003354
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003355 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356 if (write_data)
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003357 outsw(ap->ioaddr.data_addr, buf, words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003358 else
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003359 insw(ap->ioaddr.data_addr, buf, words);
3360
3361 /* Transfer trailing 1 byte, if any. */
3362 if (unlikely(buflen & 0x01)) {
3363 u16 align_buf[1] = { 0 };
3364 unsigned char *trailing_buf = buf + buflen - 1;
3365
3366 if (write_data) {
3367 memcpy(align_buf, trailing_buf, 1);
3368 outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
3369 } else {
3370 align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
3371 memcpy(trailing_buf, align_buf, 1);
3372 }
3373 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374}
3375
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003376/**
3377 * ata_data_xfer - Transfer data from/to the data register.
3378 * @ap: port to read/write
3379 * @buf: data buffer
3380 * @buflen: buffer length
3381 * @do_write: read/write
3382 *
3383 * Transfer data from/to the device data register.
3384 *
3385 * LOCKING:
3386 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003387 */
3388
Linus Torvalds1da177e2005-04-16 15:20:36 -07003389static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
3390 unsigned int buflen, int do_write)
3391{
Alan Coxa1bd9e62006-01-17 20:53:50 +00003392 /* Make the crap hardware pay the costs not the good stuff */
3393 if (unlikely(ap->flags & ATA_FLAG_IRQ_MASK)) {
3394 unsigned long flags;
3395 local_irq_save(flags);
3396 if (ap->flags & ATA_FLAG_MMIO)
3397 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3398 else
3399 ata_pio_data_xfer(ap, buf, buflen, do_write);
3400 local_irq_restore(flags);
3401 } else {
3402 if (ap->flags & ATA_FLAG_MMIO)
3403 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3404 else
3405 ata_pio_data_xfer(ap, buf, buflen, do_write);
3406 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407}
3408
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003409/**
3410 * ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
3411 * @qc: Command on going
3412 *
3413 * Transfer ATA_SECT_SIZE of data from/to the ATA device.
3414 *
3415 * LOCKING:
3416 * Inherited from caller.
3417 */
3418
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419static void ata_pio_sector(struct ata_queued_cmd *qc)
3420{
3421 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003422 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423 struct ata_port *ap = qc->ap;
3424 struct page *page;
3425 unsigned int offset;
3426 unsigned char *buf;
3427
3428 if (qc->cursect == (qc->nsect - 1))
Albert Lee14be71f2005-09-27 17:36:35 +08003429 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003430
3431 page = sg[qc->cursg].page;
3432 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
3433
3434 /* get the current page and offset */
3435 page = nth_page(page, (offset >> PAGE_SHIFT));
3436 offset %= PAGE_SIZE;
3437
3438 buf = kmap(page) + offset;
3439
3440 qc->cursect++;
3441 qc->cursg_ofs++;
3442
Albert Lee32529e02005-05-26 03:49:42 -04003443 if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444 qc->cursg++;
3445 qc->cursg_ofs = 0;
3446 }
3447
3448 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3449
3450 /* do the actual data transfer */
3451 do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3452 ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
3453
3454 kunmap(page);
3455}
3456
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003457/**
3458 * __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3459 * @qc: Command on going
3460 * @bytes: number of bytes
3461 *
3462 * Transfer Transfer data from/to the ATAPI device.
3463 *
3464 * LOCKING:
3465 * Inherited from caller.
3466 *
3467 */
3468
Linus Torvalds1da177e2005-04-16 15:20:36 -07003469static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3470{
3471 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003472 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003473 struct ata_port *ap = qc->ap;
3474 struct page *page;
3475 unsigned char *buf;
3476 unsigned int offset, count;
3477
Albert Lee563a6e12005-08-12 14:17:50 +08003478 if (qc->curbytes + bytes >= qc->nbytes)
Albert Lee14be71f2005-09-27 17:36:35 +08003479 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480
3481next_sg:
Albert Lee563a6e12005-08-12 14:17:50 +08003482 if (unlikely(qc->cursg >= qc->n_elem)) {
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003483 /*
Albert Lee563a6e12005-08-12 14:17:50 +08003484 * The end of qc->sg is reached and the device expects
3485 * more data to transfer. In order not to overrun qc->sg
3486 * and fulfill length specified in the byte count register,
3487 * - for read case, discard trailing data from the device
3488 * - for write case, padding zero data to the device
3489 */
3490 u16 pad_buf[1] = { 0 };
3491 unsigned int words = bytes >> 1;
3492 unsigned int i;
3493
3494 if (words) /* warning if bytes > 1 */
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003495 printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
Albert Lee563a6e12005-08-12 14:17:50 +08003496 ap->id, bytes);
3497
3498 for (i = 0; i < words; i++)
3499 ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
3500
Albert Lee14be71f2005-09-27 17:36:35 +08003501 ap->hsm_task_state = HSM_ST_LAST;
Albert Lee563a6e12005-08-12 14:17:50 +08003502 return;
3503 }
3504
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003505 sg = &qc->__sg[qc->cursg];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507 page = sg->page;
3508 offset = sg->offset + qc->cursg_ofs;
3509
3510 /* get the current page and offset */
3511 page = nth_page(page, (offset >> PAGE_SHIFT));
3512 offset %= PAGE_SIZE;
3513
Albert Lee6952df02005-06-06 15:56:03 +08003514 /* don't overrun current sg */
Albert Lee32529e02005-05-26 03:49:42 -04003515 count = min(sg->length - qc->cursg_ofs, bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516
3517 /* don't cross page boundaries */
3518 count = min(count, (unsigned int)PAGE_SIZE - offset);
3519
3520 buf = kmap(page) + offset;
3521
3522 bytes -= count;
3523 qc->curbytes += count;
3524 qc->cursg_ofs += count;
3525
Albert Lee32529e02005-05-26 03:49:42 -04003526 if (qc->cursg_ofs == sg->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 qc->cursg++;
3528 qc->cursg_ofs = 0;
3529 }
3530
3531 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3532
3533 /* do the actual data transfer */
3534 ata_data_xfer(ap, buf, count, do_write);
3535
3536 kunmap(page);
3537
Albert Lee563a6e12005-08-12 14:17:50 +08003538 if (bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003539 goto next_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003540}
3541
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003542/**
3543 * atapi_pio_bytes - Transfer data from/to the ATAPI device.
3544 * @qc: Command on going
3545 *
3546 * Transfer Transfer data from/to the ATAPI device.
3547 *
3548 * LOCKING:
3549 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003550 */
3551
Linus Torvalds1da177e2005-04-16 15:20:36 -07003552static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3553{
3554 struct ata_port *ap = qc->ap;
3555 struct ata_device *dev = qc->dev;
3556 unsigned int ireason, bc_lo, bc_hi, bytes;
3557 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3558
3559 ap->ops->tf_read(ap, &qc->tf);
3560 ireason = qc->tf.nsect;
3561 bc_lo = qc->tf.lbam;
3562 bc_hi = qc->tf.lbah;
3563 bytes = (bc_hi << 8) | bc_lo;
3564
3565 /* shall be cleared to zero, indicating xfer of data */
3566 if (ireason & (1 << 0))
3567 goto err_out;
3568
3569 /* make sure transfer direction matches expected */
3570 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3571 if (do_write != i_write)
3572 goto err_out;
3573
3574 __atapi_pio_bytes(qc, bytes);
3575
3576 return;
3577
3578err_out:
3579 printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
3580 ap->id, dev->devno);
Tejun Heo11a56d22006-01-23 13:09:36 +09003581 qc->err_mask |= AC_ERR_HSM;
Albert Lee14be71f2005-09-27 17:36:35 +08003582 ap->hsm_task_state = HSM_ST_ERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003583}
3584
3585/**
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003586 * ata_pio_block - start PIO on a block
3587 * @ap: the target ata_port
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588 *
3589 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003590 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591 */
3592
3593static void ata_pio_block(struct ata_port *ap)
3594{
3595 struct ata_queued_cmd *qc;
3596 u8 status;
3597
3598 /*
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003599 * This is purely heuristic. This is a fast path.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600 * Sometimes when we enter, BSY will be cleared in
3601 * a chk-status or two. If not, the drive is probably seeking
3602 * or something. Snooze for a couple msecs, then
3603 * chk-status again. If still busy, fall back to
Albert Lee14be71f2005-09-27 17:36:35 +08003604 * HSM_ST_POLL state.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003605 */
3606 status = ata_busy_wait(ap, ATA_BUSY, 5);
3607 if (status & ATA_BUSY) {
3608 msleep(2);
3609 status = ata_busy_wait(ap, ATA_BUSY, 10);
3610 if (status & ATA_BUSY) {
Albert Lee14be71f2005-09-27 17:36:35 +08003611 ap->hsm_task_state = HSM_ST_POLL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003612 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
3613 return;
3614 }
3615 }
3616
3617 qc = ata_qc_from_tag(ap, ap->active_tag);
Tejun Heoa46314742006-02-11 19:11:13 +09003618 WARN_ON(qc == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619
Albert Leefe79e682005-12-06 11:34:59 +08003620 /* check error */
3621 if (status & (ATA_ERR | ATA_DF)) {
3622 qc->err_mask |= AC_ERR_DEV;
3623 ap->hsm_task_state = HSM_ST_ERR;
3624 return;
3625 }
3626
3627 /* transfer data if any */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628 if (is_atapi_taskfile(&qc->tf)) {
Albert Leefe79e682005-12-06 11:34:59 +08003629 /* DRQ=0 means no more data to transfer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003630 if ((status & ATA_DRQ) == 0) {
Albert Lee14be71f2005-09-27 17:36:35 +08003631 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003632 return;
3633 }
3634
3635 atapi_pio_bytes(qc);
3636 } else {
3637 /* handle BSY=0, DRQ=0 as error */
3638 if ((status & ATA_DRQ) == 0) {
Tejun Heo11a56d22006-01-23 13:09:36 +09003639 qc->err_mask |= AC_ERR_HSM;
Albert Lee14be71f2005-09-27 17:36:35 +08003640 ap->hsm_task_state = HSM_ST_ERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641 return;
3642 }
3643
3644 ata_pio_sector(qc);
3645 }
Albert Leebb31a8f2006-05-22 11:43:46 +08003646
3647 ata_altstatus(ap); /* flush */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003648}
3649
3650static void ata_pio_error(struct ata_port *ap)
3651{
3652 struct ata_queued_cmd *qc;
Jeff Garzika7dac442005-10-30 04:44:42 -05003653
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654 qc = ata_qc_from_tag(ap, ap->active_tag);
Tejun Heoa46314742006-02-11 19:11:13 +09003655 WARN_ON(qc == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003656
Albert Lee0565c262006-02-13 18:55:25 +08003657 if (qc->tf.command != ATA_CMD_PACKET)
3658 printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
3659
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05003660 /* make sure qc->err_mask is available to
Albert Lee1c848982005-12-05 15:40:15 +08003661 * know what's wrong and recover
3662 */
Tejun Heoa46314742006-02-11 19:11:13 +09003663 WARN_ON(qc->err_mask == 0);
Albert Lee1c848982005-12-05 15:40:15 +08003664
Albert Lee14be71f2005-09-27 17:36:35 +08003665 ap->hsm_task_state = HSM_ST_IDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666
Albert Leea22e2eb2005-12-05 15:38:02 +08003667 ata_poll_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668}
3669
3670static void ata_pio_task(void *_data)
3671{
3672 struct ata_port *ap = _data;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003673 unsigned long timeout;
3674 int qc_completed;
3675
3676fsm_start:
3677 timeout = 0;
3678 qc_completed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003679
Albert Lee14be71f2005-09-27 17:36:35 +08003680 switch (ap->hsm_task_state) {
3681 case HSM_ST_IDLE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003682 return;
3683
Albert Lee14be71f2005-09-27 17:36:35 +08003684 case HSM_ST:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003685 ata_pio_block(ap);
3686 break;
3687
Albert Lee14be71f2005-09-27 17:36:35 +08003688 case HSM_ST_LAST:
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003689 qc_completed = ata_pio_complete(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003690 break;
3691
Albert Lee14be71f2005-09-27 17:36:35 +08003692 case HSM_ST_POLL:
3693 case HSM_ST_LAST_POLL:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003694 timeout = ata_pio_poll(ap);
3695 break;
3696
Albert Lee14be71f2005-09-27 17:36:35 +08003697 case HSM_ST_TMOUT:
3698 case HSM_ST_ERR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003699 ata_pio_error(ap);
3700 return;
3701 }
3702
3703 if (timeout)
Tejun Heo8061f5f2006-03-05 15:29:09 +09003704 ata_port_queue_task(ap, ata_pio_task, ap, timeout);
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003705 else if (!qc_completed)
3706 goto fsm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003707}
3708
Linus Torvalds1da177e2005-04-16 15:20:36 -07003709/**
Tejun Heo8061f5f2006-03-05 15:29:09 +09003710 * atapi_packet_task - Write CDB bytes to hardware
3711 * @_data: Port to which ATAPI device is attached.
3712 *
3713 * When device has indicated its readiness to accept
3714 * a CDB, this function is called. Send the CDB.
3715 * If DMA is to be performed, exit immediately.
3716 * Otherwise, we are in polling mode, so poll
3717 * status under operation succeeds or fails.
3718 *
3719 * LOCKING:
3720 * Kernel thread context (may sleep)
3721 */
3722
3723static void atapi_packet_task(void *_data)
3724{
3725 struct ata_port *ap = _data;
3726 struct ata_queued_cmd *qc;
3727 u8 status;
3728
3729 qc = ata_qc_from_tag(ap, ap->active_tag);
3730 WARN_ON(qc == NULL);
3731 WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
3732
3733 /* sleep-wait for BSY to clear */
3734 DPRINTK("busy wait\n");
3735 if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB)) {
3736 qc->err_mask |= AC_ERR_TIMEOUT;
3737 goto err_out;
3738 }
3739
3740 /* make sure DRQ is set */
3741 status = ata_chk_status(ap);
3742 if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ) {
3743 qc->err_mask |= AC_ERR_HSM;
3744 goto err_out;
3745 }
3746
3747 /* send SCSI cdb */
3748 DPRINTK("send cdb\n");
3749 WARN_ON(qc->dev->cdb_len < 12);
3750
3751 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA ||
3752 qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3753 unsigned long flags;
3754
3755 /* Once we're done issuing command and kicking bmdma,
3756 * irq handler takes over. To not lose irq, we need
3757 * to clear NOINTR flag before sending cdb, but
3758 * interrupt handler shouldn't be invoked before we're
3759 * finished. Hence, the following locking.
3760 */
3761 spin_lock_irqsave(&ap->host_set->lock, flags);
3762 ap->flags &= ~ATA_FLAG_NOINTR;
3763 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
Albert Leebb31a8f2006-05-22 11:43:46 +08003764 ata_altstatus(ap); /* flush */
3765
Tejun Heo8061f5f2006-03-05 15:29:09 +09003766 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
3767 ap->ops->bmdma_start(qc); /* initiate bmdma */
3768 spin_unlock_irqrestore(&ap->host_set->lock, flags);
3769 } else {
3770 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
Albert Leebb31a8f2006-05-22 11:43:46 +08003771 ata_altstatus(ap); /* flush */
Tejun Heo8061f5f2006-03-05 15:29:09 +09003772
3773 /* PIO commands are handled by polling */
3774 ap->hsm_task_state = HSM_ST;
3775 ata_port_queue_task(ap, ata_pio_task, ap, 0);
3776 }
3777
3778 return;
3779
3780err_out:
3781 ata_poll_qc_complete(qc);
3782}
3783
3784/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003785 * ata_qc_timeout - Handle timeout of queued command
3786 * @qc: Command that timed out
3787 *
3788 * Some part of the kernel (currently, only the SCSI layer)
3789 * has noticed that the active command on port @ap has not
3790 * completed after a specified length of time. Handle this
3791 * condition by disabling DMA (if necessary) and completing
3792 * transactions, with error if necessary.
3793 *
3794 * This also handles the case of the "lost interrupt", where
3795 * for some reason (possibly hardware bug, possibly driver bug)
3796 * an interrupt was not delivered to the driver, even though the
3797 * transaction completed successfully.
3798 *
3799 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003800 * Inherited from SCSI layer (none, can sleep)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003801 */
3802
3803static void ata_qc_timeout(struct ata_queued_cmd *qc)
3804{
3805 struct ata_port *ap = qc->ap;
Jeff Garzikb8f61532005-08-25 22:01:20 -04003806 struct ata_host_set *host_set = ap->host_set;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807 u8 host_stat = 0, drv_stat;
Jeff Garzikb8f61532005-08-25 22:01:20 -04003808 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003809
3810 DPRINTK("ENTER\n");
3811
Tejun Heoc18d06f2006-02-02 00:56:10 +09003812 ap->hsm_task_state = HSM_ST_IDLE;
3813
Jeff Garzikb8f61532005-08-25 22:01:20 -04003814 spin_lock_irqsave(&host_set->lock, flags);
3815
Linus Torvalds1da177e2005-04-16 15:20:36 -07003816 switch (qc->tf.protocol) {
3817
3818 case ATA_PROT_DMA:
3819 case ATA_PROT_ATAPI_DMA:
3820 host_stat = ap->ops->bmdma_status(ap);
3821
3822 /* before we do anything else, clear DMA-Start bit */
Alan Coxb73fc892005-08-26 16:03:19 +01003823 ap->ops->bmdma_stop(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003824
3825 /* fall through */
3826
3827 default:
3828 ata_altstatus(ap);
3829 drv_stat = ata_chk_status(ap);
3830
3831 /* ack bmdma irq events */
3832 ap->ops->irq_clear(ap);
3833
3834 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
3835 ap->id, qc->tf.command, drv_stat, host_stat);
3836
3837 /* complete taskfile transaction */
Albert Leea22e2eb2005-12-05 15:38:02 +08003838 qc->err_mask |= ac_err_mask(drv_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839 break;
3840 }
Jeff Garzikb8f61532005-08-25 22:01:20 -04003841
3842 spin_unlock_irqrestore(&host_set->lock, flags);
3843
Tejun Heoa72ec4c2006-01-23 13:09:37 +09003844 ata_eh_qc_complete(qc);
3845
Linus Torvalds1da177e2005-04-16 15:20:36 -07003846 DPRINTK("EXIT\n");
3847}
3848
3849/**
3850 * ata_eng_timeout - Handle timeout of queued command
3851 * @ap: Port on which timed-out command is active
3852 *
3853 * Some part of the kernel (currently, only the SCSI layer)
3854 * has noticed that the active command on port @ap has not
3855 * completed after a specified length of time. Handle this
3856 * condition by disabling DMA (if necessary) and completing
3857 * transactions, with error if necessary.
3858 *
3859 * This also handles the case of the "lost interrupt", where
3860 * for some reason (possibly hardware bug, possibly driver bug)
3861 * an interrupt was not delivered to the driver, even though the
3862 * transaction completed successfully.
3863 *
3864 * LOCKING:
3865 * Inherited from SCSI layer (none, can sleep)
3866 */
3867
3868void ata_eng_timeout(struct ata_port *ap)
3869{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003870 DPRINTK("ENTER\n");
3871
Tejun Heof6379022006-02-10 15:10:48 +09003872 ata_qc_timeout(ata_qc_from_tag(ap, ap->active_tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003873
Linus Torvalds1da177e2005-04-16 15:20:36 -07003874 DPRINTK("EXIT\n");
3875}
3876
3877/**
3878 * ata_qc_new - Request an available ATA command, for queueing
3879 * @ap: Port associated with device @dev
3880 * @dev: Device from whom we request an available command structure
3881 *
3882 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003883 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003884 */
3885
3886static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
3887{
3888 struct ata_queued_cmd *qc = NULL;
3889 unsigned int i;
3890
3891 for (i = 0; i < ATA_MAX_QUEUE; i++)
3892 if (!test_and_set_bit(i, &ap->qactive)) {
3893 qc = ata_qc_from_tag(ap, i);
3894 break;
3895 }
3896
3897 if (qc)
3898 qc->tag = i;
3899
3900 return qc;
3901}
3902
3903/**
3904 * ata_qc_new_init - Request an available ATA command, and initialize it
3905 * @ap: Port associated with device @dev
3906 * @dev: Device from whom we request an available command structure
3907 *
3908 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003909 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003910 */
3911
3912struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
3913 struct ata_device *dev)
3914{
3915 struct ata_queued_cmd *qc;
3916
3917 qc = ata_qc_new(ap);
3918 if (qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003919 qc->scsicmd = NULL;
3920 qc->ap = ap;
3921 qc->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003922
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05003923 ata_qc_reinit(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924 }
3925
3926 return qc;
3927}
3928
Linus Torvalds1da177e2005-04-16 15:20:36 -07003929/**
3930 * ata_qc_free - free unused ata_queued_cmd
3931 * @qc: Command to complete
3932 *
3933 * Designed to free unused ata_queued_cmd object
3934 * in case something prevents using it.
3935 *
3936 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003937 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003938 */
3939void ata_qc_free(struct ata_queued_cmd *qc)
3940{
Tejun Heo4ba946e2006-01-23 13:09:36 +09003941 struct ata_port *ap = qc->ap;
3942 unsigned int tag;
3943
Tejun Heoa46314742006-02-11 19:11:13 +09003944 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945
Tejun Heo4ba946e2006-01-23 13:09:36 +09003946 qc->flags = 0;
3947 tag = qc->tag;
3948 if (likely(ata_tag_valid(tag))) {
3949 if (tag == ap->active_tag)
3950 ap->active_tag = ATA_TAG_POISON;
3951 qc->tag = ATA_TAG_POISON;
3952 clear_bit(tag, &ap->qactive);
3953 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003954}
3955
Tejun Heo76014422006-02-11 15:13:49 +09003956void __ata_qc_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003957{
Tejun Heoa46314742006-02-11 19:11:13 +09003958 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
3959 WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003960
3961 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
3962 ata_sg_clean(qc);
3963
Albert Lee3f3791d2005-08-16 14:25:38 +08003964 /* atapi: mark qc as inactive to prevent the interrupt handler
3965 * from completing the command twice later, before the error handler
3966 * is called. (when rc != 0 and atapi request sense is needed)
3967 */
3968 qc->flags &= ~ATA_QCFLAG_ACTIVE;
3969
Linus Torvalds1da177e2005-04-16 15:20:36 -07003970 /* call completion callback */
Tejun Heo77853bf2006-01-23 13:09:36 +09003971 qc->complete_fn(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972}
3973
3974static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
3975{
3976 struct ata_port *ap = qc->ap;
3977
3978 switch (qc->tf.protocol) {
3979 case ATA_PROT_DMA:
3980 case ATA_PROT_ATAPI_DMA:
3981 return 1;
3982
3983 case ATA_PROT_ATAPI:
3984 case ATA_PROT_PIO:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003985 if (ap->flags & ATA_FLAG_PIO_DMA)
3986 return 1;
3987
3988 /* fall through */
3989
3990 default:
3991 return 0;
3992 }
3993
3994 /* never reached */
3995}
3996
3997/**
3998 * ata_qc_issue - issue taskfile to device
3999 * @qc: command to issue to device
4000 *
4001 * Prepare an ATA command to submission to device.
4002 * This includes mapping the data into a DMA-able
4003 * area, filling in the S/G table, and finally
4004 * writing the taskfile to hardware, starting the command.
4005 *
4006 * LOCKING:
4007 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004008 */
Tejun Heo8e0e6942006-03-31 20:41:11 +09004009void ata_qc_issue(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004010{
4011 struct ata_port *ap = qc->ap;
4012
Tejun Heoe4a70e72006-03-31 20:36:47 +09004013 qc->ap->active_tag = qc->tag;
4014 qc->flags |= ATA_QCFLAG_ACTIVE;
4015
Linus Torvalds1da177e2005-04-16 15:20:36 -07004016 if (ata_should_dma_map(qc)) {
4017 if (qc->flags & ATA_QCFLAG_SG) {
4018 if (ata_sg_setup(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004019 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004020 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
4021 if (ata_sg_setup_one(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004022 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004023 }
4024 } else {
4025 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4026 }
4027
4028 ap->ops->qc_prep(qc);
4029
Tejun Heo8e0e6942006-03-31 20:41:11 +09004030 qc->err_mask |= ap->ops->qc_issue(qc);
4031 if (unlikely(qc->err_mask))
4032 goto err;
4033 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004034
Tejun Heo8e436af2006-01-23 13:09:36 +09004035sg_err:
4036 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Tejun Heo8e0e6942006-03-31 20:41:11 +09004037 qc->err_mask |= AC_ERR_SYSTEM;
4038err:
4039 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004040}
4041
4042/**
4043 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
4044 * @qc: command to issue to device
4045 *
4046 * Using various libata functions and hooks, this function
4047 * starts an ATA command. ATA commands are grouped into
4048 * classes called "protocols", and issuing each type of protocol
4049 * is slightly different.
4050 *
Edward Falk0baab862005-06-02 18:17:13 -04004051 * May be used as the qc_issue() entry in ata_port_operations.
4052 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004053 * LOCKING:
4054 * spin_lock_irqsave(host_set lock)
4055 *
4056 * RETURNS:
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004057 * Zero on success, AC_ERR_* mask on failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004058 */
4059
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004060unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004061{
4062 struct ata_port *ap = qc->ap;
4063
4064 ata_dev_select(ap, qc->dev->devno, 1, 0);
4065
4066 switch (qc->tf.protocol) {
4067 case ATA_PROT_NODATA:
Jeff Garzike5338252005-10-30 21:37:17 -05004068 ata_tf_to_host(ap, &qc->tf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004069 break;
4070
4071 case ATA_PROT_DMA:
4072 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4073 ap->ops->bmdma_setup(qc); /* set up bmdma */
4074 ap->ops->bmdma_start(qc); /* initiate bmdma */
4075 break;
4076
4077 case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
4078 ata_qc_set_polling(qc);
Jeff Garzike5338252005-10-30 21:37:17 -05004079 ata_tf_to_host(ap, &qc->tf);
Albert Lee14be71f2005-09-27 17:36:35 +08004080 ap->hsm_task_state = HSM_ST;
Tejun Heo8061f5f2006-03-05 15:29:09 +09004081 ata_port_queue_task(ap, ata_pio_task, ap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004082 break;
4083
4084 case ATA_PROT_ATAPI:
4085 ata_qc_set_polling(qc);
Jeff Garzike5338252005-10-30 21:37:17 -05004086 ata_tf_to_host(ap, &qc->tf);
Tejun Heo8061f5f2006-03-05 15:29:09 +09004087 ata_port_queue_task(ap, atapi_packet_task, ap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004088 break;
4089
4090 case ATA_PROT_ATAPI_NODATA:
Tejun Heoc1389502005-08-22 14:59:24 +09004091 ap->flags |= ATA_FLAG_NOINTR;
Jeff Garzike5338252005-10-30 21:37:17 -05004092 ata_tf_to_host(ap, &qc->tf);
Tejun Heo8061f5f2006-03-05 15:29:09 +09004093 ata_port_queue_task(ap, atapi_packet_task, ap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094 break;
4095
4096 case ATA_PROT_ATAPI_DMA:
Tejun Heoc1389502005-08-22 14:59:24 +09004097 ap->flags |= ATA_FLAG_NOINTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004098 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4099 ap->ops->bmdma_setup(qc); /* set up bmdma */
Tejun Heo8061f5f2006-03-05 15:29:09 +09004100 ata_port_queue_task(ap, atapi_packet_task, ap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004101 break;
4102
4103 default:
4104 WARN_ON(1);
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004105 return AC_ERR_SYSTEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004106 }
4107
4108 return 0;
4109}
4110
4111/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004112 * ata_host_intr - Handle host interrupt for given (port, task)
4113 * @ap: Port on which interrupt arrived (possibly...)
4114 * @qc: Taskfile currently active in engine
4115 *
4116 * Handle host interrupt for given queued command. Currently,
4117 * only DMA interrupts are handled. All other commands are
4118 * handled via polling with interrupts disabled (nIEN bit).
4119 *
4120 * LOCKING:
4121 * spin_lock_irqsave(host_set lock)
4122 *
4123 * RETURNS:
4124 * One if interrupt was handled, zero if not (shared irq).
4125 */
4126
4127inline unsigned int ata_host_intr (struct ata_port *ap,
4128 struct ata_queued_cmd *qc)
4129{
4130 u8 status, host_stat;
4131
4132 switch (qc->tf.protocol) {
4133
4134 case ATA_PROT_DMA:
4135 case ATA_PROT_ATAPI_DMA:
4136 case ATA_PROT_ATAPI:
4137 /* check status of DMA engine */
4138 host_stat = ap->ops->bmdma_status(ap);
4139 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
4140
4141 /* if it's not our irq... */
4142 if (!(host_stat & ATA_DMA_INTR))
4143 goto idle_irq;
4144
4145 /* before we do anything else, clear DMA-Start bit */
Alan Coxb73fc892005-08-26 16:03:19 +01004146 ap->ops->bmdma_stop(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004147
4148 /* fall through */
4149
4150 case ATA_PROT_ATAPI_NODATA:
4151 case ATA_PROT_NODATA:
4152 /* check altstatus */
4153 status = ata_altstatus(ap);
4154 if (status & ATA_BUSY)
4155 goto idle_irq;
4156
4157 /* check main status, clearing INTRQ */
4158 status = ata_chk_status(ap);
4159 if (unlikely(status & ATA_BUSY))
4160 goto idle_irq;
4161 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
4162 ap->id, qc->tf.protocol, status);
4163
4164 /* ack bmdma irq events */
4165 ap->ops->irq_clear(ap);
4166
4167 /* complete taskfile transaction */
Albert Leea22e2eb2005-12-05 15:38:02 +08004168 qc->err_mask |= ac_err_mask(status);
4169 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004170 break;
4171
4172 default:
4173 goto idle_irq;
4174 }
4175
4176 return 1; /* irq handled */
4177
4178idle_irq:
4179 ap->stats.idle_irq++;
4180
4181#ifdef ATA_IRQ_TRAP
4182 if ((ap->stats.idle_irq % 1000) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004183 ata_irq_ack(ap, 0); /* debug trap */
4184 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
Alan Cox23cfce82006-03-21 16:06:53 +00004185 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004186 }
4187#endif
4188 return 0; /* irq not handled */
4189}
4190
4191/**
4192 * ata_interrupt - Default ATA host interrupt handler
Jeff Garzik0cba6322005-05-30 19:49:12 -04004193 * @irq: irq line (unused)
4194 * @dev_instance: pointer to our ata_host_set information structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004195 * @regs: unused
4196 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004197 * Default interrupt handler for PCI IDE devices. Calls
4198 * ata_host_intr() for each port that is not disabled.
4199 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004200 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004201 * Obtains host_set lock during operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004202 *
4203 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004204 * IRQ_NONE or IRQ_HANDLED.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004205 */
4206
4207irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
4208{
4209 struct ata_host_set *host_set = dev_instance;
4210 unsigned int i;
4211 unsigned int handled = 0;
4212 unsigned long flags;
4213
4214 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
4215 spin_lock_irqsave(&host_set->lock, flags);
4216
4217 for (i = 0; i < host_set->n_ports; i++) {
4218 struct ata_port *ap;
4219
4220 ap = host_set->ports[i];
Tejun Heoc1389502005-08-22 14:59:24 +09004221 if (ap &&
4222 !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004223 struct ata_queued_cmd *qc;
4224
4225 qc = ata_qc_from_tag(ap, ap->active_tag);
Albert Lee21b1ed72005-04-29 17:34:59 +08004226 if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
4227 (qc->flags & ATA_QCFLAG_ACTIVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004228 handled |= ata_host_intr(ap, qc);
4229 }
4230 }
4231
4232 spin_unlock_irqrestore(&host_set->lock, flags);
4233
4234 return IRQ_RETVAL(handled);
4235}
4236
Edward Falk0baab862005-06-02 18:17:13 -04004237
Jens Axboe9b847542006-01-06 09:28:07 +01004238/*
4239 * Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
4240 * without filling any other registers
4241 */
4242static int ata_do_simple_cmd(struct ata_port *ap, struct ata_device *dev,
4243 u8 cmd)
4244{
4245 struct ata_taskfile tf;
4246 int err;
4247
4248 ata_tf_init(ap, &tf, dev->devno);
4249
4250 tf.command = cmd;
4251 tf.flags |= ATA_TFLAG_DEVICE;
4252 tf.protocol = ATA_PROT_NODATA;
4253
4254 err = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
4255 if (err)
4256 printk(KERN_ERR "%s: ata command failed: %d\n",
4257 __FUNCTION__, err);
4258
4259 return err;
4260}
4261
4262static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
4263{
4264 u8 cmd;
4265
4266 if (!ata_try_flush_cache(dev))
4267 return 0;
4268
4269 if (ata_id_has_flush_ext(dev->id))
4270 cmd = ATA_CMD_FLUSH_EXT;
4271 else
4272 cmd = ATA_CMD_FLUSH;
4273
4274 return ata_do_simple_cmd(ap, dev, cmd);
4275}
4276
4277static int ata_standby_drive(struct ata_port *ap, struct ata_device *dev)
4278{
4279 return ata_do_simple_cmd(ap, dev, ATA_CMD_STANDBYNOW1);
4280}
4281
4282static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
4283{
4284 return ata_do_simple_cmd(ap, dev, ATA_CMD_IDLEIMMEDIATE);
4285}
4286
4287/**
4288 * ata_device_resume - wakeup a previously suspended devices
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004289 * @ap: port the device is connected to
4290 * @dev: the device to resume
Jens Axboe9b847542006-01-06 09:28:07 +01004291 *
4292 * Kick the drive back into action, by sending it an idle immediate
4293 * command and making sure its transfer mode matches between drive
4294 * and host.
4295 *
4296 */
4297int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
4298{
4299 if (ap->flags & ATA_FLAG_SUSPENDED) {
Mark Lord0737ac82006-05-28 11:28:00 -04004300 ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 200000);
Jens Axboe9b847542006-01-06 09:28:07 +01004301 ap->flags &= ~ATA_FLAG_SUSPENDED;
4302 ata_set_mode(ap);
4303 }
4304 if (!ata_dev_present(dev))
4305 return 0;
4306 if (dev->class == ATA_DEV_ATA)
4307 ata_start_drive(ap, dev);
4308
4309 return 0;
4310}
4311
4312/**
4313 * ata_device_suspend - prepare a device for suspend
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004314 * @ap: port the device is connected to
4315 * @dev: the device to suspend
Randy Dunlape2a7f772006-05-18 10:50:18 -07004316 * @state: target power management state
Jens Axboe9b847542006-01-06 09:28:07 +01004317 *
4318 * Flush the cache on the drive, if appropriate, then issue a
4319 * standbynow command.
Jens Axboe9b847542006-01-06 09:28:07 +01004320 */
Nigel Cunningham082776e2006-03-23 23:22:16 +10004321int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
Jens Axboe9b847542006-01-06 09:28:07 +01004322{
4323 if (!ata_dev_present(dev))
4324 return 0;
4325 if (dev->class == ATA_DEV_ATA)
4326 ata_flush_cache(ap, dev);
4327
Nigel Cunningham082776e2006-03-23 23:22:16 +10004328 if (state.event != PM_EVENT_FREEZE)
4329 ata_standby_drive(ap, dev);
Jens Axboe9b847542006-01-06 09:28:07 +01004330 ap->flags |= ATA_FLAG_SUSPENDED;
4331 return 0;
4332}
4333
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004334/**
4335 * ata_port_start - Set port up for dma.
4336 * @ap: Port to initialize
4337 *
4338 * Called just after data structures for each port are
4339 * initialized. Allocates space for PRD table.
4340 *
4341 * May be used as the port_start() entry in ata_port_operations.
4342 *
4343 * LOCKING:
4344 * Inherited from caller.
4345 */
4346
Linus Torvalds1da177e2005-04-16 15:20:36 -07004347int ata_port_start (struct ata_port *ap)
4348{
Brian King2f1f6102006-03-23 17:30:15 -06004349 struct device *dev = ap->dev;
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004350 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004351
4352 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
4353 if (!ap->prd)
4354 return -ENOMEM;
4355
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004356 rc = ata_pad_alloc(ap, dev);
4357 if (rc) {
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004358 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004359 return rc;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004360 }
4361
Linus Torvalds1da177e2005-04-16 15:20:36 -07004362 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
4363
4364 return 0;
4365}
4366
Edward Falk0baab862005-06-02 18:17:13 -04004367
4368/**
4369 * ata_port_stop - Undo ata_port_start()
4370 * @ap: Port to shut down
4371 *
4372 * Frees the PRD table.
4373 *
4374 * May be used as the port_stop() entry in ata_port_operations.
4375 *
4376 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004377 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04004378 */
4379
Linus Torvalds1da177e2005-04-16 15:20:36 -07004380void ata_port_stop (struct ata_port *ap)
4381{
Brian King2f1f6102006-03-23 17:30:15 -06004382 struct device *dev = ap->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004383
4384 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004385 ata_pad_free(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004386}
4387
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04004388void ata_host_stop (struct ata_host_set *host_set)
4389{
4390 if (host_set->mmio_base)
4391 iounmap(host_set->mmio_base);
4392}
4393
4394
Linus Torvalds1da177e2005-04-16 15:20:36 -07004395/**
4396 * ata_host_remove - Unregister SCSI host structure with upper layers
4397 * @ap: Port to unregister
4398 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
4399 *
4400 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004401 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004402 */
4403
4404static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
4405{
4406 struct Scsi_Host *sh = ap->host;
4407
4408 DPRINTK("ENTER\n");
4409
4410 if (do_unregister)
4411 scsi_remove_host(sh);
4412
4413 ap->ops->port_stop(ap);
4414}
4415
4416/**
4417 * ata_host_init - Initialize an ata_port structure
4418 * @ap: Structure to initialize
4419 * @host: associated SCSI mid-layer structure
4420 * @host_set: Collection of hosts to which @ap belongs
4421 * @ent: Probe information provided by low-level driver
4422 * @port_no: Port number associated with this ata_port
4423 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004424 * Initialize a new ata_port structure, and its associated
4425 * scsi_host.
4426 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004427 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004428 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004429 */
4430
4431static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
4432 struct ata_host_set *host_set,
Jeff Garzik057ace52005-10-22 14:27:05 -04004433 const struct ata_probe_ent *ent, unsigned int port_no)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004434{
4435 unsigned int i;
4436
4437 host->max_id = 16;
4438 host->max_lun = 1;
4439 host->max_channel = 1;
4440 host->unique_id = ata_unique_id++;
4441 host->max_cmd_len = 12;
Christoph Hellwig12413192005-06-11 01:05:01 +02004442
Linus Torvalds1da177e2005-04-16 15:20:36 -07004443 ap->flags = ATA_FLAG_PORT_DISABLED;
4444 ap->id = host->unique_id;
4445 ap->host = host;
4446 ap->ctl = ATA_DEVCTL_OBS;
4447 ap->host_set = host_set;
Brian King2f1f6102006-03-23 17:30:15 -06004448 ap->dev = ent->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004449 ap->port_no = port_no;
4450 ap->hard_port_no =
4451 ent->legacy_mode ? ent->hard_port_no : port_no;
4452 ap->pio_mask = ent->pio_mask;
4453 ap->mwdma_mask = ent->mwdma_mask;
4454 ap->udma_mask = ent->udma_mask;
4455 ap->flags |= ent->host_flags;
4456 ap->ops = ent->port_ops;
4457 ap->cbl = ATA_CBL_NONE;
4458 ap->active_tag = ATA_TAG_POISON;
4459 ap->last_ctl = 0xFF;
4460
Tejun Heo86e45b62006-03-05 15:29:09 +09004461 INIT_WORK(&ap->port_task, NULL, NULL);
Tejun Heoa72ec4c2006-01-23 13:09:37 +09004462 INIT_LIST_HEAD(&ap->eh_done_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004463
Tejun Heoacf356b2006-03-24 14:07:50 +09004464 for (i = 0; i < ATA_MAX_DEVICES; i++) {
4465 struct ata_device *dev = &ap->device[i];
4466 dev->devno = i;
4467 dev->pio_mask = UINT_MAX;
4468 dev->mwdma_mask = UINT_MAX;
4469 dev->udma_mask = UINT_MAX;
4470 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004471
4472#ifdef ATA_IRQ_TRAP
4473 ap->stats.unhandled_irq = 1;
4474 ap->stats.idle_irq = 1;
4475#endif
4476
4477 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
4478}
4479
4480/**
4481 * ata_host_add - Attach low-level ATA driver to system
4482 * @ent: Information provided by low-level driver
4483 * @host_set: Collections of ports to which we add
4484 * @port_no: Port number associated with this host
4485 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004486 * Attach low-level ATA driver to system.
4487 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004488 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004489 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004490 *
4491 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004492 * New ata_port on success, for NULL on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004493 */
4494
Jeff Garzik057ace52005-10-22 14:27:05 -04004495static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004496 struct ata_host_set *host_set,
4497 unsigned int port_no)
4498{
4499 struct Scsi_Host *host;
4500 struct ata_port *ap;
4501 int rc;
4502
4503 DPRINTK("ENTER\n");
Tejun Heoaec5c3c2006-03-25 01:33:34 +09004504
4505 if (!ent->port_ops->probe_reset &&
4506 !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
4507 printk(KERN_ERR "ata%u: no reset mechanism available\n",
4508 port_no);
4509 return NULL;
4510 }
4511
Linus Torvalds1da177e2005-04-16 15:20:36 -07004512 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
4513 if (!host)
4514 return NULL;
4515
Tejun Heo30afc842006-03-18 18:40:14 +09004516 host->transportt = &ata_scsi_transport_template;
4517
Linus Torvalds1da177e2005-04-16 15:20:36 -07004518 ap = (struct ata_port *) &host->hostdata[0];
4519
4520 ata_host_init(ap, host, host_set, ent, port_no);
4521
4522 rc = ap->ops->port_start(ap);
4523 if (rc)
4524 goto err_out;
4525
4526 return ap;
4527
4528err_out:
4529 scsi_host_put(host);
4530 return NULL;
4531}
4532
4533/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04004534 * ata_device_add - Register hardware device with ATA and SCSI layers
4535 * @ent: Probe information describing hardware device to be registered
4536 *
4537 * This function processes the information provided in the probe
4538 * information struct @ent, allocates the necessary ATA and SCSI
4539 * host information structures, initializes them, and registers
4540 * everything with requisite kernel subsystems.
4541 *
4542 * This function requests irqs, probes the ATA bus, and probes
4543 * the SCSI bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004544 *
4545 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004546 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004547 *
4548 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004549 * Number of ports registered. Zero on error (no ports registered).
Linus Torvalds1da177e2005-04-16 15:20:36 -07004550 */
4551
Jeff Garzik057ace52005-10-22 14:27:05 -04004552int ata_device_add(const struct ata_probe_ent *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004553{
4554 unsigned int count = 0, i;
4555 struct device *dev = ent->dev;
4556 struct ata_host_set *host_set;
4557
4558 DPRINTK("ENTER\n");
4559 /* alloc a container for our list of ATA ports (buses) */
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004560 host_set = kzalloc(sizeof(struct ata_host_set) +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004561 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
4562 if (!host_set)
4563 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004564 spin_lock_init(&host_set->lock);
4565
4566 host_set->dev = dev;
4567 host_set->n_ports = ent->n_ports;
4568 host_set->irq = ent->irq;
4569 host_set->mmio_base = ent->mmio_base;
4570 host_set->private_data = ent->private_data;
4571 host_set->ops = ent->port_ops;
Alan Cox5444a6f2006-03-27 18:58:20 +01004572 host_set->flags = ent->host_set_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004573
4574 /* register each port bound to this device */
4575 for (i = 0; i < ent->n_ports; i++) {
4576 struct ata_port *ap;
4577 unsigned long xfer_mode_mask;
4578
4579 ap = ata_host_add(ent, host_set, i);
4580 if (!ap)
4581 goto err_out;
4582
4583 host_set->ports[i] = ap;
4584 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
4585 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
4586 (ap->pio_mask << ATA_SHIFT_PIO);
4587
4588 /* print per-port info to dmesg */
4589 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
4590 "bmdma 0x%lX irq %lu\n",
4591 ap->id,
4592 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
4593 ata_mode_string(xfer_mode_mask),
4594 ap->ioaddr.cmd_addr,
4595 ap->ioaddr.ctl_addr,
4596 ap->ioaddr.bmdma_addr,
4597 ent->irq);
4598
4599 ata_chk_status(ap);
4600 host_set->ops->irq_clear(ap);
4601 count++;
4602 }
4603
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004604 if (!count)
4605 goto err_free_ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004606
4607 /* obtain irq, that is shared between channels */
4608 if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
4609 DRV_NAME, host_set))
4610 goto err_out;
4611
4612 /* perform each probe synchronously */
4613 DPRINTK("probe begin\n");
4614 for (i = 0; i < count; i++) {
4615 struct ata_port *ap;
4616 int rc;
4617
4618 ap = host_set->ports[i];
4619
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004620 DPRINTK("ata%u: bus probe begin\n", ap->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004621 rc = ata_bus_probe(ap);
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004622 DPRINTK("ata%u: bus probe end\n", ap->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004623
4624 if (rc) {
4625 /* FIXME: do something useful here?
4626 * Current libata behavior will
4627 * tear down everything when
4628 * the module is removed
4629 * or the h/w is unplugged.
4630 */
4631 }
4632
4633 rc = scsi_add_host(ap->host, dev);
4634 if (rc) {
4635 printk(KERN_ERR "ata%u: scsi_add_host failed\n",
4636 ap->id);
4637 /* FIXME: do something useful here */
4638 /* FIXME: handle unconditional calls to
4639 * scsi_scan_host and ata_host_remove, below,
4640 * at the very least
4641 */
4642 }
4643 }
4644
4645 /* probes are done, now scan each port's disk(s) */
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004646 DPRINTK("host probe begin\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004647 for (i = 0; i < count; i++) {
4648 struct ata_port *ap = host_set->ports[i];
4649
Jeff Garzik644dd0c2005-10-03 15:55:19 -04004650 ata_scsi_scan_host(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004651 }
4652
4653 dev_set_drvdata(dev, host_set);
4654
4655 VPRINTK("EXIT, returning %u\n", ent->n_ports);
4656 return ent->n_ports; /* success */
4657
4658err_out:
4659 for (i = 0; i < count; i++) {
4660 ata_host_remove(host_set->ports[i], 1);
4661 scsi_host_put(host_set->ports[i]->host);
4662 }
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004663err_free_ret:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004664 kfree(host_set);
4665 VPRINTK("EXIT, returning 0\n");
4666 return 0;
4667}
4668
4669/**
Alan Cox17b14452005-09-15 15:44:00 +01004670 * ata_host_set_remove - PCI layer callback for device removal
4671 * @host_set: ATA host set that was removed
4672 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05004673 * Unregister all objects associated with this host set. Free those
Alan Cox17b14452005-09-15 15:44:00 +01004674 * objects.
4675 *
4676 * LOCKING:
4677 * Inherited from calling layer (may sleep).
4678 */
4679
Alan Cox17b14452005-09-15 15:44:00 +01004680void ata_host_set_remove(struct ata_host_set *host_set)
4681{
4682 struct ata_port *ap;
4683 unsigned int i;
4684
4685 for (i = 0; i < host_set->n_ports; i++) {
4686 ap = host_set->ports[i];
4687 scsi_remove_host(ap->host);
4688 }
4689
4690 free_irq(host_set->irq, host_set);
4691
4692 for (i = 0; i < host_set->n_ports; i++) {
4693 ap = host_set->ports[i];
4694
4695 ata_scsi_release(ap->host);
4696
4697 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
4698 struct ata_ioports *ioaddr = &ap->ioaddr;
4699
4700 if (ioaddr->cmd_addr == 0x1f0)
4701 release_region(0x1f0, 8);
4702 else if (ioaddr->cmd_addr == 0x170)
4703 release_region(0x170, 8);
4704 }
4705
4706 scsi_host_put(ap->host);
4707 }
4708
4709 if (host_set->ops->host_stop)
4710 host_set->ops->host_stop(host_set);
4711
4712 kfree(host_set);
4713}
4714
4715/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004716 * ata_scsi_release - SCSI layer callback hook for host unload
4717 * @host: libata host to be unloaded
4718 *
4719 * Performs all duties necessary to shut down a libata port...
4720 * Kill port kthread, disable port, and release resources.
4721 *
4722 * LOCKING:
4723 * Inherited from SCSI layer.
4724 *
4725 * RETURNS:
4726 * One.
4727 */
4728
4729int ata_scsi_release(struct Scsi_Host *host)
4730{
4731 struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
Tejun Heod9572b12006-03-01 16:09:35 +09004732 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004733
4734 DPRINTK("ENTER\n");
4735
4736 ap->ops->port_disable(ap);
4737 ata_host_remove(ap, 0);
Tejun Heod9572b12006-03-01 16:09:35 +09004738 for (i = 0; i < ATA_MAX_DEVICES; i++)
4739 kfree(ap->device[i].id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004740
4741 DPRINTK("EXIT\n");
4742 return 1;
4743}
4744
4745/**
4746 * ata_std_ports - initialize ioaddr with standard port offsets.
4747 * @ioaddr: IO address structure to be initialized
Edward Falk0baab862005-06-02 18:17:13 -04004748 *
4749 * Utility function which initializes data_addr, error_addr,
4750 * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
4751 * device_addr, status_addr, and command_addr to standard offsets
4752 * relative to cmd_addr.
4753 *
4754 * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004755 */
Edward Falk0baab862005-06-02 18:17:13 -04004756
Linus Torvalds1da177e2005-04-16 15:20:36 -07004757void ata_std_ports(struct ata_ioports *ioaddr)
4758{
4759 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
4760 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
4761 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
4762 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
4763 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
4764 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
4765 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
4766 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
4767 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
4768 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
4769}
4770
Edward Falk0baab862005-06-02 18:17:13 -04004771
Jeff Garzik374b1872005-08-30 05:42:52 -04004772#ifdef CONFIG_PCI
4773
4774void ata_pci_host_stop (struct ata_host_set *host_set)
4775{
4776 struct pci_dev *pdev = to_pci_dev(host_set->dev);
4777
4778 pci_iounmap(pdev, host_set->mmio_base);
4779}
4780
Edward Falk0baab862005-06-02 18:17:13 -04004781/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004782 * ata_pci_remove_one - PCI layer callback for device removal
4783 * @pdev: PCI device that was removed
4784 *
4785 * PCI layer indicates to libata via this hook that
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004786 * hot-unplug or module unload event has occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004787 * Handle this by unregistering all objects associated
4788 * with this PCI device. Free those objects. Then finally
4789 * release PCI resources and disable device.
4790 *
4791 * LOCKING:
4792 * Inherited from PCI layer (may sleep).
4793 */
4794
4795void ata_pci_remove_one (struct pci_dev *pdev)
4796{
4797 struct device *dev = pci_dev_to_dev(pdev);
4798 struct ata_host_set *host_set = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004799
Alan Cox17b14452005-09-15 15:44:00 +01004800 ata_host_set_remove(host_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004801 pci_release_regions(pdev);
4802 pci_disable_device(pdev);
4803 dev_set_drvdata(dev, NULL);
4804}
4805
4806/* move to PCI subsystem */
Jeff Garzik057ace52005-10-22 14:27:05 -04004807int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004808{
4809 unsigned long tmp = 0;
4810
4811 switch (bits->width) {
4812 case 1: {
4813 u8 tmp8 = 0;
4814 pci_read_config_byte(pdev, bits->reg, &tmp8);
4815 tmp = tmp8;
4816 break;
4817 }
4818 case 2: {
4819 u16 tmp16 = 0;
4820 pci_read_config_word(pdev, bits->reg, &tmp16);
4821 tmp = tmp16;
4822 break;
4823 }
4824 case 4: {
4825 u32 tmp32 = 0;
4826 pci_read_config_dword(pdev, bits->reg, &tmp32);
4827 tmp = tmp32;
4828 break;
4829 }
4830
4831 default:
4832 return -EINVAL;
4833 }
4834
4835 tmp &= bits->mask;
4836
4837 return (tmp == bits->val) ? 1 : 0;
4838}
Jens Axboe9b847542006-01-06 09:28:07 +01004839
4840int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state)
4841{
4842 pci_save_state(pdev);
4843 pci_disable_device(pdev);
4844 pci_set_power_state(pdev, PCI_D3hot);
4845 return 0;
4846}
4847
4848int ata_pci_device_resume(struct pci_dev *pdev)
4849{
4850 pci_set_power_state(pdev, PCI_D0);
4851 pci_restore_state(pdev);
4852 pci_enable_device(pdev);
4853 pci_set_master(pdev);
4854 return 0;
4855}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004856#endif /* CONFIG_PCI */
4857
4858
Linus Torvalds1da177e2005-04-16 15:20:36 -07004859static int __init ata_init(void)
4860{
4861 ata_wq = create_workqueue("ata");
4862 if (!ata_wq)
4863 return -ENOMEM;
4864
4865 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
4866 return 0;
4867}
4868
4869static void __exit ata_exit(void)
4870{
4871 destroy_workqueue(ata_wq);
4872}
4873
4874module_init(ata_init);
4875module_exit(ata_exit);
4876
Jeff Garzik67846b32005-10-05 02:58:32 -04004877static unsigned long ratelimit_time;
4878static spinlock_t ata_ratelimit_lock = SPIN_LOCK_UNLOCKED;
4879
4880int ata_ratelimit(void)
4881{
4882 int rc;
4883 unsigned long flags;
4884
4885 spin_lock_irqsave(&ata_ratelimit_lock, flags);
4886
4887 if (time_after(jiffies, ratelimit_time)) {
4888 rc = 1;
4889 ratelimit_time = jiffies + (HZ/5);
4890 } else
4891 rc = 0;
4892
4893 spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
4894
4895 return rc;
4896}
4897
Linus Torvalds1da177e2005-04-16 15:20:36 -07004898/*
4899 * libata is essentially a library of internal helper functions for
4900 * low-level ATA host controller drivers. As such, the API/ABI is
4901 * likely to change as new drivers are added and updated.
4902 * Do not depend on ABI/API stability.
4903 */
4904
4905EXPORT_SYMBOL_GPL(ata_std_bios_param);
4906EXPORT_SYMBOL_GPL(ata_std_ports);
4907EXPORT_SYMBOL_GPL(ata_device_add);
Alan Cox17b14452005-09-15 15:44:00 +01004908EXPORT_SYMBOL_GPL(ata_host_set_remove);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004909EXPORT_SYMBOL_GPL(ata_sg_init);
4910EXPORT_SYMBOL_GPL(ata_sg_init_one);
Tejun Heo76014422006-02-11 15:13:49 +09004911EXPORT_SYMBOL_GPL(__ata_qc_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004912EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
4913EXPORT_SYMBOL_GPL(ata_eng_timeout);
4914EXPORT_SYMBOL_GPL(ata_tf_load);
4915EXPORT_SYMBOL_GPL(ata_tf_read);
4916EXPORT_SYMBOL_GPL(ata_noop_dev_select);
4917EXPORT_SYMBOL_GPL(ata_std_dev_select);
4918EXPORT_SYMBOL_GPL(ata_tf_to_fis);
4919EXPORT_SYMBOL_GPL(ata_tf_from_fis);
4920EXPORT_SYMBOL_GPL(ata_check_status);
4921EXPORT_SYMBOL_GPL(ata_altstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004922EXPORT_SYMBOL_GPL(ata_exec_command);
4923EXPORT_SYMBOL_GPL(ata_port_start);
4924EXPORT_SYMBOL_GPL(ata_port_stop);
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04004925EXPORT_SYMBOL_GPL(ata_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004926EXPORT_SYMBOL_GPL(ata_interrupt);
4927EXPORT_SYMBOL_GPL(ata_qc_prep);
Brian Kinge46834c2006-03-17 17:04:03 -06004928EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004929EXPORT_SYMBOL_GPL(ata_bmdma_setup);
4930EXPORT_SYMBOL_GPL(ata_bmdma_start);
4931EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
4932EXPORT_SYMBOL_GPL(ata_bmdma_status);
4933EXPORT_SYMBOL_GPL(ata_bmdma_stop);
4934EXPORT_SYMBOL_GPL(ata_port_probe);
4935EXPORT_SYMBOL_GPL(sata_phy_reset);
4936EXPORT_SYMBOL_GPL(__sata_phy_reset);
4937EXPORT_SYMBOL_GPL(ata_bus_reset);
Tejun Heo8a19ac82006-02-02 18:20:00 +09004938EXPORT_SYMBOL_GPL(ata_std_probeinit);
Tejun Heoc2bd5802006-01-24 17:05:22 +09004939EXPORT_SYMBOL_GPL(ata_std_softreset);
4940EXPORT_SYMBOL_GPL(sata_std_hardreset);
4941EXPORT_SYMBOL_GPL(ata_std_postreset);
4942EXPORT_SYMBOL_GPL(ata_std_probe_reset);
Tejun Heoa62c0fc2006-01-24 17:05:22 +09004943EXPORT_SYMBOL_GPL(ata_drive_probe_reset);
Tejun Heo623a3122006-03-05 17:55:58 +09004944EXPORT_SYMBOL_GPL(ata_dev_revalidate);
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05004945EXPORT_SYMBOL_GPL(ata_dev_classify);
4946EXPORT_SYMBOL_GPL(ata_dev_pair);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004947EXPORT_SYMBOL_GPL(ata_port_disable);
Jeff Garzik67846b32005-10-05 02:58:32 -04004948EXPORT_SYMBOL_GPL(ata_ratelimit);
Tejun Heo6f8b9952006-01-24 17:05:21 +09004949EXPORT_SYMBOL_GPL(ata_busy_sleep);
Tejun Heo86e45b62006-03-05 15:29:09 +09004950EXPORT_SYMBOL_GPL(ata_port_queue_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004951EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
4952EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004953EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
4954EXPORT_SYMBOL_GPL(ata_scsi_release);
4955EXPORT_SYMBOL_GPL(ata_host_intr);
Tejun Heo6a62a042006-02-13 10:02:46 +09004956EXPORT_SYMBOL_GPL(ata_id_string);
4957EXPORT_SYMBOL_GPL(ata_id_c_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004958EXPORT_SYMBOL_GPL(ata_scsi_simulate);
Tejun Heoa72ec4c2006-01-23 13:09:37 +09004959EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
4960EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004961
Alan Cox1bc4ccf2006-01-09 17:18:14 +00004962EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
Alan Cox452503f2005-10-21 19:01:32 -04004963EXPORT_SYMBOL_GPL(ata_timing_compute);
4964EXPORT_SYMBOL_GPL(ata_timing_merge);
4965
Linus Torvalds1da177e2005-04-16 15:20:36 -07004966#ifdef CONFIG_PCI
4967EXPORT_SYMBOL_GPL(pci_test_config_bits);
Jeff Garzik374b1872005-08-30 05:42:52 -04004968EXPORT_SYMBOL_GPL(ata_pci_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004969EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
4970EXPORT_SYMBOL_GPL(ata_pci_init_one);
4971EXPORT_SYMBOL_GPL(ata_pci_remove_one);
Jens Axboe9b847542006-01-06 09:28:07 +01004972EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
4973EXPORT_SYMBOL_GPL(ata_pci_device_resume);
Alan Cox67951ad2006-03-22 15:55:54 +00004974EXPORT_SYMBOL_GPL(ata_pci_default_filter);
4975EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004976#endif /* CONFIG_PCI */
Jens Axboe9b847542006-01-06 09:28:07 +01004977
4978EXPORT_SYMBOL_GPL(ata_device_suspend);
4979EXPORT_SYMBOL_GPL(ata_device_resume);
4980EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
4981EXPORT_SYMBOL_GPL(ata_scsi_device_resume);