blob: 014855e5a43ac514bff8b06c79fee9191b06d536 [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 Heod7bb4cc2006-05-31 18:27:46 +090064/* debounce timing parameters in msecs { interval, duration, timeout } */
65const unsigned long sata_deb_timing_boot[] = { 5, 100, 2000 };
66const unsigned long sata_deb_timing_eh[] = { 25, 500, 2000 };
67const unsigned long sata_deb_timing_before_fsrst[] = { 100, 2000, 5000 };
68
Tejun Heo3373efd2006-05-15 20:57:53 +090069static unsigned int ata_dev_init_params(struct ata_device *dev,
70 u16 heads, u16 sectors);
71static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
72static void ata_dev_xfermask(struct ata_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74static unsigned int ata_unique_id = 1;
75static struct workqueue_struct *ata_wq;
76
Tejun Heo453b07a2006-05-31 18:27:42 +090077struct workqueue_struct *ata_aux_wq;
78
Jeff Garzik418dc1f2006-03-11 20:50:08 -050079int atapi_enabled = 1;
Jeff Garzik1623c812005-08-30 03:37:42 -040080module_param(atapi_enabled, int, 0444);
81MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
82
Albert Lee95de7192006-04-04 10:57:18 +080083int atapi_dmadir = 0;
84module_param(atapi_dmadir, int, 0444);
85MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
86
Jeff Garzikc3c013a2006-02-27 22:31:19 -050087int libata_fua = 0;
88module_param_named(fua, libata_fua, int, 0444);
89MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
90
Linus Torvalds1da177e2005-04-16 15:20:36 -070091MODULE_AUTHOR("Jeff Garzik");
92MODULE_DESCRIPTION("Library module for ATA devices");
93MODULE_LICENSE("GPL");
94MODULE_VERSION(DRV_VERSION);
95
Edward Falk0baab862005-06-02 18:17:13 -040096
97/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
99 * @tf: Taskfile to convert
100 * @fis: Buffer into which data will output
101 * @pmp: Port multiplier port
102 *
103 * Converts a standard ATA taskfile to a Serial ATA
104 * FIS structure (Register - Host to Device).
105 *
106 * LOCKING:
107 * Inherited from caller.
108 */
109
Jeff Garzik057ace52005-10-22 14:27:05 -0400110void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
112 fis[0] = 0x27; /* Register - Host to Device FIS */
113 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
114 bit 7 indicates Command FIS */
115 fis[2] = tf->command;
116 fis[3] = tf->feature;
117
118 fis[4] = tf->lbal;
119 fis[5] = tf->lbam;
120 fis[6] = tf->lbah;
121 fis[7] = tf->device;
122
123 fis[8] = tf->hob_lbal;
124 fis[9] = tf->hob_lbam;
125 fis[10] = tf->hob_lbah;
126 fis[11] = tf->hob_feature;
127
128 fis[12] = tf->nsect;
129 fis[13] = tf->hob_nsect;
130 fis[14] = 0;
131 fis[15] = tf->ctl;
132
133 fis[16] = 0;
134 fis[17] = 0;
135 fis[18] = 0;
136 fis[19] = 0;
137}
138
139/**
140 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
141 * @fis: Buffer from which data will be input
142 * @tf: Taskfile to output
143 *
Mark Lorde12a1be2005-11-12 18:55:45 -0500144 * Converts a serial ATA FIS structure to a standard ATA taskfile.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 *
146 * LOCKING:
147 * Inherited from caller.
148 */
149
Jeff Garzik057ace52005-10-22 14:27:05 -0400150void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
152 tf->command = fis[2]; /* status */
153 tf->feature = fis[3]; /* error */
154
155 tf->lbal = fis[4];
156 tf->lbam = fis[5];
157 tf->lbah = fis[6];
158 tf->device = fis[7];
159
160 tf->hob_lbal = fis[8];
161 tf->hob_lbam = fis[9];
162 tf->hob_lbah = fis[10];
163
164 tf->nsect = fis[12];
165 tf->hob_nsect = fis[13];
166}
167
Albert Lee8cbd6df2005-10-12 15:06:27 +0800168static const u8 ata_rw_cmds[] = {
169 /* pio multi */
170 ATA_CMD_READ_MULTI,
171 ATA_CMD_WRITE_MULTI,
172 ATA_CMD_READ_MULTI_EXT,
173 ATA_CMD_WRITE_MULTI_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100174 0,
175 0,
176 0,
177 ATA_CMD_WRITE_MULTI_FUA_EXT,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800178 /* pio */
179 ATA_CMD_PIO_READ,
180 ATA_CMD_PIO_WRITE,
181 ATA_CMD_PIO_READ_EXT,
182 ATA_CMD_PIO_WRITE_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100183 0,
184 0,
185 0,
186 0,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800187 /* dma */
188 ATA_CMD_READ,
189 ATA_CMD_WRITE,
190 ATA_CMD_READ_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100191 ATA_CMD_WRITE_EXT,
192 0,
193 0,
194 0,
195 ATA_CMD_WRITE_FUA_EXT
Albert Lee8cbd6df2005-10-12 15:06:27 +0800196};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198/**
Albert Lee8cbd6df2005-10-12 15:06:27 +0800199 * ata_rwcmd_protocol - set taskfile r/w commands and protocol
200 * @qc: command to examine and configure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500202 * Examine the device configuration and tf->flags to calculate
Albert Lee8cbd6df2005-10-12 15:06:27 +0800203 * the proper read/write commands and protocol to use.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 *
205 * LOCKING:
206 * caller.
207 */
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100208int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
Albert Lee8cbd6df2005-10-12 15:06:27 +0800210 struct ata_taskfile *tf = &qc->tf;
211 struct ata_device *dev = qc->dev;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100212 u8 cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100214 int index, fua, lba48, write;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500215
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100216 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800217 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
218 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Albert Lee8cbd6df2005-10-12 15:06:27 +0800220 if (dev->flags & ATA_DFLAG_PIO) {
221 tf->protocol = ATA_PROT_PIO;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100222 index = dev->multi_count ? 0 : 8;
Alan Cox8d238e02006-01-17 20:50:31 +0000223 } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
224 /* Unable to use DMA due to host limitation */
225 tf->protocol = ATA_PROT_PIO;
Albert Lee0565c262006-02-13 18:55:25 +0800226 index = dev->multi_count ? 0 : 8;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800227 } else {
228 tf->protocol = ATA_PROT_DMA;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100229 index = 16;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800230 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100232 cmd = ata_rw_cmds[index + fua + lba48 + write];
233 if (cmd) {
234 tf->command = cmd;
235 return 0;
236 }
237 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238}
239
Tejun Heocb95d562006-03-06 04:31:56 +0900240/**
241 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
242 * @pio_mask: pio_mask
243 * @mwdma_mask: mwdma_mask
244 * @udma_mask: udma_mask
245 *
246 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
247 * unsigned int xfer_mask.
248 *
249 * LOCKING:
250 * None.
251 *
252 * RETURNS:
253 * Packed xfer_mask.
254 */
255static unsigned int ata_pack_xfermask(unsigned int pio_mask,
256 unsigned int mwdma_mask,
257 unsigned int udma_mask)
258{
259 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
260 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
261 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
262}
263
Tejun Heoc0489e42006-03-24 14:07:49 +0900264/**
265 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
266 * @xfer_mask: xfer_mask to unpack
267 * @pio_mask: resulting pio_mask
268 * @mwdma_mask: resulting mwdma_mask
269 * @udma_mask: resulting udma_mask
270 *
271 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
272 * Any NULL distination masks will be ignored.
273 */
274static void ata_unpack_xfermask(unsigned int xfer_mask,
275 unsigned int *pio_mask,
276 unsigned int *mwdma_mask,
277 unsigned int *udma_mask)
278{
279 if (pio_mask)
280 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
281 if (mwdma_mask)
282 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
283 if (udma_mask)
284 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
285}
286
Tejun Heocb95d562006-03-06 04:31:56 +0900287static const struct ata_xfer_ent {
Tejun Heobe9a50c2006-03-31 22:48:52 +0900288 int shift, bits;
Tejun Heocb95d562006-03-06 04:31:56 +0900289 u8 base;
290} ata_xfer_tbl[] = {
291 { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
292 { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
293 { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
294 { -1, },
295};
296
297/**
298 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
299 * @xfer_mask: xfer_mask of interest
300 *
301 * Return matching XFER_* value for @xfer_mask. Only the highest
302 * bit of @xfer_mask is considered.
303 *
304 * LOCKING:
305 * None.
306 *
307 * RETURNS:
308 * Matching XFER_* value, 0 if no match found.
309 */
310static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
311{
312 int highbit = fls(xfer_mask) - 1;
313 const struct ata_xfer_ent *ent;
314
315 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
316 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
317 return ent->base + highbit - ent->shift;
318 return 0;
319}
320
321/**
322 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
323 * @xfer_mode: XFER_* of interest
324 *
325 * Return matching xfer_mask for @xfer_mode.
326 *
327 * LOCKING:
328 * None.
329 *
330 * RETURNS:
331 * Matching xfer_mask, 0 if no match found.
332 */
333static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
334{
335 const struct ata_xfer_ent *ent;
336
337 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
338 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
339 return 1 << (ent->shift + xfer_mode - ent->base);
340 return 0;
341}
342
343/**
344 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
345 * @xfer_mode: XFER_* of interest
346 *
347 * Return matching xfer_shift for @xfer_mode.
348 *
349 * LOCKING:
350 * None.
351 *
352 * RETURNS:
353 * Matching xfer_shift, -1 if no match found.
354 */
355static int ata_xfer_mode2shift(unsigned int xfer_mode)
356{
357 const struct ata_xfer_ent *ent;
358
359 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
360 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
361 return ent->shift;
362 return -1;
363}
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365/**
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900366 * ata_mode_string - convert xfer_mask to string
367 * @xfer_mask: mask of bits supported; only highest bit counts.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 *
369 * Determine string which represents the highest speed
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900370 * (highest bit in @modemask).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 *
372 * LOCKING:
373 * None.
374 *
375 * RETURNS:
376 * Constant C string representing highest speed listed in
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900377 * @mode_mask, or the constant C string "<n/a>".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 */
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900379static const char *ata_mode_string(unsigned int xfer_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Tejun Heo75f554b2006-03-06 04:31:57 +0900381 static const char * const xfer_mode_str[] = {
382 "PIO0",
383 "PIO1",
384 "PIO2",
385 "PIO3",
386 "PIO4",
387 "MWDMA0",
388 "MWDMA1",
389 "MWDMA2",
390 "UDMA/16",
391 "UDMA/25",
392 "UDMA/33",
393 "UDMA/44",
394 "UDMA/66",
395 "UDMA/100",
396 "UDMA/133",
397 "UDMA7",
398 };
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900399 int highbit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900401 highbit = fls(xfer_mask) - 1;
402 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
403 return xfer_mode_str[highbit];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 return "<n/a>";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405}
406
Tejun Heo4c360c82006-04-01 01:38:17 +0900407static const char *sata_spd_string(unsigned int spd)
408{
409 static const char * const spd_str[] = {
410 "1.5 Gbps",
411 "3.0 Gbps",
412 };
413
414 if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
415 return "<unknown>";
416 return spd_str[spd - 1];
417}
418
Tejun Heo3373efd2006-05-15 20:57:53 +0900419void ata_dev_disable(struct ata_device *dev)
Tejun Heo0b8efb02006-03-24 15:25:31 +0900420{
Tejun Heoe1211e32006-04-01 01:38:18 +0900421 if (ata_dev_enabled(dev)) {
Tejun Heof15a1da2006-05-15 20:57:56 +0900422 ata_dev_printk(dev, KERN_WARNING, "disabled\n");
Tejun Heo0b8efb02006-03-24 15:25:31 +0900423 dev->class++;
424 }
425}
426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427/**
428 * ata_pio_devchk - PATA device presence detection
429 * @ap: ATA channel to examine
430 * @device: Device to examine (starting at zero)
431 *
432 * This technique was originally described in
433 * Hale Landis's ATADRVR (www.ata-atapi.com), and
434 * later found its way into the ATA/ATAPI spec.
435 *
436 * Write a pattern to the ATA shadow registers,
437 * and if a device is present, it will respond by
438 * correctly storing and echoing back the
439 * ATA shadow register contents.
440 *
441 * LOCKING:
442 * caller.
443 */
444
445static unsigned int ata_pio_devchk(struct ata_port *ap,
446 unsigned int device)
447{
448 struct ata_ioports *ioaddr = &ap->ioaddr;
449 u8 nsect, lbal;
450
451 ap->ops->dev_select(ap, device);
452
453 outb(0x55, ioaddr->nsect_addr);
454 outb(0xaa, ioaddr->lbal_addr);
455
456 outb(0xaa, ioaddr->nsect_addr);
457 outb(0x55, ioaddr->lbal_addr);
458
459 outb(0x55, ioaddr->nsect_addr);
460 outb(0xaa, ioaddr->lbal_addr);
461
462 nsect = inb(ioaddr->nsect_addr);
463 lbal = inb(ioaddr->lbal_addr);
464
465 if ((nsect == 0x55) && (lbal == 0xaa))
466 return 1; /* we found a device */
467
468 return 0; /* nothing found */
469}
470
471/**
472 * ata_mmio_devchk - PATA device presence detection
473 * @ap: ATA channel to examine
474 * @device: Device to examine (starting at zero)
475 *
476 * This technique was originally described in
477 * Hale Landis's ATADRVR (www.ata-atapi.com), and
478 * later found its way into the ATA/ATAPI spec.
479 *
480 * Write a pattern to the ATA shadow registers,
481 * and if a device is present, it will respond by
482 * correctly storing and echoing back the
483 * ATA shadow register contents.
484 *
485 * LOCKING:
486 * caller.
487 */
488
489static unsigned int ata_mmio_devchk(struct ata_port *ap,
490 unsigned int device)
491{
492 struct ata_ioports *ioaddr = &ap->ioaddr;
493 u8 nsect, lbal;
494
495 ap->ops->dev_select(ap, device);
496
497 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
498 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
499
500 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
501 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
502
503 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
504 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
505
506 nsect = readb((void __iomem *) ioaddr->nsect_addr);
507 lbal = readb((void __iomem *) ioaddr->lbal_addr);
508
509 if ((nsect == 0x55) && (lbal == 0xaa))
510 return 1; /* we found a device */
511
512 return 0; /* nothing found */
513}
514
515/**
516 * ata_devchk - PATA device presence detection
517 * @ap: ATA channel to examine
518 * @device: Device to examine (starting at zero)
519 *
520 * Dispatch ATA device presence detection, depending
521 * on whether we are using PIO or MMIO to talk to the
522 * ATA shadow registers.
523 *
524 * LOCKING:
525 * caller.
526 */
527
528static unsigned int ata_devchk(struct ata_port *ap,
529 unsigned int device)
530{
531 if (ap->flags & ATA_FLAG_MMIO)
532 return ata_mmio_devchk(ap, device);
533 return ata_pio_devchk(ap, device);
534}
535
536/**
537 * ata_dev_classify - determine device type based on ATA-spec signature
538 * @tf: ATA taskfile register set for device to be identified
539 *
540 * Determine from taskfile register contents whether a device is
541 * ATA or ATAPI, as per "Signature and persistence" section
542 * of ATA/PI spec (volume 1, sect 5.14).
543 *
544 * LOCKING:
545 * None.
546 *
547 * RETURNS:
548 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
549 * the event of failure.
550 */
551
Jeff Garzik057ace52005-10-22 14:27:05 -0400552unsigned int ata_dev_classify(const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553{
554 /* Apple's open source Darwin code hints that some devices only
555 * put a proper signature into the LBA mid/high registers,
556 * So, we only check those. It's sufficient for uniqueness.
557 */
558
559 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
560 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
561 DPRINTK("found ATA device by sig\n");
562 return ATA_DEV_ATA;
563 }
564
565 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
566 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
567 DPRINTK("found ATAPI device by sig\n");
568 return ATA_DEV_ATAPI;
569 }
570
571 DPRINTK("unknown device\n");
572 return ATA_DEV_UNKNOWN;
573}
574
575/**
576 * ata_dev_try_classify - Parse returned ATA device signature
577 * @ap: ATA channel to examine
578 * @device: Device to examine (starting at zero)
Tejun Heob4dc7622006-01-24 17:05:22 +0900579 * @r_err: Value of error register on completion
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 *
581 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
582 * an ATA/ATAPI-defined set of values is placed in the ATA
583 * shadow registers, indicating the results of device detection
584 * and diagnostics.
585 *
586 * Select the ATA device, and read the values from the ATA shadow
587 * registers. Then parse according to the Error register value,
588 * and the spec-defined values examined by ata_dev_classify().
589 *
590 * LOCKING:
591 * caller.
Tejun Heob4dc7622006-01-24 17:05:22 +0900592 *
593 * RETURNS:
594 * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 */
596
Tejun Heob4dc7622006-01-24 17:05:22 +0900597static unsigned int
598ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 struct ata_taskfile tf;
601 unsigned int class;
602 u8 err;
603
604 ap->ops->dev_select(ap, device);
605
606 memset(&tf, 0, sizeof(tf));
607
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 ap->ops->tf_read(ap, &tf);
Jeff Garzik0169e282005-10-29 21:25:10 -0400609 err = tf.feature;
Tejun Heob4dc7622006-01-24 17:05:22 +0900610 if (r_err)
611 *r_err = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
613 /* see if device passed diags */
614 if (err == 1)
615 /* do nothing */ ;
616 else if ((device == 0) && (err == 0x81))
617 /* do nothing */ ;
618 else
Tejun Heob4dc7622006-01-24 17:05:22 +0900619 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Tejun Heob4dc7622006-01-24 17:05:22 +0900621 /* determine if device is ATA or ATAPI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 class = ata_dev_classify(&tf);
Tejun Heob4dc7622006-01-24 17:05:22 +0900623
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 if (class == ATA_DEV_UNKNOWN)
Tejun Heob4dc7622006-01-24 17:05:22 +0900625 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
Tejun Heob4dc7622006-01-24 17:05:22 +0900627 return ATA_DEV_NONE;
628 return class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629}
630
631/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900632 * ata_id_string - Convert IDENTIFY DEVICE page into string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 * @id: IDENTIFY DEVICE results we will examine
634 * @s: string into which data is output
635 * @ofs: offset into identify device page
636 * @len: length of string to return. must be an even number.
637 *
638 * The strings in the IDENTIFY DEVICE page are broken up into
639 * 16-bit chunks. Run through the string, and output each
640 * 8-bit chunk linearly, regardless of platform.
641 *
642 * LOCKING:
643 * caller.
644 */
645
Tejun Heo6a62a042006-02-13 10:02:46 +0900646void ata_id_string(const u16 *id, unsigned char *s,
647 unsigned int ofs, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648{
649 unsigned int c;
650
651 while (len > 0) {
652 c = id[ofs] >> 8;
653 *s = c;
654 s++;
655
656 c = id[ofs] & 0xff;
657 *s = c;
658 s++;
659
660 ofs++;
661 len -= 2;
662 }
663}
664
Tejun Heo0e949ff2006-02-12 22:47:04 +0900665/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900666 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
Tejun Heo0e949ff2006-02-12 22:47:04 +0900667 * @id: IDENTIFY DEVICE results we will examine
668 * @s: string into which data is output
669 * @ofs: offset into identify device page
670 * @len: length of string to return. must be an odd number.
671 *
Tejun Heo6a62a042006-02-13 10:02:46 +0900672 * This function is identical to ata_id_string except that it
Tejun Heo0e949ff2006-02-12 22:47:04 +0900673 * trims trailing spaces and terminates the resulting string with
674 * null. @len must be actual maximum length (even number) + 1.
675 *
676 * LOCKING:
677 * caller.
678 */
Tejun Heo6a62a042006-02-13 10:02:46 +0900679void ata_id_c_string(const u16 *id, unsigned char *s,
680 unsigned int ofs, unsigned int len)
Tejun Heo0e949ff2006-02-12 22:47:04 +0900681{
682 unsigned char *p;
683
684 WARN_ON(!(len & 1));
685
Tejun Heo6a62a042006-02-13 10:02:46 +0900686 ata_id_string(id, s, ofs, len - 1);
Tejun Heo0e949ff2006-02-12 22:47:04 +0900687
688 p = s + strnlen(s, len - 1);
689 while (p > s && p[-1] == ' ')
690 p--;
691 *p = '\0';
692}
Edward Falk0baab862005-06-02 18:17:13 -0400693
Tejun Heo29407402006-02-12 22:47:04 +0900694static u64 ata_id_n_sectors(const u16 *id)
695{
696 if (ata_id_has_lba(id)) {
697 if (ata_id_has_lba48(id))
698 return ata_id_u64(id, 100);
699 else
700 return ata_id_u32(id, 60);
701 } else {
702 if (ata_id_current_chs_valid(id))
703 return ata_id_u32(id, 57);
704 else
705 return id[1] * id[3] * id[6];
706 }
707}
708
Edward Falk0baab862005-06-02 18:17:13 -0400709/**
710 * ata_noop_dev_select - Select device 0/1 on ATA bus
711 * @ap: ATA channel to manipulate
712 * @device: ATA device (numbered from zero) to select
713 *
714 * This function performs no actual function.
715 *
716 * May be used as the dev_select() entry in ata_port_operations.
717 *
718 * LOCKING:
719 * caller.
720 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
722{
723}
724
Edward Falk0baab862005-06-02 18:17:13 -0400725
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726/**
727 * ata_std_dev_select - Select device 0/1 on ATA bus
728 * @ap: ATA channel to manipulate
729 * @device: ATA device (numbered from zero) to select
730 *
731 * Use the method defined in the ATA specification to
732 * make either device 0, or device 1, active on the
Edward Falk0baab862005-06-02 18:17:13 -0400733 * ATA channel. Works with both PIO and MMIO.
734 *
735 * May be used as the dev_select() entry in ata_port_operations.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 *
737 * LOCKING:
738 * caller.
739 */
740
741void ata_std_dev_select (struct ata_port *ap, unsigned int device)
742{
743 u8 tmp;
744
745 if (device == 0)
746 tmp = ATA_DEVICE_OBS;
747 else
748 tmp = ATA_DEVICE_OBS | ATA_DEV1;
749
750 if (ap->flags & ATA_FLAG_MMIO) {
751 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
752 } else {
753 outb(tmp, ap->ioaddr.device_addr);
754 }
755 ata_pause(ap); /* needed; also flushes, for mmio */
756}
757
758/**
759 * ata_dev_select - Select device 0/1 on ATA bus
760 * @ap: ATA channel to manipulate
761 * @device: ATA device (numbered from zero) to select
762 * @wait: non-zero to wait for Status register BSY bit to clear
763 * @can_sleep: non-zero if context allows sleeping
764 *
765 * Use the method defined in the ATA specification to
766 * make either device 0, or device 1, active on the
767 * ATA channel.
768 *
769 * This is a high-level version of ata_std_dev_select(),
770 * which additionally provides the services of inserting
771 * the proper pauses and status polling, where needed.
772 *
773 * LOCKING:
774 * caller.
775 */
776
777void ata_dev_select(struct ata_port *ap, unsigned int device,
778 unsigned int wait, unsigned int can_sleep)
779{
780 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
781 ap->id, device, wait);
782
783 if (wait)
784 ata_wait_idle(ap);
785
786 ap->ops->dev_select(ap, device);
787
788 if (wait) {
789 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
790 msleep(150);
791 ata_wait_idle(ap);
792 }
793}
794
795/**
796 * ata_dump_id - IDENTIFY DEVICE info debugging output
Tejun Heo0bd33002006-02-12 22:47:05 +0900797 * @id: IDENTIFY DEVICE page to dump
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 *
Tejun Heo0bd33002006-02-12 22:47:05 +0900799 * Dump selected 16-bit words from the given IDENTIFY DEVICE
800 * page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 *
802 * LOCKING:
803 * caller.
804 */
805
Tejun Heo0bd33002006-02-12 22:47:05 +0900806static inline void ata_dump_id(const u16 *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807{
808 DPRINTK("49==0x%04x "
809 "53==0x%04x "
810 "63==0x%04x "
811 "64==0x%04x "
812 "75==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900813 id[49],
814 id[53],
815 id[63],
816 id[64],
817 id[75]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 DPRINTK("80==0x%04x "
819 "81==0x%04x "
820 "82==0x%04x "
821 "83==0x%04x "
822 "84==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900823 id[80],
824 id[81],
825 id[82],
826 id[83],
827 id[84]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 DPRINTK("88==0x%04x "
829 "93==0x%04x\n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900830 id[88],
831 id[93]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832}
833
Tejun Heocb95d562006-03-06 04:31:56 +0900834/**
835 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
836 * @id: IDENTIFY data to compute xfer mask from
837 *
838 * Compute the xfermask for this device. This is not as trivial
839 * as it seems if we must consider early devices correctly.
840 *
841 * FIXME: pre IDE drive timing (do we care ?).
842 *
843 * LOCKING:
844 * None.
845 *
846 * RETURNS:
847 * Computed xfermask
848 */
849static unsigned int ata_id_xfermask(const u16 *id)
850{
851 unsigned int pio_mask, mwdma_mask, udma_mask;
852
853 /* Usual case. Word 53 indicates word 64 is valid */
854 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
855 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
856 pio_mask <<= 3;
857 pio_mask |= 0x7;
858 } else {
859 /* If word 64 isn't valid then Word 51 high byte holds
860 * the PIO timing number for the maximum. Turn it into
861 * a mask.
862 */
863 pio_mask = (2 << (id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
864
865 /* But wait.. there's more. Design your standards by
866 * committee and you too can get a free iordy field to
867 * process. However its the speeds not the modes that
868 * are supported... Note drivers using the timing API
869 * will get this right anyway
870 */
871 }
872
873 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
Tejun Heofb21f0d2006-03-12 12:34:35 +0900874
875 udma_mask = 0;
876 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
877 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
Tejun Heocb95d562006-03-06 04:31:56 +0900878
879 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
880}
881
Tejun Heo86e45b62006-03-05 15:29:09 +0900882/**
883 * ata_port_queue_task - Queue port_task
884 * @ap: The ata_port to queue port_task for
Randy Dunlape2a7f772006-05-18 10:50:18 -0700885 * @fn: workqueue function to be scheduled
886 * @data: data value to pass to workqueue function
887 * @delay: delay time for workqueue function
Tejun Heo86e45b62006-03-05 15:29:09 +0900888 *
889 * Schedule @fn(@data) for execution after @delay jiffies using
890 * port_task. There is one port_task per port and it's the
891 * user(low level driver)'s responsibility to make sure that only
892 * one task is active at any given time.
893 *
894 * libata core layer takes care of synchronization between
895 * port_task and EH. ata_port_queue_task() may be ignored for EH
896 * synchronization.
897 *
898 * LOCKING:
899 * Inherited from caller.
900 */
901void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *), void *data,
902 unsigned long delay)
903{
904 int rc;
905
Tejun Heo2e755f62006-03-05 15:29:09 +0900906 if (ap->flags & ATA_FLAG_FLUSH_PORT_TASK)
Tejun Heo86e45b62006-03-05 15:29:09 +0900907 return;
908
909 PREPARE_WORK(&ap->port_task, fn, data);
910
911 if (!delay)
912 rc = queue_work(ata_wq, &ap->port_task);
913 else
914 rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
915
916 /* rc == 0 means that another user is using port task */
917 WARN_ON(rc == 0);
918}
919
920/**
921 * ata_port_flush_task - Flush port_task
922 * @ap: The ata_port to flush port_task for
923 *
924 * After this function completes, port_task is guranteed not to
925 * be running or scheduled.
926 *
927 * LOCKING:
928 * Kernel thread context (may sleep)
929 */
930void ata_port_flush_task(struct ata_port *ap)
931{
932 unsigned long flags;
933
934 DPRINTK("ENTER\n");
935
936 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900937 ap->flags |= ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heo86e45b62006-03-05 15:29:09 +0900938 spin_unlock_irqrestore(&ap->host_set->lock, flags);
939
940 DPRINTK("flush #1\n");
941 flush_workqueue(ata_wq);
942
943 /*
944 * At this point, if a task is running, it's guaranteed to see
945 * the FLUSH flag; thus, it will never queue pio tasks again.
946 * Cancel and flush.
947 */
948 if (!cancel_delayed_work(&ap->port_task)) {
949 DPRINTK("flush #2\n");
950 flush_workqueue(ata_wq);
951 }
952
953 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900954 ap->flags &= ~ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heo86e45b62006-03-05 15:29:09 +0900955 spin_unlock_irqrestore(&ap->host_set->lock, flags);
956
957 DPRINTK("EXIT\n");
958}
959
Tejun Heo77853bf2006-01-23 13:09:36 +0900960void ata_qc_complete_internal(struct ata_queued_cmd *qc)
Tejun Heoa2a7a662005-12-13 14:48:31 +0900961{
Tejun Heo77853bf2006-01-23 13:09:36 +0900962 struct completion *waiting = qc->private_data;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900963
Tejun Heoa2a7a662005-12-13 14:48:31 +0900964 complete(waiting);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900965}
966
967/**
968 * ata_exec_internal - execute libata internal command
Tejun Heoa2a7a662005-12-13 14:48:31 +0900969 * @dev: Device to which the command is sent
970 * @tf: Taskfile registers for the command and the result
Tejun Heod69cf372006-04-02 18:51:53 +0900971 * @cdb: CDB for packet command
Tejun Heoa2a7a662005-12-13 14:48:31 +0900972 * @dma_dir: Data tranfer direction of the command
973 * @buf: Data buffer of the command
974 * @buflen: Length of data buffer
975 *
976 * Executes libata internal command with timeout. @tf contains
977 * command on entry and result on return. Timeout and error
978 * conditions are reported via return value. No recovery action
979 * is taken after a command times out. It's caller's duty to
980 * clean up after timeout.
981 *
982 * LOCKING:
983 * None. Should be called with kernel context, might sleep.
Tejun Heo551e8882006-06-12 14:09:49 +0900984 *
985 * RETURNS:
986 * Zero on success, AC_ERR_* mask on failure
Tejun Heoa2a7a662005-12-13 14:48:31 +0900987 */
Tejun Heo3373efd2006-05-15 20:57:53 +0900988unsigned ata_exec_internal(struct ata_device *dev,
Tejun Heo1ad8e7f2006-04-02 18:51:53 +0900989 struct ata_taskfile *tf, const u8 *cdb,
990 int dma_dir, void *buf, unsigned int buflen)
Tejun Heoa2a7a662005-12-13 14:48:31 +0900991{
Tejun Heo3373efd2006-05-15 20:57:53 +0900992 struct ata_port *ap = dev->ap;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900993 u8 command = tf->command;
994 struct ata_queued_cmd *qc;
Tejun Heo2ab7db12006-05-15 20:58:02 +0900995 unsigned int tag, preempted_tag;
Tejun Heodedaf2b2006-05-15 21:03:43 +0900996 u32 preempted_sactive, preempted_qc_active;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900997 DECLARE_COMPLETION(wait);
998 unsigned long flags;
Tejun Heo77853bf2006-01-23 13:09:36 +0900999 unsigned int err_mask;
Tejun Heod95a7172006-05-15 20:58:14 +09001000 int rc;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001001
1002 spin_lock_irqsave(&ap->host_set->lock, flags);
1003
Tejun Heoe3180492006-05-15 20:58:09 +09001004 /* no internal command while frozen */
1005 if (ap->flags & ATA_FLAG_FROZEN) {
1006 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1007 return AC_ERR_SYSTEM;
1008 }
1009
Tejun Heo2ab7db12006-05-15 20:58:02 +09001010 /* initialize internal qc */
Tejun Heoa2a7a662005-12-13 14:48:31 +09001011
Tejun Heo2ab7db12006-05-15 20:58:02 +09001012 /* XXX: Tag 0 is used for drivers with legacy EH as some
1013 * drivers choke if any other tag is given. This breaks
1014 * ata_tag_internal() test for those drivers. Don't use new
1015 * EH stuff without converting to it.
1016 */
1017 if (ap->ops->error_handler)
1018 tag = ATA_TAG_INTERNAL;
1019 else
1020 tag = 0;
1021
Tejun Heo6cec4a32006-05-15 21:03:41 +09001022 if (test_and_set_bit(tag, &ap->qc_allocated))
Tejun Heo2ab7db12006-05-15 20:58:02 +09001023 BUG();
Tejun Heof69499f2006-05-15 20:58:03 +09001024 qc = __ata_qc_from_tag(ap, tag);
Tejun Heo2ab7db12006-05-15 20:58:02 +09001025
1026 qc->tag = tag;
1027 qc->scsicmd = NULL;
1028 qc->ap = ap;
1029 qc->dev = dev;
1030 ata_qc_reinit(qc);
1031
1032 preempted_tag = ap->active_tag;
Tejun Heodedaf2b2006-05-15 21:03:43 +09001033 preempted_sactive = ap->sactive;
1034 preempted_qc_active = ap->qc_active;
Tejun Heo2ab7db12006-05-15 20:58:02 +09001035 ap->active_tag = ATA_TAG_POISON;
Tejun Heodedaf2b2006-05-15 21:03:43 +09001036 ap->sactive = 0;
1037 ap->qc_active = 0;
Tejun Heo2ab7db12006-05-15 20:58:02 +09001038
1039 /* prepare & issue qc */
Tejun Heoa2a7a662005-12-13 14:48:31 +09001040 qc->tf = *tf;
Tejun Heod69cf372006-04-02 18:51:53 +09001041 if (cdb)
1042 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
Tejun Heoe61e0672006-05-15 20:57:40 +09001043 qc->flags |= ATA_QCFLAG_RESULT_TF;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001044 qc->dma_dir = dma_dir;
1045 if (dma_dir != DMA_NONE) {
1046 ata_sg_init_one(qc, buf, buflen);
1047 qc->nsect = buflen / ATA_SECT_SIZE;
1048 }
1049
Tejun Heo77853bf2006-01-23 13:09:36 +09001050 qc->private_data = &wait;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001051 qc->complete_fn = ata_qc_complete_internal;
1052
Tejun Heo8e0e6942006-03-31 20:41:11 +09001053 ata_qc_issue(qc);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001054
1055 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1056
Tejun Heod95a7172006-05-15 20:58:14 +09001057 rc = wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL);
Albert Lee41ade502006-03-14 11:19:04 +08001058
Tejun Heod95a7172006-05-15 20:58:14 +09001059 ata_port_flush_task(ap);
1060
1061 if (!rc) {
Tejun Heoa2a7a662005-12-13 14:48:31 +09001062 spin_lock_irqsave(&ap->host_set->lock, flags);
1063
1064 /* We're racing with irq here. If we lose, the
1065 * following test prevents us from completing the qc
Tejun Heod95a7172006-05-15 20:58:14 +09001066 * twice. If we win, the port is frozen and will be
1067 * cleaned up by ->post_internal_cmd().
Tejun Heoa2a7a662005-12-13 14:48:31 +09001068 */
Tejun Heo77853bf2006-01-23 13:09:36 +09001069 if (qc->flags & ATA_QCFLAG_ACTIVE) {
Tejun Heod95a7172006-05-15 20:58:14 +09001070 qc->err_mask |= AC_ERR_TIMEOUT;
1071
1072 if (ap->ops->error_handler)
1073 ata_port_freeze(ap);
1074 else
1075 ata_qc_complete(qc);
Tejun Heof15a1da2006-05-15 20:57:56 +09001076
1077 ata_dev_printk(dev, KERN_WARNING,
1078 "qc timeout (cmd 0x%x)\n", command);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001079 }
1080
1081 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1082 }
1083
Tejun Heod95a7172006-05-15 20:58:14 +09001084 /* do post_internal_cmd */
1085 if (ap->ops->post_internal_cmd)
1086 ap->ops->post_internal_cmd(qc);
1087
1088 if (qc->flags & ATA_QCFLAG_FAILED && !qc->err_mask) {
1089 ata_dev_printk(dev, KERN_WARNING, "zero err_mask for failed "
1090 "internal command, assuming AC_ERR_OTHER\n");
1091 qc->err_mask |= AC_ERR_OTHER;
1092 }
1093
Tejun Heo15869302006-05-15 20:57:33 +09001094 /* finish up */
1095 spin_lock_irqsave(&ap->host_set->lock, flags);
1096
Tejun Heoe61e0672006-05-15 20:57:40 +09001097 *tf = qc->result_tf;
Tejun Heo77853bf2006-01-23 13:09:36 +09001098 err_mask = qc->err_mask;
1099
1100 ata_qc_free(qc);
Tejun Heo2ab7db12006-05-15 20:58:02 +09001101 ap->active_tag = preempted_tag;
Tejun Heodedaf2b2006-05-15 21:03:43 +09001102 ap->sactive = preempted_sactive;
1103 ap->qc_active = preempted_qc_active;
Tejun Heo77853bf2006-01-23 13:09:36 +09001104
Tejun Heo1f7dd3e92006-03-24 15:25:30 +09001105 /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1106 * Until those drivers are fixed, we detect the condition
1107 * here, fail the command with AC_ERR_SYSTEM and reenable the
1108 * port.
1109 *
1110 * Note that this doesn't change any behavior as internal
1111 * command failure results in disabling the device in the
1112 * higher layer for LLDDs without new reset/EH callbacks.
1113 *
1114 * Kill the following code as soon as those drivers are fixed.
1115 */
Tejun Heo198e0fe2006-04-02 18:51:52 +09001116 if (ap->flags & ATA_FLAG_DISABLED) {
Tejun Heo1f7dd3e92006-03-24 15:25:30 +09001117 err_mask |= AC_ERR_SYSTEM;
1118 ata_port_probe(ap);
1119 }
1120
Tejun Heo15869302006-05-15 20:57:33 +09001121 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1122
Tejun Heo77853bf2006-01-23 13:09:36 +09001123 return err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001124}
1125
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126/**
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001127 * ata_pio_need_iordy - check if iordy needed
1128 * @adev: ATA device
1129 *
1130 * Check if the current speed of the device requires IORDY. Used
1131 * by various controllers for chip configuration.
1132 */
1133
1134unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1135{
1136 int pio;
1137 int speed = adev->pio_mode - XFER_PIO_0;
1138
1139 if (speed < 2)
1140 return 0;
1141 if (speed > 2)
1142 return 1;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001143
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001144 /* If we have no drive specific rule, then PIO 2 is non IORDY */
1145
1146 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1147 pio = adev->id[ATA_ID_EIDE_PIO];
1148 /* Is the speed faster than the drive allows non IORDY ? */
1149 if (pio) {
1150 /* This is cycle times not frequency - watch the logic! */
1151 if (pio > 240) /* PIO2 is 240nS per cycle */
1152 return 1;
1153 return 0;
1154 }
1155 }
1156 return 0;
1157}
1158
1159/**
Tejun Heo49016ac2006-02-21 02:12:11 +09001160 * ata_dev_read_id - Read ID data from the specified device
Tejun Heo49016ac2006-02-21 02:12:11 +09001161 * @dev: target device
1162 * @p_class: pointer to class of the target device (may be changed)
1163 * @post_reset: is this read ID post-reset?
Tejun Heofe635c72006-05-15 20:57:35 +09001164 * @id: buffer to read IDENTIFY data into
Tejun Heo49016ac2006-02-21 02:12:11 +09001165 *
1166 * Read ID data from the specified device. ATA_CMD_ID_ATA is
1167 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
Tejun Heoaec5c3c2006-03-25 01:33:34 +09001168 * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS
1169 * for pre-ATA4 drives.
Tejun Heo49016ac2006-02-21 02:12:11 +09001170 *
1171 * LOCKING:
1172 * Kernel thread context (may sleep)
1173 *
1174 * RETURNS:
1175 * 0 on success, -errno otherwise.
1176 */
Tejun Heoa9beec92006-05-31 18:27:44 +09001177int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
1178 int post_reset, u16 *id)
Tejun Heo49016ac2006-02-21 02:12:11 +09001179{
Tejun Heo3373efd2006-05-15 20:57:53 +09001180 struct ata_port *ap = dev->ap;
Tejun Heo49016ac2006-02-21 02:12:11 +09001181 unsigned int class = *p_class;
Tejun Heo49016ac2006-02-21 02:12:11 +09001182 struct ata_taskfile tf;
1183 unsigned int err_mask = 0;
1184 const char *reason;
1185 int rc;
1186
1187 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1188
Tejun Heo49016ac2006-02-21 02:12:11 +09001189 ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1190
1191 retry:
Tejun Heo3373efd2006-05-15 20:57:53 +09001192 ata_tf_init(dev, &tf);
Tejun Heo49016ac2006-02-21 02:12:11 +09001193
1194 switch (class) {
1195 case ATA_DEV_ATA:
1196 tf.command = ATA_CMD_ID_ATA;
1197 break;
1198 case ATA_DEV_ATAPI:
1199 tf.command = ATA_CMD_ID_ATAPI;
1200 break;
1201 default:
1202 rc = -ENODEV;
1203 reason = "unsupported class";
1204 goto err_out;
1205 }
1206
1207 tf.protocol = ATA_PROT_PIO;
1208
Tejun Heo3373efd2006-05-15 20:57:53 +09001209 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
Tejun Heo49016ac2006-02-21 02:12:11 +09001210 id, sizeof(id[0]) * ATA_ID_WORDS);
Tejun Heo49016ac2006-02-21 02:12:11 +09001211 if (err_mask) {
1212 rc = -EIO;
1213 reason = "I/O error";
Tejun Heo49016ac2006-02-21 02:12:11 +09001214 goto err_out;
1215 }
1216
1217 swap_buf_le16(id, ATA_ID_WORDS);
1218
Tejun Heo49016ac2006-02-21 02:12:11 +09001219 /* sanity check */
Alan Cox692785e2006-03-27 18:49:19 +01001220 if ((class == ATA_DEV_ATA) != (ata_id_is_ata(id) | ata_id_is_cfa(id))) {
Tejun Heo49016ac2006-02-21 02:12:11 +09001221 rc = -EINVAL;
1222 reason = "device reports illegal type";
1223 goto err_out;
1224 }
1225
1226 if (post_reset && class == ATA_DEV_ATA) {
1227 /*
1228 * The exact sequence expected by certain pre-ATA4 drives is:
1229 * SRST RESET
1230 * IDENTIFY
1231 * INITIALIZE DEVICE PARAMETERS
1232 * anything else..
1233 * Some drives were very specific about that exact sequence.
1234 */
1235 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
Tejun Heo3373efd2006-05-15 20:57:53 +09001236 err_mask = ata_dev_init_params(dev, id[3], id[6]);
Tejun Heo49016ac2006-02-21 02:12:11 +09001237 if (err_mask) {
1238 rc = -EIO;
1239 reason = "INIT_DEV_PARAMS failed";
1240 goto err_out;
1241 }
1242
1243 /* current CHS translation info (id[53-58]) might be
1244 * changed. reread the identify device info.
1245 */
1246 post_reset = 0;
1247 goto retry;
1248 }
1249 }
1250
1251 *p_class = class;
Tejun Heofe635c72006-05-15 20:57:35 +09001252
Tejun Heo49016ac2006-02-21 02:12:11 +09001253 return 0;
1254
1255 err_out:
Tejun Heof15a1da2006-05-15 20:57:56 +09001256 ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY "
1257 "(%s, err_mask=0x%x)\n", reason, err_mask);
Tejun Heo49016ac2006-02-21 02:12:11 +09001258 return rc;
1259}
1260
Tejun Heo3373efd2006-05-15 20:57:53 +09001261static inline u8 ata_dev_knobble(struct ata_device *dev)
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001262{
Tejun Heo3373efd2006-05-15 20:57:53 +09001263 return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001264}
1265
Tejun Heoa6e6ce82006-05-15 21:03:48 +09001266static void ata_dev_config_ncq(struct ata_device *dev,
1267 char *desc, size_t desc_sz)
1268{
1269 struct ata_port *ap = dev->ap;
1270 int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
1271
1272 if (!ata_id_has_ncq(dev->id)) {
1273 desc[0] = '\0';
1274 return;
1275 }
1276
1277 if (ap->flags & ATA_FLAG_NCQ) {
1278 hdepth = min(ap->host->can_queue, ATA_MAX_QUEUE - 1);
1279 dev->flags |= ATA_DFLAG_NCQ;
1280 }
1281
1282 if (hdepth >= ddepth)
1283 snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth);
1284 else
1285 snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth);
1286}
1287
Tejun Heo49016ac2006-02-21 02:12:11 +09001288/**
Tejun Heoffeae412006-03-01 16:09:35 +09001289 * ata_dev_configure - Configure the specified ATA/ATAPI device
Tejun Heoffeae412006-03-01 16:09:35 +09001290 * @dev: Target device to configure
Tejun Heo4c2d7212006-03-05 17:55:58 +09001291 * @print_info: Enable device info printout
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 *
Tejun Heoffeae412006-03-01 16:09:35 +09001293 * Configure @dev according to @dev->id. Generic and low-level
1294 * driver specific fixups are also applied.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 *
1296 * LOCKING:
Tejun Heoffeae412006-03-01 16:09:35 +09001297 * Kernel thread context (may sleep)
1298 *
1299 * RETURNS:
1300 * 0 on success, -errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 */
Tejun Heoa9beec92006-05-31 18:27:44 +09001302int ata_dev_configure(struct ata_device *dev, int print_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303{
Tejun Heo3373efd2006-05-15 20:57:53 +09001304 struct ata_port *ap = dev->ap;
Tejun Heo1148c3a2006-03-13 19:48:04 +09001305 const u16 *id = dev->id;
Tejun Heoff8854b2006-03-06 04:31:56 +09001306 unsigned int xfer_mask;
Tejun Heo6e7846e2006-02-12 23:32:58 +09001307 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Tejun Heoe1211e32006-04-01 01:38:18 +09001309 if (!ata_dev_enabled(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
Tejun Heoffeae412006-03-01 16:09:35 +09001311 ap->id, dev->devno);
1312 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 }
1314
Tejun Heoffeae412006-03-01 16:09:35 +09001315 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
Tejun Heoc39f5eb2006-03-13 19:51:19 +09001317 /* print device capabilities */
1318 if (print_info)
Tejun Heof15a1da2006-05-15 20:57:56 +09001319 ata_dev_printk(dev, KERN_DEBUG, "cfg 49:%04x 82:%04x 83:%04x "
1320 "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1321 id[49], id[82], id[83], id[84],
1322 id[85], id[86], id[87], id[88]);
Tejun Heoc39f5eb2006-03-13 19:51:19 +09001323
Tejun Heo208a9932006-03-05 17:55:58 +09001324 /* initialize to-be-configured parameters */
Tejun Heoea1dd4e2006-04-02 18:51:53 +09001325 dev->flags &= ~ATA_DFLAG_CFG_MASK;
Tejun Heo208a9932006-03-05 17:55:58 +09001326 dev->max_sectors = 0;
1327 dev->cdb_len = 0;
1328 dev->n_sectors = 0;
1329 dev->cylinders = 0;
1330 dev->heads = 0;
1331 dev->sectors = 0;
1332
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 /*
1334 * common ATA, ATAPI feature tests
1335 */
1336
Tejun Heoff8854b2006-03-06 04:31:56 +09001337 /* find max transfer mode; for printk only */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001338 xfer_mask = ata_id_xfermask(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
Tejun Heo1148c3a2006-03-13 19:48:04 +09001340 ata_dump_id(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342 /* ATA-specific feature tests */
1343 if (dev->class == ATA_DEV_ATA) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001344 dev->n_sectors = ata_id_n_sectors(id);
Tejun Heo29407402006-02-12 22:47:04 +09001345
Tejun Heo1148c3a2006-03-13 19:48:04 +09001346 if (ata_id_has_lba(id)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001347 const char *lba_desc;
Tejun Heoa6e6ce82006-05-15 21:03:48 +09001348 char ncq_desc[20];
Albert Lee8bf62ece2005-05-12 15:29:42 -04001349
Tejun Heo4c2d7212006-03-05 17:55:58 +09001350 lba_desc = "LBA";
1351 dev->flags |= ATA_DFLAG_LBA;
Tejun Heo1148c3a2006-03-13 19:48:04 +09001352 if (ata_id_has_lba48(id)) {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001353 dev->flags |= ATA_DFLAG_LBA48;
Tejun Heo4c2d7212006-03-05 17:55:58 +09001354 lba_desc = "LBA48";
1355 }
Albert Lee8bf62ece2005-05-12 15:29:42 -04001356
Tejun Heoa6e6ce82006-05-15 21:03:48 +09001357 /* config NCQ */
1358 ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
1359
Albert Lee8bf62ece2005-05-12 15:29:42 -04001360 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001361 if (print_info)
Tejun Heof15a1da2006-05-15 20:57:56 +09001362 ata_dev_printk(dev, KERN_INFO, "ATA-%d, "
Tejun Heoa6e6ce82006-05-15 21:03:48 +09001363 "max %s, %Lu sectors: %s %s\n",
Tejun Heof15a1da2006-05-15 20:57:56 +09001364 ata_id_major_version(id),
1365 ata_mode_string(xfer_mask),
1366 (unsigned long long)dev->n_sectors,
Tejun Heoa6e6ce82006-05-15 21:03:48 +09001367 lba_desc, ncq_desc);
Tejun Heoffeae412006-03-01 16:09:35 +09001368 } else {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001369 /* CHS */
1370
1371 /* Default translation */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001372 dev->cylinders = id[1];
1373 dev->heads = id[3];
1374 dev->sectors = id[6];
Albert Lee8bf62ece2005-05-12 15:29:42 -04001375
Tejun Heo1148c3a2006-03-13 19:48:04 +09001376 if (ata_id_current_chs_valid(id)) {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001377 /* Current CHS translation is valid. */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001378 dev->cylinders = id[54];
1379 dev->heads = id[55];
1380 dev->sectors = id[56];
Albert Lee8bf62ece2005-05-12 15:29:42 -04001381 }
1382
1383 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001384 if (print_info)
Tejun Heof15a1da2006-05-15 20:57:56 +09001385 ata_dev_printk(dev, KERN_INFO, "ATA-%d, "
1386 "max %s, %Lu sectors: CHS %u/%u/%u\n",
1387 ata_id_major_version(id),
1388 ata_mode_string(xfer_mask),
1389 (unsigned long long)dev->n_sectors,
1390 dev->cylinders, dev->heads, dev->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 }
1392
Albert Lee07f6f7d2005-11-01 19:33:20 +08001393 if (dev->id[59] & 0x100) {
1394 dev->multi_count = dev->id[59] & 0xff;
1395 DPRINTK("ata%u: dev %u multi count %u\n",
Albert Lee999bb6f2006-03-25 18:07:48 +08001396 ap->id, dev->devno, dev->multi_count);
Albert Lee07f6f7d2005-11-01 19:33:20 +08001397 }
1398
Tejun Heo6e7846e2006-02-12 23:32:58 +09001399 dev->cdb_len = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 }
1401
1402 /* ATAPI-specific feature tests */
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05001403 else if (dev->class == ATA_DEV_ATAPI) {
Albert Lee08a556d2006-03-31 13:29:04 +08001404 char *cdb_intr_string = "";
1405
Tejun Heo1148c3a2006-03-13 19:48:04 +09001406 rc = atapi_cdb_len(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
Tejun Heof15a1da2006-05-15 20:57:56 +09001408 ata_dev_printk(dev, KERN_WARNING,
1409 "unsupported CDB len\n");
Tejun Heoffeae412006-03-01 16:09:35 +09001410 rc = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 goto err_out_nosup;
1412 }
Tejun Heo6e7846e2006-02-12 23:32:58 +09001413 dev->cdb_len = (unsigned int) rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
Albert Lee08a556d2006-03-31 13:29:04 +08001415 if (ata_id_cdb_intr(dev->id)) {
Albert Lee312f7da2005-09-27 17:38:03 +08001416 dev->flags |= ATA_DFLAG_CDB_INTR;
Albert Lee08a556d2006-03-31 13:29:04 +08001417 cdb_intr_string = ", CDB intr";
1418 }
Albert Lee312f7da2005-09-27 17:38:03 +08001419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001421 if (print_info)
Tejun Heo12436c32006-05-15 20:59:15 +09001422 ata_dev_printk(dev, KERN_INFO, "ATAPI, max %s%s\n",
1423 ata_mode_string(xfer_mask),
1424 cdb_intr_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 }
1426
Tejun Heo6e7846e2006-02-12 23:32:58 +09001427 ap->host->max_cmd_len = 0;
1428 for (i = 0; i < ATA_MAX_DEVICES; i++)
1429 ap->host->max_cmd_len = max_t(unsigned int,
1430 ap->host->max_cmd_len,
1431 ap->device[i].cdb_len);
1432
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001433 /* limit bridge transfers to udma5, 200 sectors */
Tejun Heo3373efd2006-05-15 20:57:53 +09001434 if (ata_dev_knobble(dev)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001435 if (print_info)
Tejun Heof15a1da2006-05-15 20:57:56 +09001436 ata_dev_printk(dev, KERN_INFO,
1437 "applying bridge limits\n");
Tejun Heo5a529132006-03-24 14:07:50 +09001438 dev->udma_mask &= ATA_UDMA5;
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001439 dev->max_sectors = ATA_MAX_SECTORS;
1440 }
1441
1442 if (ap->ops->dev_config)
1443 ap->ops->dev_config(ap, dev);
1444
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
Tejun Heoffeae412006-03-01 16:09:35 +09001446 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
1448err_out_nosup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 DPRINTK("EXIT, err\n");
Tejun Heoffeae412006-03-01 16:09:35 +09001450 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451}
1452
1453/**
1454 * ata_bus_probe - Reset and probe ATA bus
1455 * @ap: Bus to probe
1456 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001457 * Master ATA bus probing function. Initiates a hardware-dependent
1458 * bus reset, then attempts to identify any devices found on
1459 * the bus.
1460 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001462 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 *
1464 * RETURNS:
Tejun Heo96072e62006-04-01 01:38:17 +09001465 * Zero on success, negative errno otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 */
1467
1468static int ata_bus_probe(struct ata_port *ap)
1469{
Tejun Heo28ca5c52006-03-01 16:09:36 +09001470 unsigned int classes[ATA_MAX_DEVICES];
Tejun Heo14d2bac2006-04-02 17:54:46 +09001471 int tries[ATA_MAX_DEVICES];
1472 int i, rc, down_xfermask;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001473 struct ata_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
Tejun Heo28ca5c52006-03-01 16:09:36 +09001475 ata_port_probe(ap);
1476
Tejun Heo14d2bac2006-04-02 17:54:46 +09001477 for (i = 0; i < ATA_MAX_DEVICES; i++)
1478 tries[i] = ATA_PROBE_MAX_TRIES;
1479
1480 retry:
1481 down_xfermask = 0;
1482
Tejun Heo20444702006-03-13 01:57:01 +09001483 /* reset and determine device classes */
Tejun Heo52783c52006-05-31 18:28:22 +09001484 ap->ops->phy_reset(ap);
Tejun Heo2061a472006-03-12 00:57:39 +09001485
Tejun Heo52783c52006-05-31 18:28:22 +09001486 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1487 dev = &ap->device[i];
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001488
Tejun Heo52783c52006-05-31 18:28:22 +09001489 if (!(ap->flags & ATA_FLAG_DISABLED) &&
1490 dev->class != ATA_DEV_UNKNOWN)
1491 classes[dev->devno] = dev->class;
1492 else
1493 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heo20444702006-03-13 01:57:01 +09001494
Tejun Heo52783c52006-05-31 18:28:22 +09001495 dev->class = ATA_DEV_UNKNOWN;
Tejun Heo28ca5c52006-03-01 16:09:36 +09001496 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
Tejun Heo52783c52006-05-31 18:28:22 +09001498 ata_port_probe(ap);
Tejun Heo20444702006-03-13 01:57:01 +09001499
Alan Coxb6079ca2006-05-22 16:52:06 +01001500 /* after the reset the device state is PIO 0 and the controller
1501 state is undefined. Record the mode */
1502
1503 for (i = 0; i < ATA_MAX_DEVICES; i++)
1504 ap->device[i].pio_mode = XFER_PIO_0;
1505
Tejun Heo28ca5c52006-03-01 16:09:36 +09001506 /* read IDENTIFY page and configure devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001508 dev = &ap->device[i];
Tejun Heo28ca5c52006-03-01 16:09:36 +09001509
Tejun Heoec573752006-04-11 22:26:29 +09001510 if (tries[i])
1511 dev->class = classes[i];
Tejun Heo14d2bac2006-04-02 17:54:46 +09001512
Tejun Heoe1211e32006-04-01 01:38:18 +09001513 if (!ata_dev_enabled(dev))
Tejun Heoffeae412006-03-01 16:09:35 +09001514 continue;
1515
Tejun Heo3373efd2006-05-15 20:57:53 +09001516 rc = ata_dev_read_id(dev, &dev->class, 1, dev->id);
Tejun Heo14d2bac2006-04-02 17:54:46 +09001517 if (rc)
1518 goto fail;
Tejun Heoffeae412006-03-01 16:09:35 +09001519
Tejun Heo3373efd2006-05-15 20:57:53 +09001520 rc = ata_dev_configure(dev, 1);
Tejun Heo14d2bac2006-04-02 17:54:46 +09001521 if (rc)
1522 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 }
1524
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001525 /* configure transfer mode */
Tejun Heo3adcebb2006-05-15 20:57:37 +09001526 rc = ata_set_mode(ap, &dev);
Tejun Heo51713d32006-04-11 22:26:29 +09001527 if (rc) {
1528 down_xfermask = 1;
1529 goto fail;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001530 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001532 for (i = 0; i < ATA_MAX_DEVICES; i++)
1533 if (ata_dev_enabled(&ap->device[i]))
1534 return 0;
Alan Coxe35a9e02006-03-27 18:46:37 +01001535
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001536 /* no device present, disable port */
1537 ata_port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 ap->ops->port_disable(ap);
Tejun Heo96072e62006-04-01 01:38:17 +09001539 return -ENODEV;
Tejun Heo14d2bac2006-04-02 17:54:46 +09001540
1541 fail:
1542 switch (rc) {
1543 case -EINVAL:
1544 case -ENODEV:
1545 tries[dev->devno] = 0;
1546 break;
1547 case -EIO:
Tejun Heo3c567b72006-05-15 20:57:23 +09001548 sata_down_spd_limit(ap);
Tejun Heo14d2bac2006-04-02 17:54:46 +09001549 /* fall through */
1550 default:
1551 tries[dev->devno]--;
1552 if (down_xfermask &&
Tejun Heo3373efd2006-05-15 20:57:53 +09001553 ata_down_xfermask_limit(dev, tries[dev->devno] == 1))
Tejun Heo14d2bac2006-04-02 17:54:46 +09001554 tries[dev->devno] = 0;
1555 }
1556
Tejun Heoec573752006-04-11 22:26:29 +09001557 if (!tries[dev->devno]) {
Tejun Heo3373efd2006-05-15 20:57:53 +09001558 ata_down_xfermask_limit(dev, 1);
1559 ata_dev_disable(dev);
Tejun Heoec573752006-04-11 22:26:29 +09001560 }
1561
Tejun Heo14d2bac2006-04-02 17:54:46 +09001562 goto retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563}
1564
1565/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04001566 * ata_port_probe - Mark port as enabled
1567 * @ap: Port for which we indicate enablement
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001569 * Modify @ap data structure such that the system
1570 * thinks that the entire port is enabled.
1571 *
1572 * LOCKING: host_set lock, or some other form of
1573 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 */
1575
1576void ata_port_probe(struct ata_port *ap)
1577{
Tejun Heo198e0fe2006-04-02 18:51:52 +09001578 ap->flags &= ~ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579}
1580
1581/**
Tejun Heo3be680b2005-12-19 22:35:02 +09001582 * sata_print_link_status - Print SATA link status
1583 * @ap: SATA port to printk link status about
1584 *
1585 * This function prints link speed and status of a SATA link.
1586 *
1587 * LOCKING:
1588 * None.
1589 */
1590static void sata_print_link_status(struct ata_port *ap)
1591{
Tejun Heo6d5f9732006-04-03 00:09:41 +09001592 u32 sstatus, scontrol, tmp;
Tejun Heo3be680b2005-12-19 22:35:02 +09001593
Tejun Heo81952c52006-05-15 20:57:47 +09001594 if (sata_scr_read(ap, SCR_STATUS, &sstatus))
Tejun Heo3be680b2005-12-19 22:35:02 +09001595 return;
Tejun Heo81952c52006-05-15 20:57:47 +09001596 sata_scr_read(ap, SCR_CONTROL, &scontrol);
Tejun Heo3be680b2005-12-19 22:35:02 +09001597
Tejun Heo81952c52006-05-15 20:57:47 +09001598 if (ata_port_online(ap)) {
Tejun Heo3be680b2005-12-19 22:35:02 +09001599 tmp = (sstatus >> 4) & 0xf;
Tejun Heof15a1da2006-05-15 20:57:56 +09001600 ata_port_printk(ap, KERN_INFO,
1601 "SATA link up %s (SStatus %X SControl %X)\n",
1602 sata_spd_string(tmp), sstatus, scontrol);
Tejun Heo3be680b2005-12-19 22:35:02 +09001603 } else {
Tejun Heof15a1da2006-05-15 20:57:56 +09001604 ata_port_printk(ap, KERN_INFO,
1605 "SATA link down (SStatus %X SControl %X)\n",
1606 sstatus, scontrol);
Tejun Heo3be680b2005-12-19 22:35:02 +09001607 }
1608}
1609
1610/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001611 * __sata_phy_reset - Wake/reset a low-level SATA PHY
1612 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001614 * This function issues commands to standard SATA Sxxx
1615 * PHY registers, to wake up the phy (and device), and
1616 * clear any reset condition.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 *
1618 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001619 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 *
1621 */
1622void __sata_phy_reset(struct ata_port *ap)
1623{
1624 u32 sstatus;
1625 unsigned long timeout = jiffies + (HZ * 5);
1626
1627 if (ap->flags & ATA_FLAG_SATA_RESET) {
Brett Russcdcca89e2005-03-28 15:10:27 -05001628 /* issue phy wake/reset */
Tejun Heo81952c52006-05-15 20:57:47 +09001629 sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
Tejun Heo62ba2842005-06-26 23:27:19 +09001630 /* Couldn't find anything in SATA I/II specs, but
1631 * AHCI-1.1 10.4.2 says at least 1 ms. */
1632 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 }
Tejun Heo81952c52006-05-15 20:57:47 +09001634 /* phy wake/clear reset */
1635 sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
1637 /* wait for phy to become ready, if necessary */
1638 do {
1639 msleep(200);
Tejun Heo81952c52006-05-15 20:57:47 +09001640 sata_scr_read(ap, SCR_STATUS, &sstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 if ((sstatus & 0xf) != 1)
1642 break;
1643 } while (time_before(jiffies, timeout));
1644
Tejun Heo3be680b2005-12-19 22:35:02 +09001645 /* print link status */
1646 sata_print_link_status(ap);
Jeff Garzik656563e2005-11-20 03:36:45 -05001647
Tejun Heo3be680b2005-12-19 22:35:02 +09001648 /* TODO: phy layer with polling, timeouts, etc. */
Tejun Heo81952c52006-05-15 20:57:47 +09001649 if (!ata_port_offline(ap))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 ata_port_probe(ap);
Tejun Heo3be680b2005-12-19 22:35:02 +09001651 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 ata_port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Tejun Heo198e0fe2006-04-02 18:51:52 +09001654 if (ap->flags & ATA_FLAG_DISABLED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 return;
1656
1657 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1658 ata_port_disable(ap);
1659 return;
1660 }
1661
1662 ap->cbl = ATA_CBL_SATA;
1663}
1664
1665/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001666 * sata_phy_reset - Reset SATA bus.
1667 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001669 * This function resets the SATA bus, and then probes
1670 * the bus for devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 *
1672 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001673 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 *
1675 */
1676void sata_phy_reset(struct ata_port *ap)
1677{
1678 __sata_phy_reset(ap);
Tejun Heo198e0fe2006-04-02 18:51:52 +09001679 if (ap->flags & ATA_FLAG_DISABLED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 return;
1681 ata_bus_reset(ap);
1682}
1683
1684/**
Alan Coxebdfca62006-03-23 15:38:34 +00001685 * ata_dev_pair - return other device on cable
Alan Coxebdfca62006-03-23 15:38:34 +00001686 * @adev: device
1687 *
1688 * Obtain the other device on the same cable, or if none is
1689 * present NULL is returned
1690 */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001691
Tejun Heo3373efd2006-05-15 20:57:53 +09001692struct ata_device *ata_dev_pair(struct ata_device *adev)
Alan Coxebdfca62006-03-23 15:38:34 +00001693{
Tejun Heo3373efd2006-05-15 20:57:53 +09001694 struct ata_port *ap = adev->ap;
Alan Coxebdfca62006-03-23 15:38:34 +00001695 struct ata_device *pair = &ap->device[1 - adev->devno];
Tejun Heoe1211e32006-04-01 01:38:18 +09001696 if (!ata_dev_enabled(pair))
Alan Coxebdfca62006-03-23 15:38:34 +00001697 return NULL;
1698 return pair;
1699}
1700
1701/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001702 * ata_port_disable - Disable port.
1703 * @ap: Port to be disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001705 * Modify @ap data structure such that the system
1706 * thinks that the entire port is disabled, and should
1707 * never attempt to probe or communicate with devices
1708 * on this port.
1709 *
1710 * LOCKING: host_set lock, or some other form of
1711 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 */
1713
1714void ata_port_disable(struct ata_port *ap)
1715{
1716 ap->device[0].class = ATA_DEV_NONE;
1717 ap->device[1].class = ATA_DEV_NONE;
Tejun Heo198e0fe2006-04-02 18:51:52 +09001718 ap->flags |= ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719}
1720
Tejun Heo1c3fae42006-04-02 20:53:28 +09001721/**
Tejun Heo3c567b72006-05-15 20:57:23 +09001722 * sata_down_spd_limit - adjust SATA spd limit downward
Tejun Heo1c3fae42006-04-02 20:53:28 +09001723 * @ap: Port to adjust SATA spd limit for
1724 *
1725 * Adjust SATA spd limit of @ap downward. Note that this
1726 * function only adjusts the limit. The change must be applied
Tejun Heo3c567b72006-05-15 20:57:23 +09001727 * using sata_set_spd().
Tejun Heo1c3fae42006-04-02 20:53:28 +09001728 *
1729 * LOCKING:
1730 * Inherited from caller.
1731 *
1732 * RETURNS:
1733 * 0 on success, negative errno on failure
1734 */
Tejun Heo3c567b72006-05-15 20:57:23 +09001735int sata_down_spd_limit(struct ata_port *ap)
Tejun Heo1c3fae42006-04-02 20:53:28 +09001736{
Tejun Heo81952c52006-05-15 20:57:47 +09001737 u32 sstatus, spd, mask;
1738 int rc, highbit;
Tejun Heo1c3fae42006-04-02 20:53:28 +09001739
Tejun Heo81952c52006-05-15 20:57:47 +09001740 rc = sata_scr_read(ap, SCR_STATUS, &sstatus);
1741 if (rc)
1742 return rc;
Tejun Heo1c3fae42006-04-02 20:53:28 +09001743
1744 mask = ap->sata_spd_limit;
1745 if (mask <= 1)
1746 return -EINVAL;
1747 highbit = fls(mask) - 1;
1748 mask &= ~(1 << highbit);
1749
Tejun Heo81952c52006-05-15 20:57:47 +09001750 spd = (sstatus >> 4) & 0xf;
Tejun Heo1c3fae42006-04-02 20:53:28 +09001751 if (spd <= 1)
1752 return -EINVAL;
1753 spd--;
1754 mask &= (1 << spd) - 1;
1755 if (!mask)
1756 return -EINVAL;
1757
1758 ap->sata_spd_limit = mask;
1759
Tejun Heof15a1da2006-05-15 20:57:56 +09001760 ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n",
1761 sata_spd_string(fls(mask)));
Tejun Heo1c3fae42006-04-02 20:53:28 +09001762
1763 return 0;
1764}
1765
Tejun Heo3c567b72006-05-15 20:57:23 +09001766static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
Tejun Heo1c3fae42006-04-02 20:53:28 +09001767{
1768 u32 spd, limit;
1769
1770 if (ap->sata_spd_limit == UINT_MAX)
1771 limit = 0;
1772 else
1773 limit = fls(ap->sata_spd_limit);
1774
1775 spd = (*scontrol >> 4) & 0xf;
1776 *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
1777
1778 return spd != limit;
1779}
1780
1781/**
Tejun Heo3c567b72006-05-15 20:57:23 +09001782 * sata_set_spd_needed - is SATA spd configuration needed
Tejun Heo1c3fae42006-04-02 20:53:28 +09001783 * @ap: Port in question
1784 *
1785 * Test whether the spd limit in SControl matches
1786 * @ap->sata_spd_limit. This function is used to determine
1787 * whether hardreset is necessary to apply SATA spd
1788 * configuration.
1789 *
1790 * LOCKING:
1791 * Inherited from caller.
1792 *
1793 * RETURNS:
1794 * 1 if SATA spd configuration is needed, 0 otherwise.
1795 */
Tejun Heo3c567b72006-05-15 20:57:23 +09001796int sata_set_spd_needed(struct ata_port *ap)
Tejun Heo1c3fae42006-04-02 20:53:28 +09001797{
1798 u32 scontrol;
1799
Tejun Heo81952c52006-05-15 20:57:47 +09001800 if (sata_scr_read(ap, SCR_CONTROL, &scontrol))
Tejun Heo1c3fae42006-04-02 20:53:28 +09001801 return 0;
1802
Tejun Heo3c567b72006-05-15 20:57:23 +09001803 return __sata_set_spd_needed(ap, &scontrol);
Tejun Heo1c3fae42006-04-02 20:53:28 +09001804}
1805
1806/**
Tejun Heo3c567b72006-05-15 20:57:23 +09001807 * sata_set_spd - set SATA spd according to spd limit
Tejun Heo1c3fae42006-04-02 20:53:28 +09001808 * @ap: Port to set SATA spd for
1809 *
1810 * Set SATA spd of @ap according to sata_spd_limit.
1811 *
1812 * LOCKING:
1813 * Inherited from caller.
1814 *
1815 * RETURNS:
1816 * 0 if spd doesn't need to be changed, 1 if spd has been
Tejun Heo81952c52006-05-15 20:57:47 +09001817 * changed. Negative errno if SCR registers are inaccessible.
Tejun Heo1c3fae42006-04-02 20:53:28 +09001818 */
Tejun Heo3c567b72006-05-15 20:57:23 +09001819int sata_set_spd(struct ata_port *ap)
Tejun Heo1c3fae42006-04-02 20:53:28 +09001820{
1821 u32 scontrol;
Tejun Heo81952c52006-05-15 20:57:47 +09001822 int rc;
Tejun Heo1c3fae42006-04-02 20:53:28 +09001823
Tejun Heo81952c52006-05-15 20:57:47 +09001824 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
1825 return rc;
Tejun Heo1c3fae42006-04-02 20:53:28 +09001826
Tejun Heo3c567b72006-05-15 20:57:23 +09001827 if (!__sata_set_spd_needed(ap, &scontrol))
Tejun Heo1c3fae42006-04-02 20:53:28 +09001828 return 0;
1829
Tejun Heo81952c52006-05-15 20:57:47 +09001830 if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
1831 return rc;
1832
Tejun Heo1c3fae42006-04-02 20:53:28 +09001833 return 1;
1834}
1835
Alan Cox452503f2005-10-21 19:01:32 -04001836/*
1837 * This mode timing computation functionality is ported over from
1838 * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
1839 */
1840/*
1841 * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
1842 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
1843 * for PIO 5, which is a nonstandard extension and UDMA6, which
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001844 * is currently supported only by Maxtor drives.
Alan Cox452503f2005-10-21 19:01:32 -04001845 */
1846
1847static const struct ata_timing ata_timing[] = {
1848
1849 { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 },
1850 { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 },
1851 { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 },
1852 { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 },
1853
1854 { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 },
1855 { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 },
1856 { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 },
1857
1858/* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001859
Alan Cox452503f2005-10-21 19:01:32 -04001860 { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 },
1861 { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 },
1862 { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 },
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001863
Alan Cox452503f2005-10-21 19:01:32 -04001864 { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 },
1865 { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 },
1866 { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 },
1867
1868/* { XFER_PIO_5, 20, 50, 30, 100, 50, 30, 100, 0 }, */
1869 { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 },
1870 { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 },
1871
1872 { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 },
1873 { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 },
1874 { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 },
1875
1876/* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */
1877
1878 { 0xFF }
1879};
1880
1881#define ENOUGH(v,unit) (((v)-1)/(unit)+1)
1882#define EZ(v,unit) ((v)?ENOUGH(v,unit):0)
1883
1884static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
1885{
1886 q->setup = EZ(t->setup * 1000, T);
1887 q->act8b = EZ(t->act8b * 1000, T);
1888 q->rec8b = EZ(t->rec8b * 1000, T);
1889 q->cyc8b = EZ(t->cyc8b * 1000, T);
1890 q->active = EZ(t->active * 1000, T);
1891 q->recover = EZ(t->recover * 1000, T);
1892 q->cycle = EZ(t->cycle * 1000, T);
1893 q->udma = EZ(t->udma * 1000, UT);
1894}
1895
1896void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
1897 struct ata_timing *m, unsigned int what)
1898{
1899 if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup);
1900 if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b);
1901 if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b);
1902 if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b);
1903 if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active);
1904 if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
1905 if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle);
1906 if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma);
1907}
1908
1909static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
1910{
1911 const struct ata_timing *t;
1912
1913 for (t = ata_timing; t->mode != speed; t++)
Alan Cox91190752005-10-26 12:17:46 -04001914 if (t->mode == 0xFF)
Alan Cox452503f2005-10-21 19:01:32 -04001915 return NULL;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001916 return t;
Alan Cox452503f2005-10-21 19:01:32 -04001917}
1918
1919int ata_timing_compute(struct ata_device *adev, unsigned short speed,
1920 struct ata_timing *t, int T, int UT)
1921{
1922 const struct ata_timing *s;
1923 struct ata_timing p;
1924
1925 /*
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001926 * Find the mode.
Albert Lee75b1f2f2005-11-16 17:06:18 +08001927 */
Alan Cox452503f2005-10-21 19:01:32 -04001928
1929 if (!(s = ata_timing_find_mode(speed)))
1930 return -EINVAL;
1931
Albert Lee75b1f2f2005-11-16 17:06:18 +08001932 memcpy(t, s, sizeof(*s));
1933
Alan Cox452503f2005-10-21 19:01:32 -04001934 /*
1935 * If the drive is an EIDE drive, it can tell us it needs extended
1936 * PIO/MW_DMA cycle timing.
1937 */
1938
1939 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
1940 memset(&p, 0, sizeof(p));
1941 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
1942 if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
1943 else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
1944 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
1945 p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
1946 }
1947 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
1948 }
1949
1950 /*
1951 * Convert the timing to bus clock counts.
1952 */
1953
Albert Lee75b1f2f2005-11-16 17:06:18 +08001954 ata_timing_quantize(t, t, T, UT);
Alan Cox452503f2005-10-21 19:01:32 -04001955
1956 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001957 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
1958 * S.M.A.R.T * and some other commands. We have to ensure that the
1959 * DMA cycle timing is slower/equal than the fastest PIO timing.
Alan Cox452503f2005-10-21 19:01:32 -04001960 */
1961
1962 if (speed > XFER_PIO_4) {
1963 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
1964 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
1965 }
1966
1967 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001968 * Lengthen active & recovery time so that cycle time is correct.
Alan Cox452503f2005-10-21 19:01:32 -04001969 */
1970
1971 if (t->act8b + t->rec8b < t->cyc8b) {
1972 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
1973 t->rec8b = t->cyc8b - t->act8b;
1974 }
1975
1976 if (t->active + t->recover < t->cycle) {
1977 t->active += (t->cycle - (t->active + t->recover)) / 2;
1978 t->recover = t->cycle - t->active;
1979 }
1980
1981 return 0;
1982}
1983
Tejun Heocf176e12006-04-02 17:54:46 +09001984/**
1985 * ata_down_xfermask_limit - adjust dev xfer masks downward
Tejun Heocf176e12006-04-02 17:54:46 +09001986 * @dev: Device to adjust xfer masks
1987 * @force_pio0: Force PIO0
1988 *
1989 * Adjust xfer masks of @dev downward. Note that this function
1990 * does not apply the change. Invoking ata_set_mode() afterwards
1991 * will apply the limit.
1992 *
1993 * LOCKING:
1994 * Inherited from caller.
1995 *
1996 * RETURNS:
1997 * 0 on success, negative errno on failure
1998 */
Tejun Heo3373efd2006-05-15 20:57:53 +09001999int ata_down_xfermask_limit(struct ata_device *dev, int force_pio0)
Tejun Heocf176e12006-04-02 17:54:46 +09002000{
2001 unsigned long xfer_mask;
2002 int highbit;
2003
2004 xfer_mask = ata_pack_xfermask(dev->pio_mask, dev->mwdma_mask,
2005 dev->udma_mask);
2006
2007 if (!xfer_mask)
2008 goto fail;
2009 /* don't gear down to MWDMA from UDMA, go directly to PIO */
2010 if (xfer_mask & ATA_MASK_UDMA)
2011 xfer_mask &= ~ATA_MASK_MWDMA;
2012
2013 highbit = fls(xfer_mask) - 1;
2014 xfer_mask &= ~(1 << highbit);
2015 if (force_pio0)
2016 xfer_mask &= 1 << ATA_SHIFT_PIO;
2017 if (!xfer_mask)
2018 goto fail;
2019
2020 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
2021 &dev->udma_mask);
2022
Tejun Heof15a1da2006-05-15 20:57:56 +09002023 ata_dev_printk(dev, KERN_WARNING, "limiting speed to %s\n",
2024 ata_mode_string(xfer_mask));
Tejun Heocf176e12006-04-02 17:54:46 +09002025
2026 return 0;
2027
2028 fail:
2029 return -EINVAL;
2030}
2031
Tejun Heo3373efd2006-05-15 20:57:53 +09002032static int ata_dev_set_mode(struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033{
Tejun Heo83206a22006-03-24 15:25:31 +09002034 unsigned int err_mask;
2035 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036
Tejun Heoe8384602006-04-02 18:51:53 +09002037 dev->flags &= ~ATA_DFLAG_PIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 if (dev->xfer_shift == ATA_SHIFT_PIO)
2039 dev->flags |= ATA_DFLAG_PIO;
2040
Tejun Heo3373efd2006-05-15 20:57:53 +09002041 err_mask = ata_dev_set_xfermode(dev);
Tejun Heo83206a22006-03-24 15:25:31 +09002042 if (err_mask) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002043 ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
2044 "(err_mask=0x%x)\n", err_mask);
Tejun Heo83206a22006-03-24 15:25:31 +09002045 return -EIO;
2046 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047
Tejun Heo3373efd2006-05-15 20:57:53 +09002048 rc = ata_dev_revalidate(dev, 0);
Tejun Heo5eb45c02006-04-02 18:51:52 +09002049 if (rc)
Tejun Heo83206a22006-03-24 15:25:31 +09002050 return rc;
Tejun Heo48a8a142006-03-05 17:55:58 +09002051
Tejun Heo23e71c32006-03-06 04:31:57 +09002052 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
2053 dev->xfer_shift, (int)dev->xfer_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054
Tejun Heof15a1da2006-05-15 20:57:56 +09002055 ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
2056 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
Tejun Heo83206a22006-03-24 15:25:31 +09002057 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058}
2059
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060/**
2061 * ata_set_mode - Program timings and issue SET FEATURES - XFER
2062 * @ap: port on which timings will be programmed
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002063 * @r_failed_dev: out paramter for failed device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 *
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002065 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
2066 * ata_set_mode() fails, pointer to the failing device is
2067 * returned in @r_failed_dev.
Jeff Garzik780a87f2005-05-30 15:41:05 -04002068 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002070 * PCI/etc. bus probe sem.
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002071 *
2072 * RETURNS:
2073 * 0 on success, negative errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 */
Tejun Heo1ad8e7f2006-04-02 18:51:53 +09002075int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076{
Tejun Heoe8e06192006-04-01 01:38:18 +09002077 struct ata_device *dev;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002078 int i, rc = 0, used_dma = 0, found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079
Tejun Heo3adcebb2006-05-15 20:57:37 +09002080 /* has private set_mode? */
2081 if (ap->ops->set_mode) {
2082 /* FIXME: make ->set_mode handle no device case and
2083 * return error code and failing device on failure.
2084 */
2085 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2086 if (ata_dev_enabled(&ap->device[i])) {
2087 ap->ops->set_mode(ap);
2088 break;
2089 }
2090 }
2091 return 0;
2092 }
2093
Tejun Heoa6d5a512006-03-06 04:31:57 +09002094 /* step 1: calculate xfer_mask */
2095 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoacf356b2006-03-24 14:07:50 +09002096 unsigned int pio_mask, dma_mask;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002097
Tejun Heoe8e06192006-04-01 01:38:18 +09002098 dev = &ap->device[i];
2099
Tejun Heoe1211e32006-04-01 01:38:18 +09002100 if (!ata_dev_enabled(dev))
Tejun Heoa6d5a512006-03-06 04:31:57 +09002101 continue;
2102
Tejun Heo3373efd2006-05-15 20:57:53 +09002103 ata_dev_xfermask(dev);
Tejun Heoa6d5a512006-03-06 04:31:57 +09002104
Tejun Heoacf356b2006-03-24 14:07:50 +09002105 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
2106 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
2107 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
2108 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
Alan Cox5444a6f2006-03-27 18:58:20 +01002109
Tejun Heo4f659772006-04-01 01:38:18 +09002110 found = 1;
Alan Cox5444a6f2006-03-27 18:58:20 +01002111 if (dev->dma_mode)
2112 used_dma = 1;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002113 }
Tejun Heo4f659772006-04-01 01:38:18 +09002114 if (!found)
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002115 goto out;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002116
2117 /* step 2: always set host PIO timings */
Tejun Heoe8e06192006-04-01 01:38:18 +09002118 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2119 dev = &ap->device[i];
2120 if (!ata_dev_enabled(dev))
2121 continue;
2122
2123 if (!dev->pio_mode) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002124 ata_dev_printk(dev, KERN_WARNING, "no PIO support\n");
Tejun Heoe8e06192006-04-01 01:38:18 +09002125 rc = -EINVAL;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002126 goto out;
Tejun Heoe8e06192006-04-01 01:38:18 +09002127 }
2128
2129 dev->xfer_mode = dev->pio_mode;
2130 dev->xfer_shift = ATA_SHIFT_PIO;
2131 if (ap->ops->set_piomode)
2132 ap->ops->set_piomode(ap, dev);
2133 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134
Tejun Heoa6d5a512006-03-06 04:31:57 +09002135 /* step 3: set host DMA timings */
Tejun Heoe8e06192006-04-01 01:38:18 +09002136 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2137 dev = &ap->device[i];
2138
2139 if (!ata_dev_enabled(dev) || !dev->dma_mode)
2140 continue;
2141
2142 dev->xfer_mode = dev->dma_mode;
2143 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
2144 if (ap->ops->set_dmamode)
2145 ap->ops->set_dmamode(ap, dev);
2146 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147
2148 /* step 4: update devices' xfer mode */
Tejun Heo83206a22006-03-24 15:25:31 +09002149 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoe8e06192006-04-01 01:38:18 +09002150 dev = &ap->device[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151
Tejun Heoe1211e32006-04-01 01:38:18 +09002152 if (!ata_dev_enabled(dev))
Tejun Heo83206a22006-03-24 15:25:31 +09002153 continue;
2154
Tejun Heo3373efd2006-05-15 20:57:53 +09002155 rc = ata_dev_set_mode(dev);
Tejun Heo5bbc53f2006-04-01 01:38:17 +09002156 if (rc)
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002157 goto out;
Tejun Heo83206a22006-03-24 15:25:31 +09002158 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
Tejun Heoe8e06192006-04-01 01:38:18 +09002160 /* Record simplex status. If we selected DMA then the other
2161 * host channels are not permitted to do so.
Alan Cox5444a6f2006-03-27 18:58:20 +01002162 */
Alan Cox5444a6f2006-03-27 18:58:20 +01002163 if (used_dma && (ap->host_set->flags & ATA_HOST_SIMPLEX))
2164 ap->host_set->simplex_claimed = 1;
2165
Tejun Heoe8e06192006-04-01 01:38:18 +09002166 /* step5: chip specific finalisation */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 if (ap->ops->post_set_mode)
2168 ap->ops->post_set_mode(ap);
2169
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002170 out:
2171 if (rc)
2172 *r_failed_dev = dev;
2173 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174}
2175
2176/**
Jeff Garzik1fdffbc2006-02-09 05:15:27 -05002177 * ata_tf_to_host - issue ATA taskfile to host controller
2178 * @ap: port to which command is being issued
2179 * @tf: ATA taskfile register set
2180 *
2181 * Issues ATA taskfile register set to ATA host controller,
2182 * with proper synchronization with interrupt handler and
2183 * other threads.
2184 *
2185 * LOCKING:
2186 * spin_lock_irqsave(host_set lock)
2187 */
2188
2189static inline void ata_tf_to_host(struct ata_port *ap,
2190 const struct ata_taskfile *tf)
2191{
2192 ap->ops->tf_load(ap, tf);
2193 ap->ops->exec_command(ap, tf);
2194}
2195
2196/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 * ata_busy_sleep - sleep until BSY clears, or timeout
2198 * @ap: port containing status register to be polled
2199 * @tmout_pat: impatience timeout
2200 * @tmout: overall timeout
2201 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002202 * Sleep until ATA Status register bit BSY clears,
2203 * or a timeout occurs.
2204 *
2205 * LOCKING: None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 */
2207
Tejun Heo6f8b9952006-01-24 17:05:21 +09002208unsigned int ata_busy_sleep (struct ata_port *ap,
2209 unsigned long tmout_pat, unsigned long tmout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210{
2211 unsigned long timer_start, timeout;
2212 u8 status;
2213
2214 status = ata_busy_wait(ap, ATA_BUSY, 300);
2215 timer_start = jiffies;
2216 timeout = timer_start + tmout_pat;
2217 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2218 msleep(50);
2219 status = ata_busy_wait(ap, ATA_BUSY, 3);
2220 }
2221
2222 if (status & ATA_BUSY)
Tejun Heof15a1da2006-05-15 20:57:56 +09002223 ata_port_printk(ap, KERN_WARNING,
2224 "port is slow to respond, please be patient\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225
2226 timeout = timer_start + tmout;
2227 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2228 msleep(50);
2229 status = ata_chk_status(ap);
2230 }
2231
2232 if (status & ATA_BUSY) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002233 ata_port_printk(ap, KERN_ERR, "port failed to respond "
2234 "(%lu secs)\n", tmout / HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 return 1;
2236 }
2237
2238 return 0;
2239}
2240
2241static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
2242{
2243 struct ata_ioports *ioaddr = &ap->ioaddr;
2244 unsigned int dev0 = devmask & (1 << 0);
2245 unsigned int dev1 = devmask & (1 << 1);
2246 unsigned long timeout;
2247
2248 /* if device 0 was found in ata_devchk, wait for its
2249 * BSY bit to clear
2250 */
2251 if (dev0)
2252 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2253
2254 /* if device 1 was found in ata_devchk, wait for
2255 * register access, then wait for BSY to clear
2256 */
2257 timeout = jiffies + ATA_TMOUT_BOOT;
2258 while (dev1) {
2259 u8 nsect, lbal;
2260
2261 ap->ops->dev_select(ap, 1);
2262 if (ap->flags & ATA_FLAG_MMIO) {
2263 nsect = readb((void __iomem *) ioaddr->nsect_addr);
2264 lbal = readb((void __iomem *) ioaddr->lbal_addr);
2265 } else {
2266 nsect = inb(ioaddr->nsect_addr);
2267 lbal = inb(ioaddr->lbal_addr);
2268 }
2269 if ((nsect == 1) && (lbal == 1))
2270 break;
2271 if (time_after(jiffies, timeout)) {
2272 dev1 = 0;
2273 break;
2274 }
2275 msleep(50); /* give drive a breather */
2276 }
2277 if (dev1)
2278 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2279
2280 /* is all this really necessary? */
2281 ap->ops->dev_select(ap, 0);
2282 if (dev1)
2283 ap->ops->dev_select(ap, 1);
2284 if (dev0)
2285 ap->ops->dev_select(ap, 0);
2286}
2287
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288static unsigned int ata_bus_softreset(struct ata_port *ap,
2289 unsigned int devmask)
2290{
2291 struct ata_ioports *ioaddr = &ap->ioaddr;
2292
2293 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
2294
2295 /* software reset. causes dev0 to be selected */
2296 if (ap->flags & ATA_FLAG_MMIO) {
2297 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2298 udelay(20); /* FIXME: flush */
2299 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
2300 udelay(20); /* FIXME: flush */
2301 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2302 } else {
2303 outb(ap->ctl, ioaddr->ctl_addr);
2304 udelay(10);
2305 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2306 udelay(10);
2307 outb(ap->ctl, ioaddr->ctl_addr);
2308 }
2309
2310 /* spec mandates ">= 2ms" before checking status.
2311 * We wait 150ms, because that was the magic delay used for
2312 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
2313 * between when the ATA command register is written, and then
2314 * status is checked. Because waiting for "a while" before
2315 * checking status is fine, post SRST, we perform this magic
2316 * delay here as well.
Alan Cox09c7ad72006-03-22 15:52:40 +00002317 *
2318 * Old drivers/ide uses the 2mS rule and then waits for ready
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 */
2320 msleep(150);
2321
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002322 /* Before we perform post reset processing we want to see if
Tejun Heo298a41c2006-03-25 02:58:13 +09002323 * the bus shows 0xFF because the odd clown forgets the D7
2324 * pulldown resistor.
2325 */
Tejun Heo987d2f02006-04-11 22:16:45 +09002326 if (ata_check_status(ap) == 0xFF) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002327 ata_port_printk(ap, KERN_ERR, "SRST failed (status 0xFF)\n");
Tejun Heo298a41c2006-03-25 02:58:13 +09002328 return AC_ERR_OTHER;
Tejun Heo987d2f02006-04-11 22:16:45 +09002329 }
Alan Cox09c7ad72006-03-22 15:52:40 +00002330
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 ata_bus_post_reset(ap, devmask);
2332
2333 return 0;
2334}
2335
2336/**
2337 * ata_bus_reset - reset host port and associated ATA channel
2338 * @ap: port to reset
2339 *
2340 * This is typically the first time we actually start issuing
2341 * commands to the ATA channel. We wait for BSY to clear, then
2342 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
2343 * result. Determine what devices, if any, are on the channel
2344 * by looking at the device 0/1 error register. Look at the signature
2345 * stored in each device's taskfile registers, to determine if
2346 * the device is ATA or ATAPI.
2347 *
2348 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002349 * PCI/etc. bus probe sem.
2350 * Obtains host_set lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 *
2352 * SIDE EFFECTS:
Tejun Heo198e0fe2006-04-02 18:51:52 +09002353 * Sets ATA_FLAG_DISABLED if bus reset fails.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 */
2355
2356void ata_bus_reset(struct ata_port *ap)
2357{
2358 struct ata_ioports *ioaddr = &ap->ioaddr;
2359 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2360 u8 err;
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002361 unsigned int dev0, dev1 = 0, devmask = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362
2363 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
2364
2365 /* determine if device 0/1 are present */
2366 if (ap->flags & ATA_FLAG_SATA_RESET)
2367 dev0 = 1;
2368 else {
2369 dev0 = ata_devchk(ap, 0);
2370 if (slave_possible)
2371 dev1 = ata_devchk(ap, 1);
2372 }
2373
2374 if (dev0)
2375 devmask |= (1 << 0);
2376 if (dev1)
2377 devmask |= (1 << 1);
2378
2379 /* select device 0 again */
2380 ap->ops->dev_select(ap, 0);
2381
2382 /* issue bus reset */
2383 if (ap->flags & ATA_FLAG_SRST)
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002384 if (ata_bus_softreset(ap, devmask))
2385 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386
2387 /*
2388 * determine by signature whether we have ATA or ATAPI devices
2389 */
Tejun Heob4dc7622006-01-24 17:05:22 +09002390 ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 if ((slave_possible) && (err != 0x81))
Tejun Heob4dc7622006-01-24 17:05:22 +09002392 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393
2394 /* re-enable interrupts */
2395 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2396 ata_irq_on(ap);
2397
2398 /* is double-select really necessary? */
2399 if (ap->device[1].class != ATA_DEV_NONE)
2400 ap->ops->dev_select(ap, 1);
2401 if (ap->device[0].class != ATA_DEV_NONE)
2402 ap->ops->dev_select(ap, 0);
2403
2404 /* if no devices were detected, disable this port */
2405 if ((ap->device[0].class == ATA_DEV_NONE) &&
2406 (ap->device[1].class == ATA_DEV_NONE))
2407 goto err_out;
2408
2409 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2410 /* set up device control for ATA_FLAG_SATA_RESET */
2411 if (ap->flags & ATA_FLAG_MMIO)
2412 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2413 else
2414 outb(ap->ctl, ioaddr->ctl_addr);
2415 }
2416
2417 DPRINTK("EXIT\n");
2418 return;
2419
2420err_out:
Tejun Heof15a1da2006-05-15 20:57:56 +09002421 ata_port_printk(ap, KERN_ERR, "disabling port\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422 ap->ops->port_disable(ap);
2423
2424 DPRINTK("EXIT\n");
2425}
2426
Tejun Heod7bb4cc2006-05-31 18:27:46 +09002427/**
2428 * sata_phy_debounce - debounce SATA phy status
2429 * @ap: ATA port to debounce SATA phy status for
2430 * @params: timing parameters { interval, duratinon, timeout } in msec
2431 *
2432 * Make sure SStatus of @ap reaches stable state, determined by
2433 * holding the same value where DET is not 1 for @duration polled
2434 * every @interval, before @timeout. Timeout constraints the
2435 * beginning of the stable state. Because, after hot unplugging,
2436 * DET gets stuck at 1 on some controllers, this functions waits
2437 * until timeout then returns 0 if DET is stable at 1.
2438 *
2439 * LOCKING:
2440 * Kernel thread context (may sleep)
2441 *
2442 * RETURNS:
2443 * 0 on success, -errno on failure.
2444 */
2445int sata_phy_debounce(struct ata_port *ap, const unsigned long *params)
Tejun Heo7a7921e2006-02-02 18:20:00 +09002446{
Tejun Heod7bb4cc2006-05-31 18:27:46 +09002447 unsigned long interval_msec = params[0];
2448 unsigned long duration = params[1] * HZ / 1000;
2449 unsigned long timeout = jiffies + params[2] * HZ / 1000;
2450 unsigned long last_jiffies;
2451 u32 last, cur;
2452 int rc;
2453
2454 if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
2455 return rc;
2456 cur &= 0xf;
2457
2458 last = cur;
2459 last_jiffies = jiffies;
2460
2461 while (1) {
2462 msleep(interval_msec);
2463 if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
2464 return rc;
2465 cur &= 0xf;
2466
2467 /* DET stable? */
2468 if (cur == last) {
2469 if (cur == 1 && time_before(jiffies, timeout))
2470 continue;
2471 if (time_after(jiffies, last_jiffies + duration))
2472 return 0;
2473 continue;
2474 }
2475
2476 /* unstable, start over */
2477 last = cur;
2478 last_jiffies = jiffies;
2479
2480 /* check timeout */
2481 if (time_after(jiffies, timeout))
2482 return -EBUSY;
2483 }
2484}
2485
2486/**
2487 * sata_phy_resume - resume SATA phy
2488 * @ap: ATA port to resume SATA phy for
2489 * @params: timing parameters { interval, duratinon, timeout } in msec
2490 *
2491 * Resume SATA phy of @ap and debounce it.
2492 *
2493 * LOCKING:
2494 * Kernel thread context (may sleep)
2495 *
2496 * RETURNS:
2497 * 0 on success, -errno on failure.
2498 */
2499int sata_phy_resume(struct ata_port *ap, const unsigned long *params)
2500{
2501 u32 scontrol;
Tejun Heo81952c52006-05-15 20:57:47 +09002502 int rc;
Tejun Heo7a7921e2006-02-02 18:20:00 +09002503
Tejun Heo81952c52006-05-15 20:57:47 +09002504 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2505 return rc;
2506
Tejun Heo852ee162006-04-01 01:38:18 +09002507 scontrol = (scontrol & 0x0f0) | 0x300;
Tejun Heo81952c52006-05-15 20:57:47 +09002508
2509 if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
2510 return rc;
Tejun Heo7a7921e2006-02-02 18:20:00 +09002511
Tejun Heod7bb4cc2006-05-31 18:27:46 +09002512 /* Some PHYs react badly if SStatus is pounded immediately
2513 * after resuming. Delay 200ms before debouncing.
2514 */
2515 msleep(200);
Tejun Heo7a7921e2006-02-02 18:20:00 +09002516
Tejun Heod7bb4cc2006-05-31 18:27:46 +09002517 return sata_phy_debounce(ap, params);
Tejun Heo7a7921e2006-02-02 18:20:00 +09002518}
2519
Tejun Heof5914a42006-05-31 18:27:48 +09002520static void ata_wait_spinup(struct ata_port *ap)
2521{
2522 struct ata_eh_context *ehc = &ap->eh_context;
2523 unsigned long end, secs;
2524 int rc;
2525
2526 /* first, debounce phy if SATA */
2527 if (ap->cbl == ATA_CBL_SATA) {
2528 rc = sata_phy_debounce(ap, sata_deb_timing_eh);
2529
2530 /* if debounced successfully and offline, no need to wait */
2531 if ((rc == 0 || rc == -EOPNOTSUPP) && ata_port_offline(ap))
2532 return;
2533 }
2534
2535 /* okay, let's give the drive time to spin up */
2536 end = ehc->i.hotplug_timestamp + ATA_SPINUP_WAIT * HZ / 1000;
2537 secs = ((end - jiffies) + HZ - 1) / HZ;
2538
2539 if (time_after(jiffies, end))
2540 return;
2541
2542 if (secs > 5)
2543 ata_port_printk(ap, KERN_INFO, "waiting for device to spin up "
2544 "(%lu secs)\n", secs);
2545
2546 schedule_timeout_uninterruptible(end - jiffies);
2547}
2548
2549/**
2550 * ata_std_prereset - prepare for reset
2551 * @ap: ATA port to be reset
2552 *
2553 * @ap is about to be reset. Initialize it.
2554 *
2555 * LOCKING:
2556 * Kernel thread context (may sleep)
2557 *
2558 * RETURNS:
2559 * 0 on success, -errno otherwise.
2560 */
2561int ata_std_prereset(struct ata_port *ap)
2562{
2563 struct ata_eh_context *ehc = &ap->eh_context;
2564 const unsigned long *timing;
2565 int rc;
2566
2567 /* hotplug? */
2568 if (ehc->i.flags & ATA_EHI_HOTPLUGGED) {
2569 if (ap->flags & ATA_FLAG_HRST_TO_RESUME)
2570 ehc->i.action |= ATA_EH_HARDRESET;
2571 if (ap->flags & ATA_FLAG_SKIP_D2H_BSY)
2572 ata_wait_spinup(ap);
2573 }
2574
2575 /* if we're about to do hardreset, nothing more to do */
2576 if (ehc->i.action & ATA_EH_HARDRESET)
2577 return 0;
2578
2579 /* if SATA, resume phy */
2580 if (ap->cbl == ATA_CBL_SATA) {
2581 if (ap->flags & ATA_FLAG_LOADING)
2582 timing = sata_deb_timing_boot;
2583 else
2584 timing = sata_deb_timing_eh;
2585
2586 rc = sata_phy_resume(ap, timing);
2587 if (rc && rc != -EOPNOTSUPP) {
2588 /* phy resume failed */
2589 ata_port_printk(ap, KERN_WARNING, "failed to resume "
2590 "link for reset (errno=%d)\n", rc);
2591 return rc;
2592 }
2593 }
2594
2595 /* Wait for !BSY if the controller can wait for the first D2H
2596 * Reg FIS and we don't know that no device is attached.
2597 */
2598 if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_port_offline(ap))
2599 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2600
2601 return 0;
2602}
2603
Tejun Heoc2bd5802006-01-24 17:05:22 +09002604/**
2605 * ata_std_softreset - reset host port via ATA SRST
2606 * @ap: port to reset
Tejun Heoc2bd5802006-01-24 17:05:22 +09002607 * @classes: resulting classes of attached devices
2608 *
Tejun Heo52783c52006-05-31 18:28:22 +09002609 * Reset host port using ATA SRST.
Tejun Heoc2bd5802006-01-24 17:05:22 +09002610 *
2611 * LOCKING:
2612 * Kernel thread context (may sleep)
2613 *
2614 * RETURNS:
2615 * 0 on success, -errno otherwise.
2616 */
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002617int ata_std_softreset(struct ata_port *ap, unsigned int *classes)
Tejun Heoc2bd5802006-01-24 17:05:22 +09002618{
2619 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2620 unsigned int devmask = 0, err_mask;
2621 u8 err;
2622
2623 DPRINTK("ENTER\n");
2624
Tejun Heo81952c52006-05-15 20:57:47 +09002625 if (ata_port_offline(ap)) {
Tejun Heo3a397462006-02-10 23:58:48 +09002626 classes[0] = ATA_DEV_NONE;
2627 goto out;
2628 }
2629
Tejun Heoc2bd5802006-01-24 17:05:22 +09002630 /* determine if device 0/1 are present */
2631 if (ata_devchk(ap, 0))
2632 devmask |= (1 << 0);
2633 if (slave_possible && ata_devchk(ap, 1))
2634 devmask |= (1 << 1);
2635
Tejun Heoc2bd5802006-01-24 17:05:22 +09002636 /* select device 0 again */
2637 ap->ops->dev_select(ap, 0);
2638
2639 /* issue bus reset */
2640 DPRINTK("about to softreset, devmask=%x\n", devmask);
2641 err_mask = ata_bus_softreset(ap, devmask);
2642 if (err_mask) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002643 ata_port_printk(ap, KERN_ERR, "SRST failed (err_mask=0x%x)\n",
2644 err_mask);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002645 return -EIO;
2646 }
2647
2648 /* determine by signature whether we have ATA or ATAPI devices */
2649 classes[0] = ata_dev_try_classify(ap, 0, &err);
2650 if (slave_possible && err != 0x81)
2651 classes[1] = ata_dev_try_classify(ap, 1, &err);
2652
Tejun Heo3a397462006-02-10 23:58:48 +09002653 out:
Tejun Heoc2bd5802006-01-24 17:05:22 +09002654 DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
2655 return 0;
2656}
2657
2658/**
2659 * sata_std_hardreset - reset host port via SATA phy reset
2660 * @ap: port to reset
Tejun Heoc2bd5802006-01-24 17:05:22 +09002661 * @class: resulting class of attached device
2662 *
2663 * SATA phy-reset host port using DET bits of SControl register.
Tejun Heoc2bd5802006-01-24 17:05:22 +09002664 *
2665 * LOCKING:
2666 * Kernel thread context (may sleep)
2667 *
2668 * RETURNS:
2669 * 0 on success, -errno otherwise.
2670 */
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002671int sata_std_hardreset(struct ata_port *ap, unsigned int *class)
Tejun Heoc2bd5802006-01-24 17:05:22 +09002672{
Tejun Heo852ee162006-04-01 01:38:18 +09002673 u32 scontrol;
Tejun Heo81952c52006-05-15 20:57:47 +09002674 int rc;
Tejun Heo852ee162006-04-01 01:38:18 +09002675
Tejun Heoc2bd5802006-01-24 17:05:22 +09002676 DPRINTK("ENTER\n");
2677
Tejun Heo3c567b72006-05-15 20:57:23 +09002678 if (sata_set_spd_needed(ap)) {
Tejun Heo1c3fae42006-04-02 20:53:28 +09002679 /* SATA spec says nothing about how to reconfigure
2680 * spd. To be on the safe side, turn off phy during
2681 * reconfiguration. This works for at least ICH7 AHCI
2682 * and Sil3124.
2683 */
Tejun Heo81952c52006-05-15 20:57:47 +09002684 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2685 return rc;
2686
Tejun Heo1c3fae42006-04-02 20:53:28 +09002687 scontrol = (scontrol & 0x0f0) | 0x302;
Tejun Heo81952c52006-05-15 20:57:47 +09002688
2689 if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
2690 return rc;
Tejun Heo1c3fae42006-04-02 20:53:28 +09002691
Tejun Heo3c567b72006-05-15 20:57:23 +09002692 sata_set_spd(ap);
Tejun Heo1c3fae42006-04-02 20:53:28 +09002693 }
2694
2695 /* issue phy wake/reset */
Tejun Heo81952c52006-05-15 20:57:47 +09002696 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2697 return rc;
2698
Tejun Heo852ee162006-04-01 01:38:18 +09002699 scontrol = (scontrol & 0x0f0) | 0x301;
Tejun Heo81952c52006-05-15 20:57:47 +09002700
2701 if ((rc = sata_scr_write_flush(ap, SCR_CONTROL, scontrol)))
2702 return rc;
Tejun Heoc2bd5802006-01-24 17:05:22 +09002703
Tejun Heo1c3fae42006-04-02 20:53:28 +09002704 /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
Tejun Heoc2bd5802006-01-24 17:05:22 +09002705 * 10.4.2 says at least 1 ms.
2706 */
2707 msleep(1);
2708
Tejun Heo1c3fae42006-04-02 20:53:28 +09002709 /* bring phy back */
Tejun Heod7bb4cc2006-05-31 18:27:46 +09002710 sata_phy_resume(ap, sata_deb_timing_eh);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002711
Tejun Heoc2bd5802006-01-24 17:05:22 +09002712 /* TODO: phy layer with polling, timeouts, etc. */
Tejun Heo81952c52006-05-15 20:57:47 +09002713 if (ata_port_offline(ap)) {
Tejun Heoc2bd5802006-01-24 17:05:22 +09002714 *class = ATA_DEV_NONE;
2715 DPRINTK("EXIT, link offline\n");
2716 return 0;
2717 }
2718
2719 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002720 ata_port_printk(ap, KERN_ERR,
2721 "COMRESET failed (device not ready)\n");
Tejun Heoc2bd5802006-01-24 17:05:22 +09002722 return -EIO;
2723 }
2724
Tejun Heo3a397462006-02-10 23:58:48 +09002725 ap->ops->dev_select(ap, 0); /* probably unnecessary */
2726
Tejun Heoc2bd5802006-01-24 17:05:22 +09002727 *class = ata_dev_try_classify(ap, 0, NULL);
2728
2729 DPRINTK("EXIT, class=%u\n", *class);
2730 return 0;
2731}
2732
2733/**
2734 * ata_std_postreset - standard postreset callback
2735 * @ap: the target ata_port
2736 * @classes: classes of attached devices
2737 *
2738 * This function is invoked after a successful reset. Note that
2739 * the device might have been reset more than once using
2740 * different reset methods before postreset is invoked.
Tejun Heoc2bd5802006-01-24 17:05:22 +09002741 *
Tejun Heoc2bd5802006-01-24 17:05:22 +09002742 * LOCKING:
2743 * Kernel thread context (may sleep)
2744 */
2745void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
2746{
Tejun Heodc2b3512006-05-15 20:58:00 +09002747 u32 serror;
2748
Tejun Heoc2bd5802006-01-24 17:05:22 +09002749 DPRINTK("ENTER\n");
2750
Tejun Heoc2bd5802006-01-24 17:05:22 +09002751 /* print link status */
Tejun Heo81952c52006-05-15 20:57:47 +09002752 sata_print_link_status(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002753
Tejun Heodc2b3512006-05-15 20:58:00 +09002754 /* clear SError */
2755 if (sata_scr_read(ap, SCR_ERROR, &serror) == 0)
2756 sata_scr_write(ap, SCR_ERROR, serror);
2757
Tejun Heo3a397462006-02-10 23:58:48 +09002758 /* re-enable interrupts */
Tejun Heoe3180492006-05-15 20:58:09 +09002759 if (!ap->ops->error_handler) {
2760 /* FIXME: hack. create a hook instead */
2761 if (ap->ioaddr.ctl_addr)
2762 ata_irq_on(ap);
2763 }
Tejun Heoc2bd5802006-01-24 17:05:22 +09002764
2765 /* is double-select really necessary? */
2766 if (classes[0] != ATA_DEV_NONE)
2767 ap->ops->dev_select(ap, 1);
2768 if (classes[1] != ATA_DEV_NONE)
2769 ap->ops->dev_select(ap, 0);
2770
Tejun Heo3a397462006-02-10 23:58:48 +09002771 /* bail out if no device is present */
2772 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2773 DPRINTK("EXIT, no device\n");
2774 return;
2775 }
2776
2777 /* set up device control */
2778 if (ap->ioaddr.ctl_addr) {
2779 if (ap->flags & ATA_FLAG_MMIO)
2780 writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
2781 else
2782 outb(ap->ctl, ap->ioaddr.ctl_addr);
2783 }
Tejun Heoc2bd5802006-01-24 17:05:22 +09002784
2785 DPRINTK("EXIT\n");
2786}
2787
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002788/**
Tejun Heo623a3122006-03-05 17:55:58 +09002789 * ata_dev_same_device - Determine whether new ID matches configured device
Tejun Heo623a3122006-03-05 17:55:58 +09002790 * @dev: device to compare against
2791 * @new_class: class of the new device
2792 * @new_id: IDENTIFY page of the new device
2793 *
2794 * Compare @new_class and @new_id against @dev and determine
2795 * whether @dev is the device indicated by @new_class and
2796 * @new_id.
2797 *
2798 * LOCKING:
2799 * None.
2800 *
2801 * RETURNS:
2802 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
2803 */
Tejun Heo3373efd2006-05-15 20:57:53 +09002804static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
2805 const u16 *new_id)
Tejun Heo623a3122006-03-05 17:55:58 +09002806{
2807 const u16 *old_id = dev->id;
2808 unsigned char model[2][41], serial[2][21];
2809 u64 new_n_sectors;
2810
2811 if (dev->class != new_class) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002812 ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n",
2813 dev->class, new_class);
Tejun Heo623a3122006-03-05 17:55:58 +09002814 return 0;
2815 }
2816
2817 ata_id_c_string(old_id, model[0], ATA_ID_PROD_OFS, sizeof(model[0]));
2818 ata_id_c_string(new_id, model[1], ATA_ID_PROD_OFS, sizeof(model[1]));
2819 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO_OFS, sizeof(serial[0]));
2820 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO_OFS, sizeof(serial[1]));
2821 new_n_sectors = ata_id_n_sectors(new_id);
2822
2823 if (strcmp(model[0], model[1])) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002824 ata_dev_printk(dev, KERN_INFO, "model number mismatch "
2825 "'%s' != '%s'\n", model[0], model[1]);
Tejun Heo623a3122006-03-05 17:55:58 +09002826 return 0;
2827 }
2828
2829 if (strcmp(serial[0], serial[1])) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002830 ata_dev_printk(dev, KERN_INFO, "serial number mismatch "
2831 "'%s' != '%s'\n", serial[0], serial[1]);
Tejun Heo623a3122006-03-05 17:55:58 +09002832 return 0;
2833 }
2834
2835 if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
Tejun Heof15a1da2006-05-15 20:57:56 +09002836 ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch "
2837 "%llu != %llu\n",
2838 (unsigned long long)dev->n_sectors,
2839 (unsigned long long)new_n_sectors);
Tejun Heo623a3122006-03-05 17:55:58 +09002840 return 0;
2841 }
2842
2843 return 1;
2844}
2845
2846/**
2847 * ata_dev_revalidate - Revalidate ATA device
Tejun Heo623a3122006-03-05 17:55:58 +09002848 * @dev: device to revalidate
2849 * @post_reset: is this revalidation after reset?
2850 *
2851 * Re-read IDENTIFY page and make sure @dev is still attached to
2852 * the port.
2853 *
2854 * LOCKING:
2855 * Kernel thread context (may sleep)
2856 *
2857 * RETURNS:
2858 * 0 on success, negative errno otherwise
2859 */
Tejun Heo3373efd2006-05-15 20:57:53 +09002860int ata_dev_revalidate(struct ata_device *dev, int post_reset)
Tejun Heo623a3122006-03-05 17:55:58 +09002861{
Tejun Heo5eb45c02006-04-02 18:51:52 +09002862 unsigned int class = dev->class;
Tejun Heof15a1da2006-05-15 20:57:56 +09002863 u16 *id = (void *)dev->ap->sector_buf;
Tejun Heo623a3122006-03-05 17:55:58 +09002864 int rc;
2865
Tejun Heo5eb45c02006-04-02 18:51:52 +09002866 if (!ata_dev_enabled(dev)) {
2867 rc = -ENODEV;
2868 goto fail;
2869 }
Tejun Heo623a3122006-03-05 17:55:58 +09002870
Tejun Heofe635c72006-05-15 20:57:35 +09002871 /* read ID data */
Tejun Heo3373efd2006-05-15 20:57:53 +09002872 rc = ata_dev_read_id(dev, &class, post_reset, id);
Tejun Heo623a3122006-03-05 17:55:58 +09002873 if (rc)
2874 goto fail;
2875
2876 /* is the device still there? */
Tejun Heo3373efd2006-05-15 20:57:53 +09002877 if (!ata_dev_same_device(dev, class, id)) {
Tejun Heo623a3122006-03-05 17:55:58 +09002878 rc = -ENODEV;
2879 goto fail;
2880 }
2881
Tejun Heofe635c72006-05-15 20:57:35 +09002882 memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
Tejun Heo623a3122006-03-05 17:55:58 +09002883
2884 /* configure device according to the new ID */
Tejun Heo3373efd2006-05-15 20:57:53 +09002885 rc = ata_dev_configure(dev, 0);
Tejun Heo5eb45c02006-04-02 18:51:52 +09002886 if (rc == 0)
2887 return 0;
Tejun Heo623a3122006-03-05 17:55:58 +09002888
2889 fail:
Tejun Heof15a1da2006-05-15 20:57:56 +09002890 ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc);
Tejun Heo623a3122006-03-05 17:55:58 +09002891 return rc;
2892}
2893
Arjan van de Ven98ac62d2005-11-28 10:06:23 +01002894static const char * const ata_dma_blacklist [] = {
Alan Coxf4b15fe2006-03-22 15:54:04 +00002895 "WDC AC11000H", NULL,
2896 "WDC AC22100H", NULL,
2897 "WDC AC32500H", NULL,
2898 "WDC AC33100H", NULL,
2899 "WDC AC31600H", NULL,
2900 "WDC AC32100H", "24.09P07",
2901 "WDC AC23200L", "21.10N21",
2902 "Compaq CRD-8241B", NULL,
2903 "CRD-8400B", NULL,
2904 "CRD-8480B", NULL,
2905 "CRD-8482B", NULL,
2906 "CRD-84", NULL,
2907 "SanDisk SDP3B", NULL,
2908 "SanDisk SDP3B-64", NULL,
2909 "SANYO CD-ROM CRD", NULL,
2910 "HITACHI CDR-8", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002911 "HITACHI CDR-8335", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002912 "HITACHI CDR-8435", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002913 "Toshiba CD-ROM XM-6202B", NULL,
2914 "TOSHIBA CD-ROM XM-1702BC", NULL,
2915 "CD-532E-A", NULL,
2916 "E-IDE CD-ROM CR-840", NULL,
2917 "CD-ROM Drive/F5A", NULL,
2918 "WPI CDD-820", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002919 "SAMSUNG CD-ROM SC-148C", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002920 "SAMSUNG CD-ROM SC", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002921 "SanDisk SDP3B-64", NULL,
2922 "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
2923 "_NEC DV5800A", NULL,
2924 "SAMSUNG CD-ROM SN-124", "N001"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925};
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002926
Alan Coxf4b15fe2006-03-22 15:54:04 +00002927static int ata_strim(char *s, size_t len)
2928{
2929 len = strnlen(s, len);
2930
2931 /* ATAPI specifies that empty space is blank-filled; remove blanks */
2932 while ((len > 0) && (s[len - 1] == ' ')) {
2933 len--;
2934 s[len] = 0;
2935 }
2936 return len;
2937}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938
Jeff Garzik057ace52005-10-22 14:27:05 -04002939static int ata_dma_blacklisted(const struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940{
Alan Coxf4b15fe2006-03-22 15:54:04 +00002941 unsigned char model_num[40];
2942 unsigned char model_rev[16];
2943 unsigned int nlen, rlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 int i;
2945
Alan Coxf4b15fe2006-03-22 15:54:04 +00002946 ata_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
2947 sizeof(model_num));
2948 ata_id_string(dev->id, model_rev, ATA_ID_FW_REV_OFS,
2949 sizeof(model_rev));
2950 nlen = ata_strim(model_num, sizeof(model_num));
2951 rlen = ata_strim(model_rev, sizeof(model_rev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002952
Alan Coxf4b15fe2006-03-22 15:54:04 +00002953 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i += 2) {
2954 if (!strncmp(ata_dma_blacklist[i], model_num, nlen)) {
2955 if (ata_dma_blacklist[i+1] == NULL)
2956 return 1;
2957 if (!strncmp(ata_dma_blacklist[i], model_rev, rlen))
2958 return 1;
2959 }
2960 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 return 0;
2962}
2963
Tejun Heoa6d5a512006-03-06 04:31:57 +09002964/**
2965 * ata_dev_xfermask - Compute supported xfermask of the given device
Tejun Heoa6d5a512006-03-06 04:31:57 +09002966 * @dev: Device to compute xfermask for
2967 *
Tejun Heoacf356b2006-03-24 14:07:50 +09002968 * Compute supported xfermask of @dev and store it in
2969 * dev->*_mask. This function is responsible for applying all
2970 * known limits including host controller limits, device
2971 * blacklist, etc...
Tejun Heoa6d5a512006-03-06 04:31:57 +09002972 *
Tejun Heo600511e2006-03-25 11:14:07 +09002973 * FIXME: The current implementation limits all transfer modes to
2974 * the fastest of the lowested device on the port. This is not
Tejun Heo05c8e0a2006-03-25 14:28:57 +09002975 * required on most controllers.
Tejun Heo600511e2006-03-25 11:14:07 +09002976 *
Tejun Heoa6d5a512006-03-06 04:31:57 +09002977 * LOCKING:
2978 * None.
Tejun Heoa6d5a512006-03-06 04:31:57 +09002979 */
Tejun Heo3373efd2006-05-15 20:57:53 +09002980static void ata_dev_xfermask(struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981{
Tejun Heo3373efd2006-05-15 20:57:53 +09002982 struct ata_port *ap = dev->ap;
Alan Cox5444a6f2006-03-27 18:58:20 +01002983 struct ata_host_set *hs = ap->host_set;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002984 unsigned long xfer_mask;
2985 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986
Tejun Heo565083e2006-04-02 17:54:47 +09002987 xfer_mask = ata_pack_xfermask(ap->pio_mask,
2988 ap->mwdma_mask, ap->udma_mask);
2989
2990 /* Apply cable rule here. Don't apply it early because when
2991 * we handle hot plug the cable type can itself change.
2992 */
2993 if (ap->cbl == ATA_CBL_PATA40)
2994 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995
Alan Cox5444a6f2006-03-27 18:58:20 +01002996 /* FIXME: Use port-wide xfermask for now */
Tejun Heoa6d5a512006-03-06 04:31:57 +09002997 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2998 struct ata_device *d = &ap->device[i];
Tejun Heo565083e2006-04-02 17:54:47 +09002999
3000 if (ata_dev_absent(d))
Tejun Heoa6d5a512006-03-06 04:31:57 +09003001 continue;
Tejun Heo565083e2006-04-02 17:54:47 +09003002
3003 if (ata_dev_disabled(d)) {
3004 /* to avoid violating device selection timing */
3005 xfer_mask &= ata_pack_xfermask(d->pio_mask,
3006 UINT_MAX, UINT_MAX);
3007 continue;
3008 }
3009
3010 xfer_mask &= ata_pack_xfermask(d->pio_mask,
3011 d->mwdma_mask, d->udma_mask);
Tejun Heoa6d5a512006-03-06 04:31:57 +09003012 xfer_mask &= ata_id_xfermask(d->id);
3013 if (ata_dma_blacklisted(d))
3014 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 }
3016
Tejun Heoa6d5a512006-03-06 04:31:57 +09003017 if (ata_dma_blacklisted(dev))
Tejun Heof15a1da2006-05-15 20:57:56 +09003018 ata_dev_printk(dev, KERN_WARNING,
3019 "device is on DMA blacklist, disabling DMA\n");
Tejun Heoa6d5a512006-03-06 04:31:57 +09003020
Alan Cox5444a6f2006-03-27 18:58:20 +01003021 if (hs->flags & ATA_HOST_SIMPLEX) {
3022 if (hs->simplex_claimed)
3023 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
3024 }
Tejun Heo565083e2006-04-02 17:54:47 +09003025
Alan Cox5444a6f2006-03-27 18:58:20 +01003026 if (ap->ops->mode_filter)
3027 xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask);
3028
Tejun Heo565083e2006-04-02 17:54:47 +09003029 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
3030 &dev->mwdma_mask, &dev->udma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031}
3032
Linus Torvalds1da177e2005-04-16 15:20:36 -07003033/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 * @dev: Device to which command will be sent
3036 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003037 * Issue SET FEATURES - XFER MODE command to device @dev
3038 * on port @ap.
3039 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003041 * PCI/etc. bus probe sem.
Tejun Heo83206a22006-03-24 15:25:31 +09003042 *
3043 * RETURNS:
3044 * 0 on success, AC_ERR_* mask otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 */
3046
Tejun Heo3373efd2006-05-15 20:57:53 +09003047static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048{
Tejun Heoa0123702005-12-13 14:49:31 +09003049 struct ata_taskfile tf;
Tejun Heo83206a22006-03-24 15:25:31 +09003050 unsigned int err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051
3052 /* set up set-features taskfile */
3053 DPRINTK("set features - xfer mode\n");
3054
Tejun Heo3373efd2006-05-15 20:57:53 +09003055 ata_tf_init(dev, &tf);
Tejun Heoa0123702005-12-13 14:49:31 +09003056 tf.command = ATA_CMD_SET_FEATURES;
3057 tf.feature = SETFEATURES_XFER;
3058 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3059 tf.protocol = ATA_PROT_NODATA;
3060 tf.nsect = dev->xfer_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061
Tejun Heo3373efd2006-05-15 20:57:53 +09003062 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063
Tejun Heo83206a22006-03-24 15:25:31 +09003064 DPRINTK("EXIT, err_mask=%x\n", err_mask);
3065 return err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066}
3067
3068/**
Albert Lee8bf62ece2005-05-12 15:29:42 -04003069 * ata_dev_init_params - Issue INIT DEV PARAMS command
Albert Lee8bf62ece2005-05-12 15:29:42 -04003070 * @dev: Device to which command will be sent
Randy Dunlape2a7f772006-05-18 10:50:18 -07003071 * @heads: Number of heads (taskfile parameter)
3072 * @sectors: Number of sectors (taskfile parameter)
Albert Lee8bf62ece2005-05-12 15:29:42 -04003073 *
3074 * LOCKING:
Tejun Heo6aff8f12006-02-15 18:24:09 +09003075 * Kernel thread context (may sleep)
3076 *
3077 * RETURNS:
3078 * 0 on success, AC_ERR_* mask otherwise.
Albert Lee8bf62ece2005-05-12 15:29:42 -04003079 */
Tejun Heo3373efd2006-05-15 20:57:53 +09003080static unsigned int ata_dev_init_params(struct ata_device *dev,
3081 u16 heads, u16 sectors)
Albert Lee8bf62ece2005-05-12 15:29:42 -04003082{
Tejun Heoa0123702005-12-13 14:49:31 +09003083 struct ata_taskfile tf;
Tejun Heo6aff8f12006-02-15 18:24:09 +09003084 unsigned int err_mask;
Albert Lee8bf62ece2005-05-12 15:29:42 -04003085
3086 /* Number of sectors per track 1-255. Number of heads 1-16 */
3087 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
Albert Lee00b6f5e2006-03-27 16:39:18 +08003088 return AC_ERR_INVALID;
Albert Lee8bf62ece2005-05-12 15:29:42 -04003089
3090 /* set up init dev params taskfile */
3091 DPRINTK("init dev params \n");
3092
Tejun Heo3373efd2006-05-15 20:57:53 +09003093 ata_tf_init(dev, &tf);
Tejun Heoa0123702005-12-13 14:49:31 +09003094 tf.command = ATA_CMD_INIT_DEV_PARAMS;
3095 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3096 tf.protocol = ATA_PROT_NODATA;
3097 tf.nsect = sectors;
3098 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
Albert Lee8bf62ece2005-05-12 15:29:42 -04003099
Tejun Heo3373efd2006-05-15 20:57:53 +09003100 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
Albert Lee8bf62ece2005-05-12 15:29:42 -04003101
Tejun Heo6aff8f12006-02-15 18:24:09 +09003102 DPRINTK("EXIT, err_mask=%x\n", err_mask);
3103 return err_mask;
Albert Lee8bf62ece2005-05-12 15:29:42 -04003104}
3105
3106/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003107 * ata_sg_clean - Unmap DMA memory associated with command
3108 * @qc: Command containing DMA memory to be released
3109 *
3110 * Unmap all mapped DMA memory associated with this command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111 *
3112 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003113 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 */
3115
3116static void ata_sg_clean(struct ata_queued_cmd *qc)
3117{
3118 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003119 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003120 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003121 void *pad_buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122
Tejun Heoa46314742006-02-11 19:11:13 +09003123 WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
3124 WARN_ON(sg == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125
3126 if (qc->flags & ATA_QCFLAG_SINGLE)
Jeff Garzikf1318832006-02-20 16:55:56 -05003127 WARN_ON(qc->n_elem > 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05003129 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003131 /* if we padded the buffer out to 32-bit bound, and data
3132 * xfer direction is from-device, we must copy from the
3133 * pad buffer back into the supplied buffer
3134 */
3135 if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
3136 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3137
3138 if (qc->flags & ATA_QCFLAG_SG) {
Jeff Garzike1410f22005-11-14 14:06:26 -05003139 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06003140 dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003141 /* restore last sg */
3142 sg[qc->orig_n_elem - 1].length += qc->pad_len;
3143 if (pad_buf) {
3144 struct scatterlist *psg = &qc->pad_sgent;
3145 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3146 memcpy(addr + psg->offset, pad_buf, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05003147 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003148 }
3149 } else {
Tejun Heo2e242fa2006-02-20 23:48:38 +09003150 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06003151 dma_unmap_single(ap->dev,
Jeff Garzike1410f22005-11-14 14:06:26 -05003152 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
3153 dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003154 /* restore sg */
3155 sg->length += qc->pad_len;
3156 if (pad_buf)
3157 memcpy(qc->buf_virt + sg->length - qc->pad_len,
3158 pad_buf, qc->pad_len);
3159 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160
3161 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003162 qc->__sg = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163}
3164
3165/**
3166 * ata_fill_sg - Fill PCI IDE PRD table
3167 * @qc: Metadata associated with taskfile to be transferred
3168 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003169 * Fill PCI IDE PRD (scatter-gather) table with segments
3170 * associated with the current disk command.
3171 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 * LOCKING:
Jeff Garzik780a87f2005-05-30 15:41:05 -04003173 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174 *
3175 */
3176static void ata_fill_sg(struct ata_queued_cmd *qc)
3177{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003179 struct scatterlist *sg;
3180 unsigned int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181
Tejun Heoa46314742006-02-11 19:11:13 +09003182 WARN_ON(qc->__sg == NULL);
Jeff Garzikf1318832006-02-20 16:55:56 -05003183 WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184
3185 idx = 0;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003186 ata_for_each_sg(sg, qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187 u32 addr, offset;
3188 u32 sg_len, len;
3189
3190 /* determine if physical DMA addr spans 64K boundary.
3191 * Note h/w doesn't support 64-bit, so we unconditionally
3192 * truncate dma_addr_t to u32.
3193 */
3194 addr = (u32) sg_dma_address(sg);
3195 sg_len = sg_dma_len(sg);
3196
3197 while (sg_len) {
3198 offset = addr & 0xffff;
3199 len = sg_len;
3200 if ((offset + sg_len) > 0x10000)
3201 len = 0x10000 - offset;
3202
3203 ap->prd[idx].addr = cpu_to_le32(addr);
3204 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
3205 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
3206
3207 idx++;
3208 sg_len -= len;
3209 addr += len;
3210 }
3211 }
3212
3213 if (idx)
3214 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
3215}
3216/**
3217 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
3218 * @qc: Metadata associated with taskfile to check
3219 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003220 * Allow low-level driver to filter ATA PACKET commands, returning
3221 * a status indicating whether or not it is OK to use DMA for the
3222 * supplied PACKET command.
3223 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003225 * spin_lock_irqsave(host_set lock)
3226 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003227 * RETURNS: 0 when ATAPI DMA can be used
3228 * nonzero otherwise
3229 */
3230int ata_check_atapi_dma(struct ata_queued_cmd *qc)
3231{
3232 struct ata_port *ap = qc->ap;
3233 int rc = 0; /* Assume ATAPI DMA is OK by default */
3234
3235 if (ap->ops->check_atapi_dma)
3236 rc = ap->ops->check_atapi_dma(qc);
3237
Albert Leec2bbc552006-03-25 17:56:55 +08003238 /* We don't support polling DMA.
3239 * Use PIO if the LLDD handles only interrupts in
3240 * the HSM_ST_LAST state and the ATAPI device
3241 * generates CDB interrupts.
3242 */
3243 if ((ap->flags & ATA_FLAG_PIO_POLLING) &&
3244 (qc->dev->flags & ATA_DFLAG_CDB_INTR))
3245 rc = 1;
3246
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 return rc;
3248}
3249/**
3250 * ata_qc_prep - Prepare taskfile for submission
3251 * @qc: Metadata associated with taskfile to be prepared
3252 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003253 * Prepare ATA taskfile for submission.
3254 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255 * LOCKING:
3256 * spin_lock_irqsave(host_set lock)
3257 */
3258void ata_qc_prep(struct ata_queued_cmd *qc)
3259{
3260 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
3261 return;
3262
3263 ata_fill_sg(qc);
3264}
3265
Brian Kinge46834c2006-03-17 17:04:03 -06003266void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
3267
Jeff Garzik0cba6322005-05-30 19:49:12 -04003268/**
3269 * ata_sg_init_one - Associate command with memory buffer
3270 * @qc: Command to be associated
3271 * @buf: Memory buffer
3272 * @buflen: Length of memory buffer, in bytes.
3273 *
3274 * Initialize the data-related elements of queued_cmd @qc
3275 * to point to a single memory buffer, @buf of byte length @buflen.
3276 *
3277 * LOCKING:
3278 * spin_lock_irqsave(host_set lock)
3279 */
3280
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
3282{
3283 struct scatterlist *sg;
3284
3285 qc->flags |= ATA_QCFLAG_SINGLE;
3286
3287 memset(&qc->sgent, 0, sizeof(qc->sgent));
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003288 qc->__sg = &qc->sgent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 qc->n_elem = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003290 qc->orig_n_elem = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291 qc->buf_virt = buf;
Brian King233277c2006-06-07 11:25:31 -05003292 qc->nbytes = buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003293
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003294 sg = qc->__sg;
Jeff Garzikf0612bb2005-10-30 01:58:18 -05003295 sg_init_one(sg, buf, buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296}
3297
Jeff Garzik0cba6322005-05-30 19:49:12 -04003298/**
3299 * ata_sg_init - Associate command with scatter-gather table.
3300 * @qc: Command to be associated
3301 * @sg: Scatter-gather table.
3302 * @n_elem: Number of elements in s/g table.
3303 *
3304 * Initialize the data-related elements of queued_cmd @qc
3305 * to point to a scatter-gather table @sg, containing @n_elem
3306 * elements.
3307 *
3308 * LOCKING:
3309 * spin_lock_irqsave(host_set lock)
3310 */
3311
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
3313 unsigned int n_elem)
3314{
3315 qc->flags |= ATA_QCFLAG_SG;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003316 qc->__sg = sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003317 qc->n_elem = n_elem;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003318 qc->orig_n_elem = n_elem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319}
3320
3321/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003322 * ata_sg_setup_one - DMA-map the memory buffer associated with a command.
3323 * @qc: Command with memory buffer to be mapped.
3324 *
3325 * DMA-map the memory buffer associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326 *
3327 * LOCKING:
3328 * spin_lock_irqsave(host_set lock)
3329 *
3330 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003331 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 */
3333
3334static int ata_sg_setup_one(struct ata_queued_cmd *qc)
3335{
3336 struct ata_port *ap = qc->ap;
3337 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003338 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003339 dma_addr_t dma_address;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003340 int trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003341
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003342 /* we must lengthen transfers to end on a 32-bit boundary */
3343 qc->pad_len = sg->length & 3;
3344 if (qc->pad_len) {
3345 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3346 struct scatterlist *psg = &qc->pad_sgent;
3347
Tejun Heoa46314742006-02-11 19:11:13 +09003348 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003349
3350 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3351
3352 if (qc->tf.flags & ATA_TFLAG_WRITE)
3353 memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
3354 qc->pad_len);
3355
3356 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3357 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3358 /* trim sg */
3359 sg->length -= qc->pad_len;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003360 if (sg->length == 0)
3361 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003362
3363 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
3364 sg->length, qc->pad_len);
3365 }
3366
Tejun Heo2e242fa2006-02-20 23:48:38 +09003367 if (trim_sg) {
3368 qc->n_elem--;
Jeff Garzike1410f22005-11-14 14:06:26 -05003369 goto skip_map;
3370 }
3371
Brian King2f1f6102006-03-23 17:30:15 -06003372 dma_address = dma_map_single(ap->dev, qc->buf_virt,
Albert Lee32529e02005-05-26 03:49:42 -04003373 sg->length, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003374 if (dma_mapping_error(dma_address)) {
3375 /* restore sg */
3376 sg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003378 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379
3380 sg_dma_address(sg) = dma_address;
Albert Lee32529e02005-05-26 03:49:42 -04003381 sg_dma_len(sg) = sg->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382
Tejun Heo2e242fa2006-02-20 23:48:38 +09003383skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003384 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
3385 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3386
3387 return 0;
3388}
3389
3390/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003391 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
3392 * @qc: Command with scatter-gather table to be mapped.
3393 *
3394 * DMA-map the scatter-gather table associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 *
3396 * LOCKING:
3397 * spin_lock_irqsave(host_set lock)
3398 *
3399 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003400 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003401 *
3402 */
3403
3404static int ata_sg_setup(struct ata_queued_cmd *qc)
3405{
3406 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003407 struct scatterlist *sg = qc->__sg;
3408 struct scatterlist *lsg = &sg[qc->n_elem - 1];
Jeff Garzike1410f22005-11-14 14:06:26 -05003409 int n_elem, pre_n_elem, dir, trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003410
3411 VPRINTK("ENTER, ata%u\n", ap->id);
Tejun Heoa46314742006-02-11 19:11:13 +09003412 WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003413
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003414 /* we must lengthen transfers to end on a 32-bit boundary */
3415 qc->pad_len = lsg->length & 3;
3416 if (qc->pad_len) {
3417 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3418 struct scatterlist *psg = &qc->pad_sgent;
3419 unsigned int offset;
3420
Tejun Heoa46314742006-02-11 19:11:13 +09003421 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003422
3423 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3424
3425 /*
3426 * psg->page/offset are used to copy to-be-written
3427 * data in this function or read data in ata_sg_clean.
3428 */
3429 offset = lsg->offset + lsg->length - qc->pad_len;
3430 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
3431 psg->offset = offset_in_page(offset);
3432
3433 if (qc->tf.flags & ATA_TFLAG_WRITE) {
3434 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3435 memcpy(pad_buf, addr + psg->offset, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05003436 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003437 }
3438
3439 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3440 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3441 /* trim last sg */
3442 lsg->length -= qc->pad_len;
Jeff Garzike1410f22005-11-14 14:06:26 -05003443 if (lsg->length == 0)
3444 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003445
3446 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
3447 qc->n_elem - 1, lsg->length, qc->pad_len);
3448 }
3449
Jeff Garzike1410f22005-11-14 14:06:26 -05003450 pre_n_elem = qc->n_elem;
3451 if (trim_sg && pre_n_elem)
3452 pre_n_elem--;
3453
3454 if (!pre_n_elem) {
3455 n_elem = 0;
3456 goto skip_map;
3457 }
3458
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459 dir = qc->dma_dir;
Brian King2f1f6102006-03-23 17:30:15 -06003460 n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003461 if (n_elem < 1) {
3462 /* restore last sg */
3463 lsg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003464 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003465 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003466
3467 DPRINTK("%d sg elements mapped\n", n_elem);
3468
Jeff Garzike1410f22005-11-14 14:06:26 -05003469skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003470 qc->n_elem = n_elem;
3471
3472 return 0;
3473}
3474
3475/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003476 * swap_buf_le16 - swap halves of 16-bit words in place
Edward Falk0baab862005-06-02 18:17:13 -04003477 * @buf: Buffer to swap
3478 * @buf_words: Number of 16-bit words in buffer.
3479 *
3480 * Swap halves of 16-bit words if needed to convert from
3481 * little-endian byte order to native cpu byte order, or
3482 * vice-versa.
3483 *
3484 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003485 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04003486 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487void swap_buf_le16(u16 *buf, unsigned int buf_words)
3488{
3489#ifdef __BIG_ENDIAN
3490 unsigned int i;
3491
3492 for (i = 0; i < buf_words; i++)
3493 buf[i] = le16_to_cpu(buf[i]);
3494#endif /* __BIG_ENDIAN */
3495}
3496
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003497/**
3498 * ata_mmio_data_xfer - Transfer data by MMIO
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003499 * @dev: device for this I/O
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003500 * @buf: data buffer
3501 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003502 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003503 *
3504 * Transfer data from/to the device data register by MMIO.
3505 *
3506 * LOCKING:
3507 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003508 */
3509
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003510void ata_mmio_data_xfer(struct ata_device *adev, unsigned char *buf,
3511 unsigned int buflen, int write_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512{
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003513 struct ata_port *ap = adev->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003514 unsigned int i;
3515 unsigned int words = buflen >> 1;
3516 u16 *buf16 = (u16 *) buf;
3517 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
3518
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003519 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520 if (write_data) {
3521 for (i = 0; i < words; i++)
3522 writew(le16_to_cpu(buf16[i]), mmio);
3523 } else {
3524 for (i = 0; i < words; i++)
3525 buf16[i] = cpu_to_le16(readw(mmio));
3526 }
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003527
3528 /* Transfer trailing 1 byte, if any. */
3529 if (unlikely(buflen & 0x01)) {
3530 u16 align_buf[1] = { 0 };
3531 unsigned char *trailing_buf = buf + buflen - 1;
3532
3533 if (write_data) {
3534 memcpy(align_buf, trailing_buf, 1);
3535 writew(le16_to_cpu(align_buf[0]), mmio);
3536 } else {
3537 align_buf[0] = cpu_to_le16(readw(mmio));
3538 memcpy(trailing_buf, align_buf, 1);
3539 }
3540 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003541}
3542
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003543/**
3544 * ata_pio_data_xfer - Transfer data by PIO
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003545 * @adev: device to target
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003546 * @buf: data buffer
3547 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003548 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003549 *
3550 * Transfer data from/to the device data register by PIO.
3551 *
3552 * LOCKING:
3553 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003554 */
3555
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003556void ata_pio_data_xfer(struct ata_device *adev, unsigned char *buf,
3557 unsigned int buflen, int write_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003558{
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003559 struct ata_port *ap = adev->ap;
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003560 unsigned int words = buflen >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003562 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003563 if (write_data)
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003564 outsw(ap->ioaddr.data_addr, buf, words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003565 else
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003566 insw(ap->ioaddr.data_addr, buf, words);
3567
3568 /* Transfer trailing 1 byte, if any. */
3569 if (unlikely(buflen & 0x01)) {
3570 u16 align_buf[1] = { 0 };
3571 unsigned char *trailing_buf = buf + buflen - 1;
3572
3573 if (write_data) {
3574 memcpy(align_buf, trailing_buf, 1);
3575 outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
3576 } else {
3577 align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
3578 memcpy(trailing_buf, align_buf, 1);
3579 }
3580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581}
3582
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003583/**
Alan Cox75e99582006-05-24 14:14:41 +01003584 * ata_pio_data_xfer_noirq - Transfer data by PIO
3585 * @adev: device to target
3586 * @buf: data buffer
3587 * @buflen: buffer length
3588 * @write_data: read/write
3589 *
3590 * Transfer data from/to the device data register by PIO. Do the
3591 * transfer with interrupts disabled.
3592 *
3593 * LOCKING:
3594 * Inherited from caller.
3595 */
3596
3597void ata_pio_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
3598 unsigned int buflen, int write_data)
3599{
3600 unsigned long flags;
3601 local_irq_save(flags);
3602 ata_pio_data_xfer(adev, buf, buflen, write_data);
3603 local_irq_restore(flags);
3604}
3605
3606
3607/**
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003608 * ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
3609 * @qc: Command on going
3610 *
3611 * Transfer ATA_SECT_SIZE of data from/to the ATA device.
3612 *
3613 * LOCKING:
3614 * Inherited from caller.
3615 */
3616
Linus Torvalds1da177e2005-04-16 15:20:36 -07003617static void ata_pio_sector(struct ata_queued_cmd *qc)
3618{
3619 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003620 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621 struct ata_port *ap = qc->ap;
3622 struct page *page;
3623 unsigned int offset;
3624 unsigned char *buf;
3625
3626 if (qc->cursect == (qc->nsect - 1))
Albert Lee14be71f2005-09-27 17:36:35 +08003627 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628
3629 page = sg[qc->cursg].page;
3630 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
3631
3632 /* get the current page and offset */
3633 page = nth_page(page, (offset >> PAGE_SHIFT));
3634 offset %= PAGE_SIZE;
3635
Albert Lee7282aa42005-10-09 09:46:07 -04003636 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3637
Albert Lee91b8b312005-10-09 09:48:44 -04003638 if (PageHighMem(page)) {
3639 unsigned long flags;
Albert Lee7282aa42005-10-09 09:46:07 -04003640
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003641 /* FIXME: use a bounce buffer */
Albert Lee91b8b312005-10-09 09:48:44 -04003642 local_irq_save(flags);
3643 buf = kmap_atomic(page, KM_IRQ0);
Albert Lee083958d2005-10-09 09:47:31 -04003644
Albert Lee91b8b312005-10-09 09:48:44 -04003645 /* do the actual data transfer */
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003646 ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write);
Albert Lee91b8b312005-10-09 09:48:44 -04003647
3648 kunmap_atomic(buf, KM_IRQ0);
3649 local_irq_restore(flags);
3650 } else {
3651 buf = page_address(page);
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003652 ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write);
Albert Lee91b8b312005-10-09 09:48:44 -04003653 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654
3655 qc->cursect++;
3656 qc->cursg_ofs++;
3657
Albert Lee32529e02005-05-26 03:49:42 -04003658 if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003659 qc->cursg++;
3660 qc->cursg_ofs = 0;
3661 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003662}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003663
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003664/**
Albert Lee07f6f7d2005-11-01 19:33:20 +08003665 * ata_pio_sectors - Transfer one or many 512-byte sectors.
3666 * @qc: Command on going
3667 *
Jeff Garzikc81e29b2006-05-24 01:49:12 -04003668 * Transfer one or many ATA_SECT_SIZE of data from/to the
Albert Lee07f6f7d2005-11-01 19:33:20 +08003669 * ATA device for the DRQ request.
3670 *
3671 * LOCKING:
3672 * Inherited from caller.
3673 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003674
Albert Lee07f6f7d2005-11-01 19:33:20 +08003675static void ata_pio_sectors(struct ata_queued_cmd *qc)
3676{
3677 if (is_multi_taskfile(&qc->tf)) {
3678 /* READ/WRITE MULTIPLE */
3679 unsigned int nsect;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003680
Jeff Garzik587005d2006-02-11 18:17:32 -05003681 WARN_ON(qc->dev->multi_count == 0);
Albert Lee07f6f7d2005-11-01 19:33:20 +08003682
3683 nsect = min(qc->nsect - qc->cursect, qc->dev->multi_count);
3684 while (nsect--)
3685 ata_pio_sector(qc);
3686 } else
3687 ata_pio_sector(qc);
3688}
3689
3690/**
Albert Leec71c1852005-10-04 06:03:45 -04003691 * atapi_send_cdb - Write CDB bytes to hardware
3692 * @ap: Port to which ATAPI device is attached.
3693 * @qc: Taskfile currently active
3694 *
3695 * When device has indicated its readiness to accept
3696 * a CDB, this function is called. Send the CDB.
3697 *
3698 * LOCKING:
3699 * caller.
3700 */
3701
3702static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
3703{
3704 /* send SCSI cdb */
3705 DPRINTK("send cdb\n");
Jeff Garzikdb024d52006-02-13 00:23:57 -05003706 WARN_ON(qc->dev->cdb_len < 12);
Albert Leec71c1852005-10-04 06:03:45 -04003707
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003708 ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1);
Albert Leec71c1852005-10-04 06:03:45 -04003709 ata_altstatus(ap); /* flush */
3710
3711 switch (qc->tf.protocol) {
3712 case ATA_PROT_ATAPI:
3713 ap->hsm_task_state = HSM_ST;
3714 break;
3715 case ATA_PROT_ATAPI_NODATA:
3716 ap->hsm_task_state = HSM_ST_LAST;
3717 break;
3718 case ATA_PROT_ATAPI_DMA:
3719 ap->hsm_task_state = HSM_ST_LAST;
3720 /* initiate bmdma */
3721 ap->ops->bmdma_start(qc);
3722 break;
3723 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003724}
3725
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003726/**
3727 * __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3728 * @qc: Command on going
3729 * @bytes: number of bytes
3730 *
3731 * Transfer Transfer data from/to the ATAPI device.
3732 *
3733 * LOCKING:
3734 * Inherited from caller.
3735 *
3736 */
3737
Linus Torvalds1da177e2005-04-16 15:20:36 -07003738static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3739{
3740 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003741 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003742 struct ata_port *ap = qc->ap;
3743 struct page *page;
3744 unsigned char *buf;
3745 unsigned int offset, count;
3746
Albert Lee563a6e12005-08-12 14:17:50 +08003747 if (qc->curbytes + bytes >= qc->nbytes)
Albert Lee14be71f2005-09-27 17:36:35 +08003748 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003749
3750next_sg:
Albert Lee563a6e12005-08-12 14:17:50 +08003751 if (unlikely(qc->cursg >= qc->n_elem)) {
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003752 /*
Albert Lee563a6e12005-08-12 14:17:50 +08003753 * The end of qc->sg is reached and the device expects
3754 * more data to transfer. In order not to overrun qc->sg
3755 * and fulfill length specified in the byte count register,
3756 * - for read case, discard trailing data from the device
3757 * - for write case, padding zero data to the device
3758 */
3759 u16 pad_buf[1] = { 0 };
3760 unsigned int words = bytes >> 1;
3761 unsigned int i;
3762
3763 if (words) /* warning if bytes > 1 */
Tejun Heof15a1da2006-05-15 20:57:56 +09003764 ata_dev_printk(qc->dev, KERN_WARNING,
3765 "%u bytes trailing data\n", bytes);
Albert Lee563a6e12005-08-12 14:17:50 +08003766
3767 for (i = 0; i < words; i++)
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003768 ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write);
Albert Lee563a6e12005-08-12 14:17:50 +08003769
Albert Lee14be71f2005-09-27 17:36:35 +08003770 ap->hsm_task_state = HSM_ST_LAST;
Albert Lee563a6e12005-08-12 14:17:50 +08003771 return;
3772 }
3773
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003774 sg = &qc->__sg[qc->cursg];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003775
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776 page = sg->page;
3777 offset = sg->offset + qc->cursg_ofs;
3778
3779 /* get the current page and offset */
3780 page = nth_page(page, (offset >> PAGE_SHIFT));
3781 offset %= PAGE_SIZE;
3782
Albert Lee6952df02005-06-06 15:56:03 +08003783 /* don't overrun current sg */
Albert Lee32529e02005-05-26 03:49:42 -04003784 count = min(sg->length - qc->cursg_ofs, bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003785
3786 /* don't cross page boundaries */
3787 count = min(count, (unsigned int)PAGE_SIZE - offset);
3788
Albert Lee7282aa42005-10-09 09:46:07 -04003789 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3790
Albert Lee91b8b312005-10-09 09:48:44 -04003791 if (PageHighMem(page)) {
3792 unsigned long flags;
Albert Lee7282aa42005-10-09 09:46:07 -04003793
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003794 /* FIXME: use bounce buffer */
Albert Lee91b8b312005-10-09 09:48:44 -04003795 local_irq_save(flags);
3796 buf = kmap_atomic(page, KM_IRQ0);
Albert Lee083958d2005-10-09 09:47:31 -04003797
Albert Lee91b8b312005-10-09 09:48:44 -04003798 /* do the actual data transfer */
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003799 ap->ops->data_xfer(qc->dev, buf + offset, count, do_write);
Albert Lee91b8b312005-10-09 09:48:44 -04003800
3801 kunmap_atomic(buf, KM_IRQ0);
3802 local_irq_restore(flags);
3803 } else {
3804 buf = page_address(page);
Alan Coxa6b2c5d2006-05-22 16:59:59 +01003805 ap->ops->data_xfer(qc->dev, buf + offset, count, do_write);
Albert Lee91b8b312005-10-09 09:48:44 -04003806 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807
3808 bytes -= count;
3809 qc->curbytes += count;
3810 qc->cursg_ofs += count;
3811
Albert Lee32529e02005-05-26 03:49:42 -04003812 if (qc->cursg_ofs == sg->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003813 qc->cursg++;
3814 qc->cursg_ofs = 0;
3815 }
3816
Albert Lee563a6e12005-08-12 14:17:50 +08003817 if (bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003818 goto next_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003819}
3820
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003821/**
3822 * atapi_pio_bytes - Transfer data from/to the ATAPI device.
3823 * @qc: Command on going
3824 *
3825 * Transfer Transfer data from/to the ATAPI device.
3826 *
3827 * LOCKING:
3828 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003829 */
3830
Linus Torvalds1da177e2005-04-16 15:20:36 -07003831static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3832{
3833 struct ata_port *ap = qc->ap;
3834 struct ata_device *dev = qc->dev;
3835 unsigned int ireason, bc_lo, bc_hi, bytes;
3836 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3837
Albert Leeeec4c3f2006-05-18 17:51:10 +08003838 /* Abuse qc->result_tf for temp storage of intermediate TF
3839 * here to save some kernel stack usage.
3840 * For normal completion, qc->result_tf is not relevant. For
3841 * error, qc->result_tf is later overwritten by ata_qc_complete().
3842 * So, the correctness of qc->result_tf is not affected.
3843 */
3844 ap->ops->tf_read(ap, &qc->result_tf);
3845 ireason = qc->result_tf.nsect;
3846 bc_lo = qc->result_tf.lbam;
3847 bc_hi = qc->result_tf.lbah;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003848 bytes = (bc_hi << 8) | bc_lo;
3849
3850 /* shall be cleared to zero, indicating xfer of data */
3851 if (ireason & (1 << 0))
3852 goto err_out;
3853
3854 /* make sure transfer direction matches expected */
3855 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3856 if (do_write != i_write)
3857 goto err_out;
3858
Albert Lee312f7da2005-09-27 17:38:03 +08003859 VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes);
3860
Linus Torvalds1da177e2005-04-16 15:20:36 -07003861 __atapi_pio_bytes(qc, bytes);
3862
3863 return;
3864
3865err_out:
Tejun Heof15a1da2006-05-15 20:57:56 +09003866 ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n");
Tejun Heo11a56d22006-01-23 13:09:36 +09003867 qc->err_mask |= AC_ERR_HSM;
Albert Lee14be71f2005-09-27 17:36:35 +08003868 ap->hsm_task_state = HSM_ST_ERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003869}
3870
3871/**
Albert Leec234fb02006-03-25 17:58:38 +08003872 * ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue.
3873 * @ap: the target ata_port
3874 * @qc: qc on going
Linus Torvalds1da177e2005-04-16 15:20:36 -07003875 *
Albert Leec234fb02006-03-25 17:58:38 +08003876 * RETURNS:
3877 * 1 if ok in workqueue, 0 otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003878 */
Albert Leec234fb02006-03-25 17:58:38 +08003879
3880static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003881{
Albert Leec234fb02006-03-25 17:58:38 +08003882 if (qc->tf.flags & ATA_TFLAG_POLLING)
3883 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003884
Albert Leec234fb02006-03-25 17:58:38 +08003885 if (ap->hsm_task_state == HSM_ST_FIRST) {
3886 if (qc->tf.protocol == ATA_PROT_PIO &&
3887 (qc->tf.flags & ATA_TFLAG_WRITE))
3888 return 1;
3889
3890 if (is_atapi_taskfile(&qc->tf) &&
3891 !(qc->dev->flags & ATA_DFLAG_CDB_INTR))
3892 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003893 }
3894
Albert Leec234fb02006-03-25 17:58:38 +08003895 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003896}
3897
Albert Leec234fb02006-03-25 17:58:38 +08003898/**
Tejun Heoc17ea202006-05-15 20:59:29 +09003899 * ata_hsm_qc_complete - finish a qc running on standard HSM
3900 * @qc: Command to complete
3901 * @in_wq: 1 if called from workqueue, 0 otherwise
3902 *
3903 * Finish @qc which is running on standard HSM.
3904 *
3905 * LOCKING:
3906 * If @in_wq is zero, spin_lock_irqsave(host_set lock).
3907 * Otherwise, none on entry and grabs host lock.
3908 */
3909static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq)
3910{
3911 struct ata_port *ap = qc->ap;
3912 unsigned long flags;
3913
3914 if (ap->ops->error_handler) {
3915 if (in_wq) {
3916 spin_lock_irqsave(&ap->host_set->lock, flags);
3917
3918 /* EH might have kicked in while host_set lock
3919 * is released.
3920 */
3921 qc = ata_qc_from_tag(ap, qc->tag);
3922 if (qc) {
3923 if (likely(!(qc->err_mask & AC_ERR_HSM))) {
3924 ata_irq_on(ap);
3925 ata_qc_complete(qc);
3926 } else
3927 ata_port_freeze(ap);
3928 }
3929
3930 spin_unlock_irqrestore(&ap->host_set->lock, flags);
3931 } else {
3932 if (likely(!(qc->err_mask & AC_ERR_HSM)))
3933 ata_qc_complete(qc);
3934 else
3935 ata_port_freeze(ap);
3936 }
3937 } else {
3938 if (in_wq) {
3939 spin_lock_irqsave(&ap->host_set->lock, flags);
3940 ata_irq_on(ap);
3941 ata_qc_complete(qc);
3942 spin_unlock_irqrestore(&ap->host_set->lock, flags);
3943 } else
3944 ata_qc_complete(qc);
3945 }
Jeff Garzikc81e29b2006-05-24 01:49:12 -04003946
3947 ata_altstatus(ap); /* flush */
Tejun Heoc17ea202006-05-15 20:59:29 +09003948}
3949
3950/**
Albert Leebb5cb292006-03-25 17:48:02 +08003951 * ata_hsm_move - move the HSM to the next state.
3952 * @ap: the target ata_port
3953 * @qc: qc on going
3954 * @status: current device status
3955 * @in_wq: 1 if called from workqueue, 0 otherwise
3956 *
3957 * RETURNS:
3958 * 1 when poll next status needed, 0 otherwise.
3959 */
Tejun Heo9a1004d2006-05-31 18:27:52 +09003960int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
3961 u8 status, int in_wq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003962{
Albert Leebb5cb292006-03-25 17:48:02 +08003963 unsigned long flags = 0;
3964 int poll_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003965
Albert Lee6912ccd2006-03-25 17:45:49 +08003966 WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0);
Albert Lee0565c262006-02-13 18:55:25 +08003967
Albert Leebb5cb292006-03-25 17:48:02 +08003968 /* Make sure ata_qc_issue_prot() does not throw things
3969 * like DMA polling into the workqueue. Notice that
3970 * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING).
Albert Lee1c848982005-12-05 15:40:15 +08003971 */
Albert Leec234fb02006-03-25 17:58:38 +08003972 WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc));
Albert Lee1c848982005-12-05 15:40:15 +08003973
Albert Leee2cec772006-03-25 17:43:49 +08003974fsm_start:
Albert Lee999bb6f2006-03-25 18:07:48 +08003975 DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
3976 ap->id, qc->tf.protocol, ap->hsm_task_state, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003977
Albert Leee2cec772006-03-25 17:43:49 +08003978 switch (ap->hsm_task_state) {
3979 case HSM_ST_FIRST:
Albert Leebb5cb292006-03-25 17:48:02 +08003980 /* Send first data block or PACKET CDB */
3981
3982 /* If polling, we will stay in the work queue after
3983 * sending the data. Otherwise, interrupt handler
3984 * takes over after sending the data.
3985 */
3986 poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);
3987
Albert Leee2cec772006-03-25 17:43:49 +08003988 /* check device status */
Albert Lee3655d1d2006-05-19 11:43:04 +08003989 if (unlikely((status & ATA_DRQ) == 0)) {
3990 /* handle BSY=0, DRQ=0 as error */
3991 if (likely(status & (ATA_ERR | ATA_DF)))
3992 /* device stops HSM for abort/error */
3993 qc->err_mask |= AC_ERR_DEV;
3994 else
3995 /* HSM violation. Let EH handle this */
3996 qc->err_mask |= AC_ERR_HSM;
3997
Albert Leee2cec772006-03-25 17:43:49 +08003998 ap->hsm_task_state = HSM_ST_ERR;
3999 goto fsm_start;
4000 }
4001
Albert Lee71601952006-03-25 18:11:12 +08004002 /* Device should not ask for data transfer (DRQ=1)
4003 * when it finds something wrong.
Albert Leeeee6c322006-04-01 17:38:43 +08004004 * We ignore DRQ here and stop the HSM by
4005 * changing hsm_task_state to HSM_ST_ERR and
4006 * let the EH abort the command or reset the device.
Albert Lee71601952006-03-25 18:11:12 +08004007 */
4008 if (unlikely(status & (ATA_ERR | ATA_DF))) {
4009 printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
4010 ap->id, status);
Albert Lee3655d1d2006-05-19 11:43:04 +08004011 qc->err_mask |= AC_ERR_HSM;
Albert Leeeee6c322006-04-01 17:38:43 +08004012 ap->hsm_task_state = HSM_ST_ERR;
4013 goto fsm_start;
Albert Lee71601952006-03-25 18:11:12 +08004014 }
4015
Albert Leebb5cb292006-03-25 17:48:02 +08004016 /* Send the CDB (atapi) or the first data block (ata pio out).
4017 * During the state transition, interrupt handler shouldn't
4018 * be invoked before the data transfer is complete and
4019 * hsm_task_state is changed. Hence, the following locking.
4020 */
4021 if (in_wq)
4022 spin_lock_irqsave(&ap->host_set->lock, flags);
Albert Leee2cec772006-03-25 17:43:49 +08004023
Albert Leebb5cb292006-03-25 17:48:02 +08004024 if (qc->tf.protocol == ATA_PROT_PIO) {
4025 /* PIO data out protocol.
4026 * send first data block.
4027 */
4028
4029 /* ata_pio_sectors() might change the state
4030 * to HSM_ST_LAST. so, the state is changed here
4031 * before ata_pio_sectors().
4032 */
4033 ap->hsm_task_state = HSM_ST;
4034 ata_pio_sectors(qc);
4035 ata_altstatus(ap); /* flush */
4036 } else
4037 /* send CDB */
4038 atapi_send_cdb(ap, qc);
4039
4040 if (in_wq)
4041 spin_unlock_irqrestore(&ap->host_set->lock, flags);
4042
4043 /* if polling, ata_pio_task() handles the rest.
4044 * otherwise, interrupt handler takes over from here.
4045 */
Albert Leee2cec772006-03-25 17:43:49 +08004046 break;
4047
4048 case HSM_ST:
4049 /* complete command or read/write the data register */
4050 if (qc->tf.protocol == ATA_PROT_ATAPI) {
4051 /* ATAPI PIO protocol */
4052 if ((status & ATA_DRQ) == 0) {
Albert Lee3655d1d2006-05-19 11:43:04 +08004053 /* No more data to transfer or device error.
4054 * Device error will be tagged in HSM_ST_LAST.
4055 */
Albert Leee2cec772006-03-25 17:43:49 +08004056 ap->hsm_task_state = HSM_ST_LAST;
4057 goto fsm_start;
4058 }
4059
Albert Lee71601952006-03-25 18:11:12 +08004060 /* Device should not ask for data transfer (DRQ=1)
4061 * when it finds something wrong.
Albert Leeeee6c322006-04-01 17:38:43 +08004062 * We ignore DRQ here and stop the HSM by
4063 * changing hsm_task_state to HSM_ST_ERR and
4064 * let the EH abort the command or reset the device.
Albert Lee71601952006-03-25 18:11:12 +08004065 */
4066 if (unlikely(status & (ATA_ERR | ATA_DF))) {
4067 printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
4068 ap->id, status);
Albert Lee3655d1d2006-05-19 11:43:04 +08004069 qc->err_mask |= AC_ERR_HSM;
Albert Leeeee6c322006-04-01 17:38:43 +08004070 ap->hsm_task_state = HSM_ST_ERR;
4071 goto fsm_start;
Albert Lee71601952006-03-25 18:11:12 +08004072 }
4073
Albert Leee2cec772006-03-25 17:43:49 +08004074 atapi_pio_bytes(qc);
4075
4076 if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
4077 /* bad ireason reported by device */
4078 goto fsm_start;
4079
4080 } else {
4081 /* ATA PIO protocol */
4082 if (unlikely((status & ATA_DRQ) == 0)) {
4083 /* handle BSY=0, DRQ=0 as error */
Albert Lee3655d1d2006-05-19 11:43:04 +08004084 if (likely(status & (ATA_ERR | ATA_DF)))
4085 /* device stops HSM for abort/error */
4086 qc->err_mask |= AC_ERR_DEV;
4087 else
4088 /* HSM violation. Let EH handle this */
4089 qc->err_mask |= AC_ERR_HSM;
4090
Albert Leee2cec772006-03-25 17:43:49 +08004091 ap->hsm_task_state = HSM_ST_ERR;
4092 goto fsm_start;
4093 }
4094
Albert Leeeee6c322006-04-01 17:38:43 +08004095 /* For PIO reads, some devices may ask for
4096 * data transfer (DRQ=1) alone with ERR=1.
4097 * We respect DRQ here and transfer one
4098 * block of junk data before changing the
4099 * hsm_task_state to HSM_ST_ERR.
4100 *
4101 * For PIO writes, ERR=1 DRQ=1 doesn't make
4102 * sense since the data block has been
4103 * transferred to the device.
Albert Lee71601952006-03-25 18:11:12 +08004104 */
4105 if (unlikely(status & (ATA_ERR | ATA_DF))) {
Albert Lee71601952006-03-25 18:11:12 +08004106 /* data might be corrputed */
4107 qc->err_mask |= AC_ERR_DEV;
Albert Leeeee6c322006-04-01 17:38:43 +08004108
4109 if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
4110 ata_pio_sectors(qc);
4111 ata_altstatus(ap);
4112 status = ata_wait_idle(ap);
4113 }
4114
Albert Lee3655d1d2006-05-19 11:43:04 +08004115 if (status & (ATA_BUSY | ATA_DRQ))
4116 qc->err_mask |= AC_ERR_HSM;
4117
Albert Leeeee6c322006-04-01 17:38:43 +08004118 /* ata_pio_sectors() might change the
4119 * state to HSM_ST_LAST. so, the state
4120 * is changed after ata_pio_sectors().
4121 */
4122 ap->hsm_task_state = HSM_ST_ERR;
4123 goto fsm_start;
Albert Lee71601952006-03-25 18:11:12 +08004124 }
4125
Albert Leee2cec772006-03-25 17:43:49 +08004126 ata_pio_sectors(qc);
4127
4128 if (ap->hsm_task_state == HSM_ST_LAST &&
4129 (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
4130 /* all data read */
4131 ata_altstatus(ap);
Albert Lee52a32202006-03-25 18:18:15 +08004132 status = ata_wait_idle(ap);
Albert Leee2cec772006-03-25 17:43:49 +08004133 goto fsm_start;
4134 }
4135 }
4136
4137 ata_altstatus(ap); /* flush */
Albert Leebb5cb292006-03-25 17:48:02 +08004138 poll_next = 1;
Albert Leee2cec772006-03-25 17:43:49 +08004139 break;
4140
4141 case HSM_ST_LAST:
Albert Lee6912ccd2006-03-25 17:45:49 +08004142 if (unlikely(!ata_ok(status))) {
4143 qc->err_mask |= __ac_err_mask(status);
Albert Leee2cec772006-03-25 17:43:49 +08004144 ap->hsm_task_state = HSM_ST_ERR;
4145 goto fsm_start;
4146 }
4147
4148 /* no more data to transfer */
Albert Lee4332a772006-04-03 17:43:24 +08004149 DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n",
4150 ap->id, qc->dev->devno, status);
Albert Leee2cec772006-03-25 17:43:49 +08004151
Albert Lee6912ccd2006-03-25 17:45:49 +08004152 WARN_ON(qc->err_mask);
4153
Albert Leee2cec772006-03-25 17:43:49 +08004154 ap->hsm_task_state = HSM_ST_IDLE;
4155
4156 /* complete taskfile transaction */
Tejun Heoc17ea202006-05-15 20:59:29 +09004157 ata_hsm_qc_complete(qc, in_wq);
Albert Leebb5cb292006-03-25 17:48:02 +08004158
4159 poll_next = 0;
Albert Leee2cec772006-03-25 17:43:49 +08004160 break;
4161
4162 case HSM_ST_ERR:
Albert Leee2cec772006-03-25 17:43:49 +08004163 /* make sure qc->err_mask is available to
4164 * know what's wrong and recover
4165 */
4166 WARN_ON(qc->err_mask == 0);
4167
4168 ap->hsm_task_state = HSM_ST_IDLE;
Albert Leebb5cb292006-03-25 17:48:02 +08004169
Albert Lee999bb6f2006-03-25 18:07:48 +08004170 /* complete taskfile transaction */
Tejun Heoc17ea202006-05-15 20:59:29 +09004171 ata_hsm_qc_complete(qc, in_wq);
Albert Leebb5cb292006-03-25 17:48:02 +08004172
4173 poll_next = 0;
Albert Leee2cec772006-03-25 17:43:49 +08004174 break;
4175 default:
Albert Leebb5cb292006-03-25 17:48:02 +08004176 poll_next = 0;
Albert Lee6912ccd2006-03-25 17:45:49 +08004177 BUG();
Albert Leee2cec772006-03-25 17:43:49 +08004178 }
4179
Albert Leebb5cb292006-03-25 17:48:02 +08004180 return poll_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004181}
4182
4183static void ata_pio_task(void *_data)
4184{
Tejun Heoc91af2c2006-04-02 18:51:53 +09004185 struct ata_queued_cmd *qc = _data;
4186 struct ata_port *ap = qc->ap;
Albert Leea1af3732006-03-25 17:50:15 +08004187 u8 status;
4188 int poll_next;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04004189
4190fsm_start:
Albert Leea1af3732006-03-25 17:50:15 +08004191 WARN_ON(ap->hsm_task_state == HSM_ST_IDLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004192
Albert Leea1af3732006-03-25 17:50:15 +08004193 /*
4194 * This is purely heuristic. This is a fast path.
4195 * Sometimes when we enter, BSY will be cleared in
4196 * a chk-status or two. If not, the drive is probably seeking
4197 * or something. Snooze for a couple msecs, then
4198 * chk-status again. If still busy, queue delayed work.
4199 */
4200 status = ata_busy_wait(ap, ATA_BUSY, 5);
4201 if (status & ATA_BUSY) {
4202 msleep(2);
4203 status = ata_busy_wait(ap, ATA_BUSY, 10);
4204 if (status & ATA_BUSY) {
Albert Lee31ce6da2006-04-03 18:31:44 +08004205 ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE);
Albert Leea1af3732006-03-25 17:50:15 +08004206 return;
4207 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004208 }
4209
Albert Leea1af3732006-03-25 17:50:15 +08004210 /* move the HSM */
4211 poll_next = ata_hsm_move(ap, qc, status, 1);
4212
4213 /* another command or interrupt handler
4214 * may be running at this point.
4215 */
4216 if (poll_next)
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04004217 goto fsm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004218}
4219
Linus Torvalds1da177e2005-04-16 15:20:36 -07004220/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004221 * ata_qc_new - Request an available ATA command, for queueing
4222 * @ap: Port associated with device @dev
4223 * @dev: Device from whom we request an available command structure
4224 *
4225 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004226 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004227 */
4228
4229static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
4230{
4231 struct ata_queued_cmd *qc = NULL;
4232 unsigned int i;
4233
Tejun Heoe3180492006-05-15 20:58:09 +09004234 /* no command while frozen */
4235 if (unlikely(ap->flags & ATA_FLAG_FROZEN))
4236 return NULL;
4237
Tejun Heo2ab7db12006-05-15 20:58:02 +09004238 /* the last tag is reserved for internal command. */
4239 for (i = 0; i < ATA_MAX_QUEUE - 1; i++)
Tejun Heo6cec4a32006-05-15 21:03:41 +09004240 if (!test_and_set_bit(i, &ap->qc_allocated)) {
Tejun Heof69499f2006-05-15 20:58:03 +09004241 qc = __ata_qc_from_tag(ap, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004242 break;
4243 }
4244
4245 if (qc)
4246 qc->tag = i;
4247
4248 return qc;
4249}
4250
4251/**
4252 * ata_qc_new_init - Request an available ATA command, and initialize it
Linus Torvalds1da177e2005-04-16 15:20:36 -07004253 * @dev: Device from whom we request an available command structure
4254 *
4255 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004256 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004257 */
4258
Tejun Heo3373efd2006-05-15 20:57:53 +09004259struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004260{
Tejun Heo3373efd2006-05-15 20:57:53 +09004261 struct ata_port *ap = dev->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004262 struct ata_queued_cmd *qc;
4263
4264 qc = ata_qc_new(ap);
4265 if (qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004266 qc->scsicmd = NULL;
4267 qc->ap = ap;
4268 qc->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004269
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05004270 ata_qc_reinit(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004271 }
4272
4273 return qc;
4274}
4275
Linus Torvalds1da177e2005-04-16 15:20:36 -07004276/**
4277 * ata_qc_free - free unused ata_queued_cmd
4278 * @qc: Command to complete
4279 *
4280 * Designed to free unused ata_queued_cmd object
4281 * in case something prevents using it.
4282 *
4283 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004284 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004285 */
4286void ata_qc_free(struct ata_queued_cmd *qc)
4287{
Tejun Heo4ba946e2006-01-23 13:09:36 +09004288 struct ata_port *ap = qc->ap;
4289 unsigned int tag;
4290
Tejun Heoa46314742006-02-11 19:11:13 +09004291 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004292
Tejun Heo4ba946e2006-01-23 13:09:36 +09004293 qc->flags = 0;
4294 tag = qc->tag;
4295 if (likely(ata_tag_valid(tag))) {
Tejun Heo4ba946e2006-01-23 13:09:36 +09004296 qc->tag = ATA_TAG_POISON;
Tejun Heo6cec4a32006-05-15 21:03:41 +09004297 clear_bit(tag, &ap->qc_allocated);
Tejun Heo4ba946e2006-01-23 13:09:36 +09004298 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004299}
4300
Tejun Heo76014422006-02-11 15:13:49 +09004301void __ata_qc_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004302{
Tejun Heodedaf2b2006-05-15 21:03:43 +09004303 struct ata_port *ap = qc->ap;
4304
Tejun Heoa46314742006-02-11 19:11:13 +09004305 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4306 WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004307
4308 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4309 ata_sg_clean(qc);
4310
Tejun Heo7401abf2006-05-15 20:57:32 +09004311 /* command should be marked inactive atomically with qc completion */
Tejun Heodedaf2b2006-05-15 21:03:43 +09004312 if (qc->tf.protocol == ATA_PROT_NCQ)
4313 ap->sactive &= ~(1 << qc->tag);
4314 else
4315 ap->active_tag = ATA_TAG_POISON;
Tejun Heo7401abf2006-05-15 20:57:32 +09004316
Albert Lee3f3791d2005-08-16 14:25:38 +08004317 /* atapi: mark qc as inactive to prevent the interrupt handler
4318 * from completing the command twice later, before the error handler
4319 * is called. (when rc != 0 and atapi request sense is needed)
4320 */
4321 qc->flags &= ~ATA_QCFLAG_ACTIVE;
Tejun Heodedaf2b2006-05-15 21:03:43 +09004322 ap->qc_active &= ~(1 << qc->tag);
Albert Lee3f3791d2005-08-16 14:25:38 +08004323
Linus Torvalds1da177e2005-04-16 15:20:36 -07004324 /* call completion callback */
Tejun Heo77853bf2006-01-23 13:09:36 +09004325 qc->complete_fn(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004326}
4327
Tejun Heof686bcb2006-05-15 20:58:05 +09004328/**
4329 * ata_qc_complete - Complete an active ATA command
4330 * @qc: Command to complete
4331 * @err_mask: ATA Status register contents
4332 *
4333 * Indicate to the mid and upper layers that an ATA
4334 * command has completed, with either an ok or not-ok status.
4335 *
4336 * LOCKING:
4337 * spin_lock_irqsave(host_set lock)
4338 */
4339void ata_qc_complete(struct ata_queued_cmd *qc)
4340{
4341 struct ata_port *ap = qc->ap;
4342
4343 /* XXX: New EH and old EH use different mechanisms to
4344 * synchronize EH with regular execution path.
4345 *
4346 * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED.
4347 * Normal execution path is responsible for not accessing a
4348 * failed qc. libata core enforces the rule by returning NULL
4349 * from ata_qc_from_tag() for failed qcs.
4350 *
4351 * Old EH depends on ata_qc_complete() nullifying completion
4352 * requests if ATA_QCFLAG_EH_SCHEDULED is set. Old EH does
4353 * not synchronize with interrupt handler. Only PIO task is
4354 * taken care of.
4355 */
4356 if (ap->ops->error_handler) {
4357 WARN_ON(ap->flags & ATA_FLAG_FROZEN);
4358
4359 if (unlikely(qc->err_mask))
4360 qc->flags |= ATA_QCFLAG_FAILED;
4361
4362 if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
4363 if (!ata_tag_internal(qc->tag)) {
4364 /* always fill result TF for failed qc */
4365 ap->ops->tf_read(ap, &qc->result_tf);
4366 ata_qc_schedule_eh(qc);
4367 return;
4368 }
4369 }
4370
4371 /* read result TF if requested */
4372 if (qc->flags & ATA_QCFLAG_RESULT_TF)
4373 ap->ops->tf_read(ap, &qc->result_tf);
4374
4375 __ata_qc_complete(qc);
4376 } else {
4377 if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
4378 return;
4379
4380 /* read result TF if failed or requested */
4381 if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
4382 ap->ops->tf_read(ap, &qc->result_tf);
4383
4384 __ata_qc_complete(qc);
4385 }
4386}
4387
Tejun Heodedaf2b2006-05-15 21:03:43 +09004388/**
4389 * ata_qc_complete_multiple - Complete multiple qcs successfully
4390 * @ap: port in question
4391 * @qc_active: new qc_active mask
4392 * @finish_qc: LLDD callback invoked before completing a qc
4393 *
4394 * Complete in-flight commands. This functions is meant to be
4395 * called from low-level driver's interrupt routine to complete
4396 * requests normally. ap->qc_active and @qc_active is compared
4397 * and commands are completed accordingly.
4398 *
4399 * LOCKING:
4400 * spin_lock_irqsave(host_set lock)
4401 *
4402 * RETURNS:
4403 * Number of completed commands on success, -errno otherwise.
4404 */
4405int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
4406 void (*finish_qc)(struct ata_queued_cmd *))
4407{
4408 int nr_done = 0;
4409 u32 done_mask;
4410 int i;
4411
4412 done_mask = ap->qc_active ^ qc_active;
4413
4414 if (unlikely(done_mask & qc_active)) {
4415 ata_port_printk(ap, KERN_ERR, "illegal qc_active transition "
4416 "(%08x->%08x)\n", ap->qc_active, qc_active);
4417 return -EINVAL;
4418 }
4419
4420 for (i = 0; i < ATA_MAX_QUEUE; i++) {
4421 struct ata_queued_cmd *qc;
4422
4423 if (!(done_mask & (1 << i)))
4424 continue;
4425
4426 if ((qc = ata_qc_from_tag(ap, i))) {
4427 if (finish_qc)
4428 finish_qc(qc);
4429 ata_qc_complete(qc);
4430 nr_done++;
4431 }
4432 }
4433
4434 return nr_done;
4435}
4436
Linus Torvalds1da177e2005-04-16 15:20:36 -07004437static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
4438{
4439 struct ata_port *ap = qc->ap;
4440
4441 switch (qc->tf.protocol) {
Tejun Heo3dc1d882006-05-15 21:03:45 +09004442 case ATA_PROT_NCQ:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004443 case ATA_PROT_DMA:
4444 case ATA_PROT_ATAPI_DMA:
4445 return 1;
4446
4447 case ATA_PROT_ATAPI:
4448 case ATA_PROT_PIO:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004449 if (ap->flags & ATA_FLAG_PIO_DMA)
4450 return 1;
4451
4452 /* fall through */
4453
4454 default:
4455 return 0;
4456 }
4457
4458 /* never reached */
4459}
4460
4461/**
4462 * ata_qc_issue - issue taskfile to device
4463 * @qc: command to issue to device
4464 *
4465 * Prepare an ATA command to submission to device.
4466 * This includes mapping the data into a DMA-able
4467 * area, filling in the S/G table, and finally
4468 * writing the taskfile to hardware, starting the command.
4469 *
4470 * LOCKING:
4471 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004472 */
Tejun Heo8e0e6942006-03-31 20:41:11 +09004473void ata_qc_issue(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004474{
4475 struct ata_port *ap = qc->ap;
4476
Tejun Heodedaf2b2006-05-15 21:03:43 +09004477 /* Make sure only one non-NCQ command is outstanding. The
4478 * check is skipped for old EH because it reuses active qc to
4479 * request ATAPI sense.
4480 */
4481 WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag));
4482
4483 if (qc->tf.protocol == ATA_PROT_NCQ) {
4484 WARN_ON(ap->sactive & (1 << qc->tag));
4485 ap->sactive |= 1 << qc->tag;
4486 } else {
4487 WARN_ON(ap->sactive);
4488 ap->active_tag = qc->tag;
4489 }
4490
Tejun Heoe4a70e72006-03-31 20:36:47 +09004491 qc->flags |= ATA_QCFLAG_ACTIVE;
Tejun Heodedaf2b2006-05-15 21:03:43 +09004492 ap->qc_active |= 1 << qc->tag;
Tejun Heoe4a70e72006-03-31 20:36:47 +09004493
Linus Torvalds1da177e2005-04-16 15:20:36 -07004494 if (ata_should_dma_map(qc)) {
4495 if (qc->flags & ATA_QCFLAG_SG) {
4496 if (ata_sg_setup(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004497 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004498 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
4499 if (ata_sg_setup_one(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004500 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004501 }
4502 } else {
4503 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4504 }
4505
4506 ap->ops->qc_prep(qc);
4507
Tejun Heo8e0e6942006-03-31 20:41:11 +09004508 qc->err_mask |= ap->ops->qc_issue(qc);
4509 if (unlikely(qc->err_mask))
4510 goto err;
4511 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004512
Tejun Heo8e436af2006-01-23 13:09:36 +09004513sg_err:
4514 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Tejun Heo8e0e6942006-03-31 20:41:11 +09004515 qc->err_mask |= AC_ERR_SYSTEM;
4516err:
4517 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004518}
4519
4520/**
4521 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
4522 * @qc: command to issue to device
4523 *
4524 * Using various libata functions and hooks, this function
4525 * starts an ATA command. ATA commands are grouped into
4526 * classes called "protocols", and issuing each type of protocol
4527 * is slightly different.
4528 *
Edward Falk0baab862005-06-02 18:17:13 -04004529 * May be used as the qc_issue() entry in ata_port_operations.
4530 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004531 * LOCKING:
4532 * spin_lock_irqsave(host_set lock)
4533 *
4534 * RETURNS:
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004535 * Zero on success, AC_ERR_* mask on failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004536 */
4537
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004538unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004539{
4540 struct ata_port *ap = qc->ap;
4541
Albert Leee50362e2005-09-27 17:39:50 +08004542 /* Use polling pio if the LLD doesn't handle
4543 * interrupt driven pio and atapi CDB interrupt.
4544 */
4545 if (ap->flags & ATA_FLAG_PIO_POLLING) {
4546 switch (qc->tf.protocol) {
4547 case ATA_PROT_PIO:
4548 case ATA_PROT_ATAPI:
4549 case ATA_PROT_ATAPI_NODATA:
4550 qc->tf.flags |= ATA_TFLAG_POLLING;
4551 break;
4552 case ATA_PROT_ATAPI_DMA:
4553 if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
Albert Leec2bbc552006-03-25 17:56:55 +08004554 /* see ata_check_atapi_dma() */
Albert Leee50362e2005-09-27 17:39:50 +08004555 BUG();
4556 break;
4557 default:
4558 break;
4559 }
4560 }
4561
Albert Lee312f7da2005-09-27 17:38:03 +08004562 /* select the device */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004563 ata_dev_select(ap, qc->dev->devno, 1, 0);
4564
Albert Lee312f7da2005-09-27 17:38:03 +08004565 /* start the command */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004566 switch (qc->tf.protocol) {
4567 case ATA_PROT_NODATA:
Albert Lee312f7da2005-09-27 17:38:03 +08004568 if (qc->tf.flags & ATA_TFLAG_POLLING)
4569 ata_qc_set_polling(qc);
4570
Jeff Garzike5338252005-10-30 21:37:17 -05004571 ata_tf_to_host(ap, &qc->tf);
Albert Lee312f7da2005-09-27 17:38:03 +08004572 ap->hsm_task_state = HSM_ST_LAST;
4573
4574 if (qc->tf.flags & ATA_TFLAG_POLLING)
Albert Lee31ce6da2006-04-03 18:31:44 +08004575 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Albert Lee312f7da2005-09-27 17:38:03 +08004576
Linus Torvalds1da177e2005-04-16 15:20:36 -07004577 break;
4578
4579 case ATA_PROT_DMA:
Jeff Garzik587005d2006-02-11 18:17:32 -05004580 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
Albert Lee312f7da2005-09-27 17:38:03 +08004581
Linus Torvalds1da177e2005-04-16 15:20:36 -07004582 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4583 ap->ops->bmdma_setup(qc); /* set up bmdma */
4584 ap->ops->bmdma_start(qc); /* initiate bmdma */
Albert Lee312f7da2005-09-27 17:38:03 +08004585 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004586 break;
4587
Albert Lee312f7da2005-09-27 17:38:03 +08004588 case ATA_PROT_PIO:
4589 if (qc->tf.flags & ATA_TFLAG_POLLING)
4590 ata_qc_set_polling(qc);
4591
Jeff Garzike5338252005-10-30 21:37:17 -05004592 ata_tf_to_host(ap, &qc->tf);
Albert Lee312f7da2005-09-27 17:38:03 +08004593
Albert Lee54f00382005-09-30 19:14:19 +08004594 if (qc->tf.flags & ATA_TFLAG_WRITE) {
4595 /* PIO data out protocol */
4596 ap->hsm_task_state = HSM_ST_FIRST;
Albert Lee31ce6da2006-04-03 18:31:44 +08004597 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Albert Lee54f00382005-09-30 19:14:19 +08004598
4599 /* always send first data block using
Albert Leee27486d2005-11-01 19:24:49 +08004600 * the ata_pio_task() codepath.
Albert Lee54f00382005-09-30 19:14:19 +08004601 */
Albert Lee312f7da2005-09-27 17:38:03 +08004602 } else {
Albert Lee54f00382005-09-30 19:14:19 +08004603 /* PIO data in protocol */
4604 ap->hsm_task_state = HSM_ST;
Albert Lee312f7da2005-09-27 17:38:03 +08004605
Albert Lee54f00382005-09-30 19:14:19 +08004606 if (qc->tf.flags & ATA_TFLAG_POLLING)
Albert Lee31ce6da2006-04-03 18:31:44 +08004607 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Albert Lee312f7da2005-09-27 17:38:03 +08004608
Albert Lee54f00382005-09-30 19:14:19 +08004609 /* if polling, ata_pio_task() handles the rest.
4610 * otherwise, interrupt handler takes over from here.
4611 */
Albert Lee312f7da2005-09-27 17:38:03 +08004612 }
4613
Linus Torvalds1da177e2005-04-16 15:20:36 -07004614 break;
4615
4616 case ATA_PROT_ATAPI:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004617 case ATA_PROT_ATAPI_NODATA:
Albert Lee312f7da2005-09-27 17:38:03 +08004618 if (qc->tf.flags & ATA_TFLAG_POLLING)
4619 ata_qc_set_polling(qc);
4620
Jeff Garzike5338252005-10-30 21:37:17 -05004621 ata_tf_to_host(ap, &qc->tf);
Jeff Garzikf6ef65e2006-01-27 02:45:00 -05004622
Albert Lee312f7da2005-09-27 17:38:03 +08004623 ap->hsm_task_state = HSM_ST_FIRST;
4624
4625 /* send cdb by polling if no cdb interrupt */
4626 if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
4627 (qc->tf.flags & ATA_TFLAG_POLLING))
Albert Lee31ce6da2006-04-03 18:31:44 +08004628 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004629 break;
4630
4631 case ATA_PROT_ATAPI_DMA:
Jeff Garzik587005d2006-02-11 18:17:32 -05004632 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
Albert Lee312f7da2005-09-27 17:38:03 +08004633
Linus Torvalds1da177e2005-04-16 15:20:36 -07004634 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4635 ap->ops->bmdma_setup(qc); /* set up bmdma */
Albert Lee312f7da2005-09-27 17:38:03 +08004636 ap->hsm_task_state = HSM_ST_FIRST;
4637
4638 /* send cdb by polling if no cdb interrupt */
4639 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
Albert Lee31ce6da2006-04-03 18:31:44 +08004640 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004641 break;
4642
4643 default:
4644 WARN_ON(1);
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004645 return AC_ERR_SYSTEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004646 }
4647
4648 return 0;
4649}
4650
4651/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004652 * ata_host_intr - Handle host interrupt for given (port, task)
4653 * @ap: Port on which interrupt arrived (possibly...)
4654 * @qc: Taskfile currently active in engine
4655 *
4656 * Handle host interrupt for given queued command. Currently,
4657 * only DMA interrupts are handled. All other commands are
4658 * handled via polling with interrupts disabled (nIEN bit).
4659 *
4660 * LOCKING:
4661 * spin_lock_irqsave(host_set lock)
4662 *
4663 * RETURNS:
4664 * One if interrupt was handled, zero if not (shared irq).
4665 */
4666
4667inline unsigned int ata_host_intr (struct ata_port *ap,
4668 struct ata_queued_cmd *qc)
4669{
Albert Lee312f7da2005-09-27 17:38:03 +08004670 u8 status, host_stat = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004671
Albert Lee312f7da2005-09-27 17:38:03 +08004672 VPRINTK("ata%u: protocol %d task_state %d\n",
4673 ap->id, qc->tf.protocol, ap->hsm_task_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004674
Albert Lee312f7da2005-09-27 17:38:03 +08004675 /* Check whether we are expecting interrupt in this state */
4676 switch (ap->hsm_task_state) {
4677 case HSM_ST_FIRST:
Albert Lee6912ccd2006-03-25 17:45:49 +08004678 /* Some pre-ATAPI-4 devices assert INTRQ
4679 * at this state when ready to receive CDB.
4680 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004681
Albert Lee312f7da2005-09-27 17:38:03 +08004682 /* Check the ATA_DFLAG_CDB_INTR flag is enough here.
4683 * The flag was turned on only for atapi devices.
4684 * No need to check is_atapi_taskfile(&qc->tf) again.
4685 */
4686 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004687 goto idle_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004688 break;
Albert Lee312f7da2005-09-27 17:38:03 +08004689 case HSM_ST_LAST:
4690 if (qc->tf.protocol == ATA_PROT_DMA ||
4691 qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
4692 /* check status of DMA engine */
4693 host_stat = ap->ops->bmdma_status(ap);
4694 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004695
Albert Lee312f7da2005-09-27 17:38:03 +08004696 /* if it's not our irq... */
4697 if (!(host_stat & ATA_DMA_INTR))
4698 goto idle_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004699
Albert Lee312f7da2005-09-27 17:38:03 +08004700 /* before we do anything else, clear DMA-Start bit */
4701 ap->ops->bmdma_stop(qc);
Albert Leea4f16612005-12-26 16:40:53 +08004702
4703 if (unlikely(host_stat & ATA_DMA_ERR)) {
4704 /* error when transfering data to/from memory */
4705 qc->err_mask |= AC_ERR_HOST_BUS;
4706 ap->hsm_task_state = HSM_ST_ERR;
4707 }
Albert Lee312f7da2005-09-27 17:38:03 +08004708 }
4709 break;
4710 case HSM_ST:
4711 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004712 default:
4713 goto idle_irq;
4714 }
4715
Albert Lee312f7da2005-09-27 17:38:03 +08004716 /* check altstatus */
4717 status = ata_altstatus(ap);
4718 if (status & ATA_BUSY)
4719 goto idle_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004720
Albert Lee312f7da2005-09-27 17:38:03 +08004721 /* check main status, clearing INTRQ */
4722 status = ata_chk_status(ap);
4723 if (unlikely(status & ATA_BUSY))
4724 goto idle_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004725
Albert Lee312f7da2005-09-27 17:38:03 +08004726 /* ack bmdma irq events */
4727 ap->ops->irq_clear(ap);
4728
Albert Leebb5cb292006-03-25 17:48:02 +08004729 ata_hsm_move(ap, qc, status, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004730 return 1; /* irq handled */
4731
4732idle_irq:
4733 ap->stats.idle_irq++;
4734
4735#ifdef ATA_IRQ_TRAP
4736 if ((ap->stats.idle_irq % 1000) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004737 ata_irq_ack(ap, 0); /* debug trap */
Tejun Heof15a1da2006-05-15 20:57:56 +09004738 ata_port_printk(ap, KERN_WARNING, "irq trap\n");
Alan Cox23cfce82006-03-21 16:06:53 +00004739 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004740 }
4741#endif
4742 return 0; /* irq not handled */
4743}
4744
4745/**
4746 * ata_interrupt - Default ATA host interrupt handler
Jeff Garzik0cba6322005-05-30 19:49:12 -04004747 * @irq: irq line (unused)
4748 * @dev_instance: pointer to our ata_host_set information structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004749 * @regs: unused
4750 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004751 * Default interrupt handler for PCI IDE devices. Calls
4752 * ata_host_intr() for each port that is not disabled.
4753 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004754 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004755 * Obtains host_set lock during operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004756 *
4757 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004758 * IRQ_NONE or IRQ_HANDLED.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004759 */
4760
4761irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
4762{
4763 struct ata_host_set *host_set = dev_instance;
4764 unsigned int i;
4765 unsigned int handled = 0;
4766 unsigned long flags;
4767
4768 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
4769 spin_lock_irqsave(&host_set->lock, flags);
4770
4771 for (i = 0; i < host_set->n_ports; i++) {
4772 struct ata_port *ap;
4773
4774 ap = host_set->ports[i];
Tejun Heoc1389502005-08-22 14:59:24 +09004775 if (ap &&
Jeff Garzik029f5462006-04-02 10:30:40 -04004776 !(ap->flags & ATA_FLAG_DISABLED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004777 struct ata_queued_cmd *qc;
4778
4779 qc = ata_qc_from_tag(ap, ap->active_tag);
Albert Lee312f7da2005-09-27 17:38:03 +08004780 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
Albert Lee21b1ed72005-04-29 17:34:59 +08004781 (qc->flags & ATA_QCFLAG_ACTIVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004782 handled |= ata_host_intr(ap, qc);
4783 }
4784 }
4785
4786 spin_unlock_irqrestore(&host_set->lock, flags);
4787
4788 return IRQ_RETVAL(handled);
4789}
4790
Tejun Heo34bf2172006-05-15 20:57:46 +09004791/**
4792 * sata_scr_valid - test whether SCRs are accessible
4793 * @ap: ATA port to test SCR accessibility for
4794 *
4795 * Test whether SCRs are accessible for @ap.
4796 *
4797 * LOCKING:
4798 * None.
4799 *
4800 * RETURNS:
4801 * 1 if SCRs are accessible, 0 otherwise.
4802 */
4803int sata_scr_valid(struct ata_port *ap)
4804{
4805 return ap->cbl == ATA_CBL_SATA && ap->ops->scr_read;
4806}
4807
4808/**
4809 * sata_scr_read - read SCR register of the specified port
4810 * @ap: ATA port to read SCR for
4811 * @reg: SCR to read
4812 * @val: Place to store read value
4813 *
4814 * Read SCR register @reg of @ap into *@val. This function is
4815 * guaranteed to succeed if the cable type of the port is SATA
4816 * and the port implements ->scr_read.
4817 *
4818 * LOCKING:
4819 * None.
4820 *
4821 * RETURNS:
4822 * 0 on success, negative errno on failure.
4823 */
4824int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
4825{
4826 if (sata_scr_valid(ap)) {
4827 *val = ap->ops->scr_read(ap, reg);
4828 return 0;
4829 }
4830 return -EOPNOTSUPP;
4831}
4832
4833/**
4834 * sata_scr_write - write SCR register of the specified port
4835 * @ap: ATA port to write SCR for
4836 * @reg: SCR to write
4837 * @val: value to write
4838 *
4839 * Write @val to SCR register @reg of @ap. This function is
4840 * guaranteed to succeed if the cable type of the port is SATA
4841 * and the port implements ->scr_read.
4842 *
4843 * LOCKING:
4844 * None.
4845 *
4846 * RETURNS:
4847 * 0 on success, negative errno on failure.
4848 */
4849int sata_scr_write(struct ata_port *ap, int reg, u32 val)
4850{
4851 if (sata_scr_valid(ap)) {
4852 ap->ops->scr_write(ap, reg, val);
4853 return 0;
4854 }
4855 return -EOPNOTSUPP;
4856}
4857
4858/**
4859 * sata_scr_write_flush - write SCR register of the specified port and flush
4860 * @ap: ATA port to write SCR for
4861 * @reg: SCR to write
4862 * @val: value to write
4863 *
4864 * This function is identical to sata_scr_write() except that this
4865 * function performs flush after writing to the register.
4866 *
4867 * LOCKING:
4868 * None.
4869 *
4870 * RETURNS:
4871 * 0 on success, negative errno on failure.
4872 */
4873int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
4874{
4875 if (sata_scr_valid(ap)) {
4876 ap->ops->scr_write(ap, reg, val);
4877 ap->ops->scr_read(ap, reg);
4878 return 0;
4879 }
4880 return -EOPNOTSUPP;
4881}
4882
4883/**
4884 * ata_port_online - test whether the given port is online
4885 * @ap: ATA port to test
4886 *
4887 * Test whether @ap is online. Note that this function returns 0
4888 * if online status of @ap cannot be obtained, so
4889 * ata_port_online(ap) != !ata_port_offline(ap).
4890 *
4891 * LOCKING:
4892 * None.
4893 *
4894 * RETURNS:
4895 * 1 if the port online status is available and online.
4896 */
4897int ata_port_online(struct ata_port *ap)
4898{
4899 u32 sstatus;
4900
4901 if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) == 0x3)
4902 return 1;
4903 return 0;
4904}
4905
4906/**
4907 * ata_port_offline - test whether the given port is offline
4908 * @ap: ATA port to test
4909 *
4910 * Test whether @ap is offline. Note that this function returns
4911 * 0 if offline status of @ap cannot be obtained, so
4912 * ata_port_online(ap) != !ata_port_offline(ap).
4913 *
4914 * LOCKING:
4915 * None.
4916 *
4917 * RETURNS:
4918 * 1 if the port offline status is available and offline.
4919 */
4920int ata_port_offline(struct ata_port *ap)
4921{
4922 u32 sstatus;
4923
4924 if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) != 0x3)
4925 return 1;
4926 return 0;
4927}
Edward Falk0baab862005-06-02 18:17:13 -04004928
Jens Axboe9b847542006-01-06 09:28:07 +01004929/*
4930 * Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
4931 * without filling any other registers
4932 */
Tejun Heo3373efd2006-05-15 20:57:53 +09004933static int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
Jens Axboe9b847542006-01-06 09:28:07 +01004934{
4935 struct ata_taskfile tf;
4936 int err;
4937
Tejun Heo3373efd2006-05-15 20:57:53 +09004938 ata_tf_init(dev, &tf);
Jens Axboe9b847542006-01-06 09:28:07 +01004939
4940 tf.command = cmd;
4941 tf.flags |= ATA_TFLAG_DEVICE;
4942 tf.protocol = ATA_PROT_NODATA;
4943
Tejun Heo3373efd2006-05-15 20:57:53 +09004944 err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
Jens Axboe9b847542006-01-06 09:28:07 +01004945 if (err)
Tejun Heof15a1da2006-05-15 20:57:56 +09004946 ata_dev_printk(dev, KERN_ERR, "%s: ata command failed: %d\n",
4947 __FUNCTION__, err);
Jens Axboe9b847542006-01-06 09:28:07 +01004948
4949 return err;
4950}
4951
Tejun Heo3373efd2006-05-15 20:57:53 +09004952static int ata_flush_cache(struct ata_device *dev)
Jens Axboe9b847542006-01-06 09:28:07 +01004953{
4954 u8 cmd;
4955
4956 if (!ata_try_flush_cache(dev))
4957 return 0;
4958
4959 if (ata_id_has_flush_ext(dev->id))
4960 cmd = ATA_CMD_FLUSH_EXT;
4961 else
4962 cmd = ATA_CMD_FLUSH;
4963
Tejun Heo3373efd2006-05-15 20:57:53 +09004964 return ata_do_simple_cmd(dev, cmd);
Jens Axboe9b847542006-01-06 09:28:07 +01004965}
4966
Tejun Heo3373efd2006-05-15 20:57:53 +09004967static int ata_standby_drive(struct ata_device *dev)
Jens Axboe9b847542006-01-06 09:28:07 +01004968{
Tejun Heo3373efd2006-05-15 20:57:53 +09004969 return ata_do_simple_cmd(dev, ATA_CMD_STANDBYNOW1);
Jens Axboe9b847542006-01-06 09:28:07 +01004970}
4971
Tejun Heo3373efd2006-05-15 20:57:53 +09004972static int ata_start_drive(struct ata_device *dev)
Jens Axboe9b847542006-01-06 09:28:07 +01004973{
Tejun Heo3373efd2006-05-15 20:57:53 +09004974 return ata_do_simple_cmd(dev, ATA_CMD_IDLEIMMEDIATE);
Jens Axboe9b847542006-01-06 09:28:07 +01004975}
4976
4977/**
4978 * ata_device_resume - wakeup a previously suspended devices
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004979 * @dev: the device to resume
Jens Axboe9b847542006-01-06 09:28:07 +01004980 *
4981 * Kick the drive back into action, by sending it an idle immediate
4982 * command and making sure its transfer mode matches between drive
4983 * and host.
4984 *
4985 */
Tejun Heo3373efd2006-05-15 20:57:53 +09004986int ata_device_resume(struct ata_device *dev)
Jens Axboe9b847542006-01-06 09:28:07 +01004987{
Tejun Heo3373efd2006-05-15 20:57:53 +09004988 struct ata_port *ap = dev->ap;
4989
Jens Axboe9b847542006-01-06 09:28:07 +01004990 if (ap->flags & ATA_FLAG_SUSPENDED) {
Tejun Heoe82cbdb2006-04-01 01:38:18 +09004991 struct ata_device *failed_dev;
Jeff Garzike42d7be2006-05-28 16:32:59 -04004992
Mark Lord0737ac82006-05-28 11:28:00 -04004993 ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 200000);
Jeff Garzike42d7be2006-05-28 16:32:59 -04004994
Jens Axboe9b847542006-01-06 09:28:07 +01004995 ap->flags &= ~ATA_FLAG_SUSPENDED;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09004996 while (ata_set_mode(ap, &failed_dev))
Tejun Heo3373efd2006-05-15 20:57:53 +09004997 ata_dev_disable(failed_dev);
Jens Axboe9b847542006-01-06 09:28:07 +01004998 }
Tejun Heoe1211e32006-04-01 01:38:18 +09004999 if (!ata_dev_enabled(dev))
Jens Axboe9b847542006-01-06 09:28:07 +01005000 return 0;
5001 if (dev->class == ATA_DEV_ATA)
Tejun Heo3373efd2006-05-15 20:57:53 +09005002 ata_start_drive(dev);
Jens Axboe9b847542006-01-06 09:28:07 +01005003
5004 return 0;
5005}
5006
5007/**
5008 * ata_device_suspend - prepare a device for suspend
Randy Dunlapc893a3a2006-01-28 13:15:32 -05005009 * @dev: the device to suspend
Randy Dunlape2a7f772006-05-18 10:50:18 -07005010 * @state: target power management state
Jens Axboe9b847542006-01-06 09:28:07 +01005011 *
5012 * Flush the cache on the drive, if appropriate, then issue a
5013 * standbynow command.
Jens Axboe9b847542006-01-06 09:28:07 +01005014 */
Tejun Heo3373efd2006-05-15 20:57:53 +09005015int ata_device_suspend(struct ata_device *dev, pm_message_t state)
Jens Axboe9b847542006-01-06 09:28:07 +01005016{
Tejun Heo3373efd2006-05-15 20:57:53 +09005017 struct ata_port *ap = dev->ap;
5018
Tejun Heoe1211e32006-04-01 01:38:18 +09005019 if (!ata_dev_enabled(dev))
Jens Axboe9b847542006-01-06 09:28:07 +01005020 return 0;
5021 if (dev->class == ATA_DEV_ATA)
Tejun Heo3373efd2006-05-15 20:57:53 +09005022 ata_flush_cache(dev);
Jens Axboe9b847542006-01-06 09:28:07 +01005023
Nigel Cunningham082776e2006-03-23 23:22:16 +10005024 if (state.event != PM_EVENT_FREEZE)
Tejun Heo3373efd2006-05-15 20:57:53 +09005025 ata_standby_drive(dev);
Jens Axboe9b847542006-01-06 09:28:07 +01005026 ap->flags |= ATA_FLAG_SUSPENDED;
5027 return 0;
5028}
5029
Randy Dunlapc893a3a2006-01-28 13:15:32 -05005030/**
5031 * ata_port_start - Set port up for dma.
5032 * @ap: Port to initialize
5033 *
5034 * Called just after data structures for each port are
5035 * initialized. Allocates space for PRD table.
5036 *
5037 * May be used as the port_start() entry in ata_port_operations.
5038 *
5039 * LOCKING:
5040 * Inherited from caller.
5041 */
5042
Linus Torvalds1da177e2005-04-16 15:20:36 -07005043int ata_port_start (struct ata_port *ap)
5044{
Brian King2f1f6102006-03-23 17:30:15 -06005045 struct device *dev = ap->dev;
Jeff Garzik6037d6b2005-11-04 22:08:00 -05005046 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005047
5048 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
5049 if (!ap->prd)
5050 return -ENOMEM;
5051
Jeff Garzik6037d6b2005-11-04 22:08:00 -05005052 rc = ata_pad_alloc(ap, dev);
5053 if (rc) {
Jeff Garzikcedc9a42005-10-05 07:13:30 -04005054 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05005055 return rc;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04005056 }
5057
Linus Torvalds1da177e2005-04-16 15:20:36 -07005058 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
5059
5060 return 0;
5061}
5062
Edward Falk0baab862005-06-02 18:17:13 -04005063
5064/**
5065 * ata_port_stop - Undo ata_port_start()
5066 * @ap: Port to shut down
5067 *
5068 * Frees the PRD table.
5069 *
5070 * May be used as the port_stop() entry in ata_port_operations.
5071 *
5072 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04005073 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04005074 */
5075
Linus Torvalds1da177e2005-04-16 15:20:36 -07005076void ata_port_stop (struct ata_port *ap)
5077{
Brian King2f1f6102006-03-23 17:30:15 -06005078 struct device *dev = ap->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005079
5080 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05005081 ata_pad_free(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005082}
5083
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04005084void ata_host_stop (struct ata_host_set *host_set)
5085{
5086 if (host_set->mmio_base)
5087 iounmap(host_set->mmio_base);
5088}
5089
5090
Linus Torvalds1da177e2005-04-16 15:20:36 -07005091/**
5092 * ata_host_remove - Unregister SCSI host structure with upper layers
5093 * @ap: Port to unregister
5094 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
5095 *
5096 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04005097 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005098 */
5099
5100static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
5101{
5102 struct Scsi_Host *sh = ap->host;
5103
5104 DPRINTK("ENTER\n");
5105
5106 if (do_unregister)
5107 scsi_remove_host(sh);
5108
5109 ap->ops->port_stop(ap);
5110}
5111
5112/**
Tejun Heo3ef3b432006-05-31 18:27:30 +09005113 * ata_dev_init - Initialize an ata_device structure
5114 * @dev: Device structure to initialize
5115 *
5116 * Initialize @dev in preparation for probing.
5117 *
5118 * LOCKING:
5119 * Inherited from caller.
5120 */
5121void ata_dev_init(struct ata_device *dev)
5122{
5123 struct ata_port *ap = dev->ap;
Tejun Heo72fa4b72006-05-31 18:27:32 +09005124 unsigned long flags;
Tejun Heo3ef3b432006-05-31 18:27:30 +09005125
Tejun Heo5a04bf42006-05-31 18:27:38 +09005126 /* SATA spd limit is bound to the first device */
5127 ap->sata_spd_limit = ap->hw_sata_spd_limit;
5128
Tejun Heo72fa4b72006-05-31 18:27:32 +09005129 /* High bits of dev->flags are used to record warm plug
5130 * requests which occur asynchronously. Synchronize using
5131 * host_set lock.
5132 */
5133 spin_lock_irqsave(&ap->host_set->lock, flags);
5134 dev->flags &= ~ATA_DFLAG_INIT_MASK;
5135 spin_unlock_irqrestore(&ap->host_set->lock, flags);
5136
5137 memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0,
5138 sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET);
Tejun Heo3ef3b432006-05-31 18:27:30 +09005139 dev->pio_mask = UINT_MAX;
5140 dev->mwdma_mask = UINT_MAX;
5141 dev->udma_mask = UINT_MAX;
5142}
5143
5144/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07005145 * ata_host_init - Initialize an ata_port structure
5146 * @ap: Structure to initialize
5147 * @host: associated SCSI mid-layer structure
5148 * @host_set: Collection of hosts to which @ap belongs
5149 * @ent: Probe information provided by low-level driver
5150 * @port_no: Port number associated with this ata_port
5151 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04005152 * Initialize a new ata_port structure, and its associated
5153 * scsi_host.
5154 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07005155 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04005156 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005157 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005158static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
5159 struct ata_host_set *host_set,
Jeff Garzik057ace52005-10-22 14:27:05 -04005160 const struct ata_probe_ent *ent, unsigned int port_no)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005161{
5162 unsigned int i;
5163
5164 host->max_id = 16;
5165 host->max_lun = 1;
5166 host->max_channel = 1;
5167 host->unique_id = ata_unique_id++;
5168 host->max_cmd_len = 12;
Christoph Hellwig12413192005-06-11 01:05:01 +02005169
Tejun Heo198e0fe2006-04-02 18:51:52 +09005170 ap->flags = ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005171 ap->id = host->unique_id;
5172 ap->host = host;
5173 ap->ctl = ATA_DEVCTL_OBS;
5174 ap->host_set = host_set;
Brian King2f1f6102006-03-23 17:30:15 -06005175 ap->dev = ent->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005176 ap->port_no = port_no;
5177 ap->hard_port_no =
5178 ent->legacy_mode ? ent->hard_port_no : port_no;
5179 ap->pio_mask = ent->pio_mask;
5180 ap->mwdma_mask = ent->mwdma_mask;
5181 ap->udma_mask = ent->udma_mask;
5182 ap->flags |= ent->host_flags;
5183 ap->ops = ent->port_ops;
Tejun Heo5a04bf42006-05-31 18:27:38 +09005184 ap->hw_sata_spd_limit = UINT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005185 ap->active_tag = ATA_TAG_POISON;
5186 ap->last_ctl = 0xFF;
Borislav Petkovbd5d8252006-06-11 23:17:01 -04005187
5188#if defined(ATA_VERBOSE_DEBUG)
5189 /* turn on all debugging levels */
5190 ap->msg_enable = 0x00FF;
5191#elif defined(ATA_DEBUG)
5192 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
5193#else
5194 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR;
5195#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07005196
Tejun Heo86e45b62006-03-05 15:29:09 +09005197 INIT_WORK(&ap->port_task, NULL, NULL);
Tejun Heo580b21022006-05-31 18:28:05 +09005198 INIT_WORK(&ap->hotplug_task, ata_scsi_hotplug, ap);
zhao, forrest3057ac32006-06-12 12:01:34 +08005199 INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan, ap);
Tejun Heoa72ec4c2006-01-23 13:09:37 +09005200 INIT_LIST_HEAD(&ap->eh_done_q);
Tejun Heoc6cf9e92006-05-31 18:27:27 +09005201 init_waitqueue_head(&ap->eh_wait_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005202
Tejun Heo838df622006-05-15 20:57:44 +09005203 /* set cable type */
5204 ap->cbl = ATA_CBL_NONE;
5205 if (ap->flags & ATA_FLAG_SATA)
5206 ap->cbl = ATA_CBL_SATA;
5207
Tejun Heoacf356b2006-03-24 14:07:50 +09005208 for (i = 0; i < ATA_MAX_DEVICES; i++) {
5209 struct ata_device *dev = &ap->device[i];
Tejun Heo38d87232006-05-15 20:57:51 +09005210 dev->ap = ap;
Tejun Heo72fa4b72006-05-31 18:27:32 +09005211 dev->devno = i;
Tejun Heo3ef3b432006-05-31 18:27:30 +09005212 ata_dev_init(dev);
Tejun Heoacf356b2006-03-24 14:07:50 +09005213 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005214
5215#ifdef ATA_IRQ_TRAP
5216 ap->stats.unhandled_irq = 1;
5217 ap->stats.idle_irq = 1;
5218#endif
5219
5220 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
5221}
5222
5223/**
5224 * ata_host_add - Attach low-level ATA driver to system
5225 * @ent: Information provided by low-level driver
5226 * @host_set: Collections of ports to which we add
5227 * @port_no: Port number associated with this host
5228 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04005229 * Attach low-level ATA driver to system.
5230 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07005231 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04005232 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005233 *
5234 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04005235 * New ata_port on success, for NULL on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005236 */
5237
Jeff Garzik057ace52005-10-22 14:27:05 -04005238static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005239 struct ata_host_set *host_set,
5240 unsigned int port_no)
5241{
5242 struct Scsi_Host *host;
5243 struct ata_port *ap;
5244 int rc;
5245
5246 DPRINTK("ENTER\n");
Tejun Heoaec5c3c2006-03-25 01:33:34 +09005247
Tejun Heo52783c52006-05-31 18:28:22 +09005248 if (!ent->port_ops->error_handler &&
Tejun Heoaec5c3c2006-03-25 01:33:34 +09005249 !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
5250 printk(KERN_ERR "ata%u: no reset mechanism available\n",
5251 port_no);
5252 return NULL;
5253 }
5254
Linus Torvalds1da177e2005-04-16 15:20:36 -07005255 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
5256 if (!host)
5257 return NULL;
5258
Tejun Heo30afc842006-03-18 18:40:14 +09005259 host->transportt = &ata_scsi_transport_template;
5260
Jeff Garzik35bb94b2006-04-11 13:12:34 -04005261 ap = ata_shost_to_port(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005262
5263 ata_host_init(ap, host, host_set, ent, port_no);
5264
5265 rc = ap->ops->port_start(ap);
5266 if (rc)
5267 goto err_out;
5268
5269 return ap;
5270
5271err_out:
5272 scsi_host_put(host);
5273 return NULL;
5274}
5275
5276/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04005277 * ata_device_add - Register hardware device with ATA and SCSI layers
5278 * @ent: Probe information describing hardware device to be registered
5279 *
5280 * This function processes the information provided in the probe
5281 * information struct @ent, allocates the necessary ATA and SCSI
5282 * host information structures, initializes them, and registers
5283 * everything with requisite kernel subsystems.
5284 *
5285 * This function requests irqs, probes the ATA bus, and probes
5286 * the SCSI bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005287 *
5288 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04005289 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005290 *
5291 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04005292 * Number of ports registered. Zero on error (no ports registered).
Linus Torvalds1da177e2005-04-16 15:20:36 -07005293 */
Jeff Garzik057ace52005-10-22 14:27:05 -04005294int ata_device_add(const struct ata_probe_ent *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005295{
5296 unsigned int count = 0, i;
5297 struct device *dev = ent->dev;
5298 struct ata_host_set *host_set;
Jeff Garzik39b07ce2006-06-11 23:59:44 -04005299 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005300
5301 DPRINTK("ENTER\n");
5302 /* alloc a container for our list of ATA ports (buses) */
Randy Dunlap57f3bda2005-10-28 20:37:23 -07005303 host_set = kzalloc(sizeof(struct ata_host_set) +
Linus Torvalds1da177e2005-04-16 15:20:36 -07005304 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
5305 if (!host_set)
5306 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005307 spin_lock_init(&host_set->lock);
5308
5309 host_set->dev = dev;
5310 host_set->n_ports = ent->n_ports;
5311 host_set->irq = ent->irq;
5312 host_set->mmio_base = ent->mmio_base;
5313 host_set->private_data = ent->private_data;
5314 host_set->ops = ent->port_ops;
Alan Cox5444a6f2006-03-27 18:58:20 +01005315 host_set->flags = ent->host_set_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005316
5317 /* register each port bound to this device */
5318 for (i = 0; i < ent->n_ports; i++) {
5319 struct ata_port *ap;
5320 unsigned long xfer_mode_mask;
5321
5322 ap = ata_host_add(ent, host_set, i);
5323 if (!ap)
5324 goto err_out;
5325
5326 host_set->ports[i] = ap;
5327 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
5328 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
5329 (ap->pio_mask << ATA_SHIFT_PIO);
5330
5331 /* print per-port info to dmesg */
Tejun Heof15a1da2006-05-15 20:57:56 +09005332 ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%lX "
5333 "ctl 0x%lX bmdma 0x%lX irq %lu\n",
5334 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
5335 ata_mode_string(xfer_mode_mask),
5336 ap->ioaddr.cmd_addr,
5337 ap->ioaddr.ctl_addr,
5338 ap->ioaddr.bmdma_addr,
5339 ent->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005340
5341 ata_chk_status(ap);
5342 host_set->ops->irq_clear(ap);
Tejun Heoe3180492006-05-15 20:58:09 +09005343 ata_eh_freeze_port(ap); /* freeze port before requesting IRQ */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005344 count++;
5345 }
5346
Randy Dunlap57f3bda2005-10-28 20:37:23 -07005347 if (!count)
5348 goto err_free_ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005349
5350 /* obtain irq, that is shared between channels */
Jeff Garzik39b07ce2006-06-11 23:59:44 -04005351 rc = request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
5352 DRV_NAME, host_set);
5353 if (rc) {
5354 dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n",
5355 ent->irq, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005356 goto err_out;
Jeff Garzik39b07ce2006-06-11 23:59:44 -04005357 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005358
5359 /* perform each probe synchronously */
5360 DPRINTK("probe begin\n");
5361 for (i = 0; i < count; i++) {
5362 struct ata_port *ap;
Tejun Heo5a04bf42006-05-31 18:27:38 +09005363 u32 scontrol;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005364 int rc;
5365
5366 ap = host_set->ports[i];
5367
Tejun Heo5a04bf42006-05-31 18:27:38 +09005368 /* init sata_spd_limit to the current value */
5369 if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
5370 int spd = (scontrol >> 4) & 0xf;
5371 ap->hw_sata_spd_limit &= (1 << spd) - 1;
5372 }
5373 ap->sata_spd_limit = ap->hw_sata_spd_limit;
5374
Linus Torvalds1da177e2005-04-16 15:20:36 -07005375 rc = scsi_add_host(ap->host, dev);
5376 if (rc) {
Tejun Heof15a1da2006-05-15 20:57:56 +09005377 ata_port_printk(ap, KERN_ERR, "scsi_add_host failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005378 /* FIXME: do something useful here */
5379 /* FIXME: handle unconditional calls to
5380 * scsi_scan_host and ata_host_remove, below,
5381 * at the very least
5382 */
5383 }
Tejun Heo3e706392006-05-31 18:28:11 +09005384
Tejun Heo52783c52006-05-31 18:28:22 +09005385 if (ap->ops->error_handler) {
Tejun Heo3e706392006-05-31 18:28:11 +09005386 unsigned long flags;
5387
5388 ata_port_probe(ap);
5389
5390 /* kick EH for boot probing */
5391 spin_lock_irqsave(&ap->host_set->lock, flags);
5392
5393 ap->eh_info.probe_mask = (1 << ATA_MAX_DEVICES) - 1;
5394 ap->eh_info.action |= ATA_EH_SOFTRESET;
5395
5396 ap->flags |= ATA_FLAG_LOADING;
5397 ata_port_schedule_eh(ap);
5398
5399 spin_unlock_irqrestore(&ap->host_set->lock, flags);
5400
5401 /* wait for EH to finish */
5402 ata_port_wait_eh(ap);
5403 } else {
5404 DPRINTK("ata%u: bus probe begin\n", ap->id);
5405 rc = ata_bus_probe(ap);
5406 DPRINTK("ata%u: bus probe end\n", ap->id);
5407
5408 if (rc) {
5409 /* FIXME: do something useful here?
5410 * Current libata behavior will
5411 * tear down everything when
5412 * the module is removed
5413 * or the h/w is unplugged.
5414 */
5415 }
5416 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005417 }
5418
5419 /* probes are done, now scan each port's disk(s) */
Randy Dunlapc893a3a2006-01-28 13:15:32 -05005420 DPRINTK("host probe begin\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005421 for (i = 0; i < count; i++) {
5422 struct ata_port *ap = host_set->ports[i];
5423
Jeff Garzik644dd0c2005-10-03 15:55:19 -04005424 ata_scsi_scan_host(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005425 }
5426
5427 dev_set_drvdata(dev, host_set);
5428
5429 VPRINTK("EXIT, returning %u\n", ent->n_ports);
5430 return ent->n_ports; /* success */
5431
5432err_out:
5433 for (i = 0; i < count; i++) {
5434 ata_host_remove(host_set->ports[i], 1);
5435 scsi_host_put(host_set->ports[i]->host);
5436 }
Randy Dunlap57f3bda2005-10-28 20:37:23 -07005437err_free_ret:
Linus Torvalds1da177e2005-04-16 15:20:36 -07005438 kfree(host_set);
5439 VPRINTK("EXIT, returning 0\n");
5440 return 0;
5441}
5442
5443/**
Tejun Heo720ba122006-05-31 18:28:13 +09005444 * ata_port_detach - Detach ATA port in prepration of device removal
5445 * @ap: ATA port to be detached
5446 *
5447 * Detach all ATA devices and the associated SCSI devices of @ap;
5448 * then, remove the associated SCSI host. @ap is guaranteed to
5449 * be quiescent on return from this function.
5450 *
5451 * LOCKING:
5452 * Kernel thread context (may sleep).
5453 */
5454void ata_port_detach(struct ata_port *ap)
5455{
5456 unsigned long flags;
5457 int i;
5458
5459 if (!ap->ops->error_handler)
5460 return;
5461
5462 /* tell EH we're leaving & flush EH */
5463 spin_lock_irqsave(&ap->host_set->lock, flags);
5464 ap->flags |= ATA_FLAG_UNLOADING;
5465 spin_unlock_irqrestore(&ap->host_set->lock, flags);
5466
5467 ata_port_wait_eh(ap);
5468
5469 /* EH is now guaranteed to see UNLOADING, so no new device
5470 * will be attached. Disable all existing devices.
5471 */
5472 spin_lock_irqsave(&ap->host_set->lock, flags);
5473
5474 for (i = 0; i < ATA_MAX_DEVICES; i++)
5475 ata_dev_disable(&ap->device[i]);
5476
5477 spin_unlock_irqrestore(&ap->host_set->lock, flags);
5478
5479 /* Final freeze & EH. All in-flight commands are aborted. EH
5480 * will be skipped and retrials will be terminated with bad
5481 * target.
5482 */
5483 spin_lock_irqsave(&ap->host_set->lock, flags);
5484 ata_port_freeze(ap); /* won't be thawed */
5485 spin_unlock_irqrestore(&ap->host_set->lock, flags);
5486
5487 ata_port_wait_eh(ap);
5488
5489 /* Flush hotplug task. The sequence is similar to
5490 * ata_port_flush_task().
5491 */
5492 flush_workqueue(ata_aux_wq);
5493 cancel_delayed_work(&ap->hotplug_task);
5494 flush_workqueue(ata_aux_wq);
5495
5496 /* remove the associated SCSI host */
5497 scsi_remove_host(ap->host);
5498}
5499
5500/**
Alan Cox17b14452005-09-15 15:44:00 +01005501 * ata_host_set_remove - PCI layer callback for device removal
5502 * @host_set: ATA host set that was removed
5503 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05005504 * Unregister all objects associated with this host set. Free those
Alan Cox17b14452005-09-15 15:44:00 +01005505 * objects.
5506 *
5507 * LOCKING:
5508 * Inherited from calling layer (may sleep).
5509 */
5510
Alan Cox17b14452005-09-15 15:44:00 +01005511void ata_host_set_remove(struct ata_host_set *host_set)
5512{
Alan Cox17b14452005-09-15 15:44:00 +01005513 unsigned int i;
5514
Tejun Heo720ba122006-05-31 18:28:13 +09005515 for (i = 0; i < host_set->n_ports; i++)
5516 ata_port_detach(host_set->ports[i]);
Alan Cox17b14452005-09-15 15:44:00 +01005517
5518 free_irq(host_set->irq, host_set);
5519
5520 for (i = 0; i < host_set->n_ports; i++) {
Tejun Heo720ba122006-05-31 18:28:13 +09005521 struct ata_port *ap = host_set->ports[i];
Alan Cox17b14452005-09-15 15:44:00 +01005522
5523 ata_scsi_release(ap->host);
5524
5525 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
5526 struct ata_ioports *ioaddr = &ap->ioaddr;
5527
5528 if (ioaddr->cmd_addr == 0x1f0)
5529 release_region(0x1f0, 8);
5530 else if (ioaddr->cmd_addr == 0x170)
5531 release_region(0x170, 8);
5532 }
5533
5534 scsi_host_put(ap->host);
5535 }
5536
5537 if (host_set->ops->host_stop)
5538 host_set->ops->host_stop(host_set);
5539
5540 kfree(host_set);
5541}
5542
5543/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07005544 * ata_scsi_release - SCSI layer callback hook for host unload
5545 * @host: libata host to be unloaded
5546 *
5547 * Performs all duties necessary to shut down a libata port...
5548 * Kill port kthread, disable port, and release resources.
5549 *
5550 * LOCKING:
5551 * Inherited from SCSI layer.
5552 *
5553 * RETURNS:
5554 * One.
5555 */
5556
5557int ata_scsi_release(struct Scsi_Host *host)
5558{
Jeff Garzik35bb94b2006-04-11 13:12:34 -04005559 struct ata_port *ap = ata_shost_to_port(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005560
5561 DPRINTK("ENTER\n");
5562
5563 ap->ops->port_disable(ap);
5564 ata_host_remove(ap, 0);
5565
5566 DPRINTK("EXIT\n");
5567 return 1;
5568}
5569
5570/**
5571 * ata_std_ports - initialize ioaddr with standard port offsets.
5572 * @ioaddr: IO address structure to be initialized
Edward Falk0baab862005-06-02 18:17:13 -04005573 *
5574 * Utility function which initializes data_addr, error_addr,
5575 * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
5576 * device_addr, status_addr, and command_addr to standard offsets
5577 * relative to cmd_addr.
5578 *
5579 * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005580 */
Edward Falk0baab862005-06-02 18:17:13 -04005581
Linus Torvalds1da177e2005-04-16 15:20:36 -07005582void ata_std_ports(struct ata_ioports *ioaddr)
5583{
5584 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
5585 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
5586 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
5587 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
5588 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
5589 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
5590 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
5591 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
5592 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
5593 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
5594}
5595
Edward Falk0baab862005-06-02 18:17:13 -04005596
Jeff Garzik374b1872005-08-30 05:42:52 -04005597#ifdef CONFIG_PCI
5598
5599void ata_pci_host_stop (struct ata_host_set *host_set)
5600{
5601 struct pci_dev *pdev = to_pci_dev(host_set->dev);
5602
5603 pci_iounmap(pdev, host_set->mmio_base);
5604}
5605
Edward Falk0baab862005-06-02 18:17:13 -04005606/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07005607 * ata_pci_remove_one - PCI layer callback for device removal
5608 * @pdev: PCI device that was removed
5609 *
5610 * PCI layer indicates to libata via this hook that
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04005611 * hot-unplug or module unload event has occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005612 * Handle this by unregistering all objects associated
5613 * with this PCI device. Free those objects. Then finally
5614 * release PCI resources and disable device.
5615 *
5616 * LOCKING:
5617 * Inherited from PCI layer (may sleep).
5618 */
5619
5620void ata_pci_remove_one (struct pci_dev *pdev)
5621{
5622 struct device *dev = pci_dev_to_dev(pdev);
5623 struct ata_host_set *host_set = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005624
Alan Cox17b14452005-09-15 15:44:00 +01005625 ata_host_set_remove(host_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005626 pci_release_regions(pdev);
5627 pci_disable_device(pdev);
5628 dev_set_drvdata(dev, NULL);
5629}
5630
5631/* move to PCI subsystem */
Jeff Garzik057ace52005-10-22 14:27:05 -04005632int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005633{
5634 unsigned long tmp = 0;
5635
5636 switch (bits->width) {
5637 case 1: {
5638 u8 tmp8 = 0;
5639 pci_read_config_byte(pdev, bits->reg, &tmp8);
5640 tmp = tmp8;
5641 break;
5642 }
5643 case 2: {
5644 u16 tmp16 = 0;
5645 pci_read_config_word(pdev, bits->reg, &tmp16);
5646 tmp = tmp16;
5647 break;
5648 }
5649 case 4: {
5650 u32 tmp32 = 0;
5651 pci_read_config_dword(pdev, bits->reg, &tmp32);
5652 tmp = tmp32;
5653 break;
5654 }
5655
5656 default:
5657 return -EINVAL;
5658 }
5659
5660 tmp &= bits->mask;
5661
5662 return (tmp == bits->val) ? 1 : 0;
5663}
Jens Axboe9b847542006-01-06 09:28:07 +01005664
5665int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state)
5666{
5667 pci_save_state(pdev);
5668 pci_disable_device(pdev);
5669 pci_set_power_state(pdev, PCI_D3hot);
5670 return 0;
5671}
5672
5673int ata_pci_device_resume(struct pci_dev *pdev)
5674{
5675 pci_set_power_state(pdev, PCI_D0);
5676 pci_restore_state(pdev);
5677 pci_enable_device(pdev);
5678 pci_set_master(pdev);
5679 return 0;
5680}
Linus Torvalds1da177e2005-04-16 15:20:36 -07005681#endif /* CONFIG_PCI */
5682
5683
Linus Torvalds1da177e2005-04-16 15:20:36 -07005684static int __init ata_init(void)
5685{
5686 ata_wq = create_workqueue("ata");
5687 if (!ata_wq)
5688 return -ENOMEM;
5689
Tejun Heo453b07a2006-05-31 18:27:42 +09005690 ata_aux_wq = create_singlethread_workqueue("ata_aux");
5691 if (!ata_aux_wq) {
5692 destroy_workqueue(ata_wq);
5693 return -ENOMEM;
5694 }
5695
Linus Torvalds1da177e2005-04-16 15:20:36 -07005696 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
5697 return 0;
5698}
5699
5700static void __exit ata_exit(void)
5701{
5702 destroy_workqueue(ata_wq);
Tejun Heo453b07a2006-05-31 18:27:42 +09005703 destroy_workqueue(ata_aux_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005704}
5705
5706module_init(ata_init);
5707module_exit(ata_exit);
5708
Jeff Garzik67846b32005-10-05 02:58:32 -04005709static unsigned long ratelimit_time;
5710static spinlock_t ata_ratelimit_lock = SPIN_LOCK_UNLOCKED;
5711
5712int ata_ratelimit(void)
5713{
5714 int rc;
5715 unsigned long flags;
5716
5717 spin_lock_irqsave(&ata_ratelimit_lock, flags);
5718
5719 if (time_after(jiffies, ratelimit_time)) {
5720 rc = 1;
5721 ratelimit_time = jiffies + (HZ/5);
5722 } else
5723 rc = 0;
5724
5725 spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
5726
5727 return rc;
5728}
5729
Tejun Heoc22daff2006-04-11 22:22:29 +09005730/**
5731 * ata_wait_register - wait until register value changes
5732 * @reg: IO-mapped register
5733 * @mask: Mask to apply to read register value
5734 * @val: Wait condition
5735 * @interval_msec: polling interval in milliseconds
5736 * @timeout_msec: timeout in milliseconds
5737 *
5738 * Waiting for some bits of register to change is a common
5739 * operation for ATA controllers. This function reads 32bit LE
5740 * IO-mapped register @reg and tests for the following condition.
5741 *
5742 * (*@reg & mask) != val
5743 *
5744 * If the condition is met, it returns; otherwise, the process is
5745 * repeated after @interval_msec until timeout.
5746 *
5747 * LOCKING:
5748 * Kernel thread context (may sleep)
5749 *
5750 * RETURNS:
5751 * The final register value.
5752 */
5753u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
5754 unsigned long interval_msec,
5755 unsigned long timeout_msec)
5756{
5757 unsigned long timeout;
5758 u32 tmp;
5759
5760 tmp = ioread32(reg);
5761
5762 /* Calculate timeout _after_ the first read to make sure
5763 * preceding writes reach the controller before starting to
5764 * eat away the timeout.
5765 */
5766 timeout = jiffies + (timeout_msec * HZ) / 1000;
5767
5768 while ((tmp & mask) == val && time_before(jiffies, timeout)) {
5769 msleep(interval_msec);
5770 tmp = ioread32(reg);
5771 }
5772
5773 return tmp;
5774}
5775
Linus Torvalds1da177e2005-04-16 15:20:36 -07005776/*
5777 * libata is essentially a library of internal helper functions for
5778 * low-level ATA host controller drivers. As such, the API/ABI is
5779 * likely to change as new drivers are added and updated.
5780 * Do not depend on ABI/API stability.
5781 */
5782
Tejun Heod7bb4cc2006-05-31 18:27:46 +09005783EXPORT_SYMBOL_GPL(sata_deb_timing_boot);
5784EXPORT_SYMBOL_GPL(sata_deb_timing_eh);
5785EXPORT_SYMBOL_GPL(sata_deb_timing_before_fsrst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005786EXPORT_SYMBOL_GPL(ata_std_bios_param);
5787EXPORT_SYMBOL_GPL(ata_std_ports);
5788EXPORT_SYMBOL_GPL(ata_device_add);
Tejun Heo720ba122006-05-31 18:28:13 +09005789EXPORT_SYMBOL_GPL(ata_port_detach);
Alan Cox17b14452005-09-15 15:44:00 +01005790EXPORT_SYMBOL_GPL(ata_host_set_remove);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005791EXPORT_SYMBOL_GPL(ata_sg_init);
5792EXPORT_SYMBOL_GPL(ata_sg_init_one);
Tejun Heo9a1004d2006-05-31 18:27:52 +09005793EXPORT_SYMBOL_GPL(ata_hsm_move);
Tejun Heof686bcb2006-05-15 20:58:05 +09005794EXPORT_SYMBOL_GPL(ata_qc_complete);
Tejun Heodedaf2b2006-05-15 21:03:43 +09005795EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005796EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005797EXPORT_SYMBOL_GPL(ata_tf_load);
5798EXPORT_SYMBOL_GPL(ata_tf_read);
5799EXPORT_SYMBOL_GPL(ata_noop_dev_select);
5800EXPORT_SYMBOL_GPL(ata_std_dev_select);
5801EXPORT_SYMBOL_GPL(ata_tf_to_fis);
5802EXPORT_SYMBOL_GPL(ata_tf_from_fis);
5803EXPORT_SYMBOL_GPL(ata_check_status);
5804EXPORT_SYMBOL_GPL(ata_altstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005805EXPORT_SYMBOL_GPL(ata_exec_command);
5806EXPORT_SYMBOL_GPL(ata_port_start);
5807EXPORT_SYMBOL_GPL(ata_port_stop);
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04005808EXPORT_SYMBOL_GPL(ata_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005809EXPORT_SYMBOL_GPL(ata_interrupt);
Alan Coxa6b2c5d2006-05-22 16:59:59 +01005810EXPORT_SYMBOL_GPL(ata_mmio_data_xfer);
5811EXPORT_SYMBOL_GPL(ata_pio_data_xfer);
Alan Cox75e99582006-05-24 14:14:41 +01005812EXPORT_SYMBOL_GPL(ata_pio_data_xfer_noirq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005813EXPORT_SYMBOL_GPL(ata_qc_prep);
Brian Kinge46834c2006-03-17 17:04:03 -06005814EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005815EXPORT_SYMBOL_GPL(ata_bmdma_setup);
5816EXPORT_SYMBOL_GPL(ata_bmdma_start);
5817EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
5818EXPORT_SYMBOL_GPL(ata_bmdma_status);
5819EXPORT_SYMBOL_GPL(ata_bmdma_stop);
Tejun Heo6d97dbd2006-05-15 20:58:24 +09005820EXPORT_SYMBOL_GPL(ata_bmdma_freeze);
5821EXPORT_SYMBOL_GPL(ata_bmdma_thaw);
5822EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh);
5823EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);
5824EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005825EXPORT_SYMBOL_GPL(ata_port_probe);
Tejun Heo3c567b72006-05-15 20:57:23 +09005826EXPORT_SYMBOL_GPL(sata_set_spd);
Tejun Heod7bb4cc2006-05-31 18:27:46 +09005827EXPORT_SYMBOL_GPL(sata_phy_debounce);
5828EXPORT_SYMBOL_GPL(sata_phy_resume);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005829EXPORT_SYMBOL_GPL(sata_phy_reset);
5830EXPORT_SYMBOL_GPL(__sata_phy_reset);
5831EXPORT_SYMBOL_GPL(ata_bus_reset);
Tejun Heof5914a42006-05-31 18:27:48 +09005832EXPORT_SYMBOL_GPL(ata_std_prereset);
Tejun Heoc2bd5802006-01-24 17:05:22 +09005833EXPORT_SYMBOL_GPL(ata_std_softreset);
5834EXPORT_SYMBOL_GPL(sata_std_hardreset);
5835EXPORT_SYMBOL_GPL(ata_std_postreset);
Tejun Heo623a3122006-03-05 17:55:58 +09005836EXPORT_SYMBOL_GPL(ata_dev_revalidate);
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05005837EXPORT_SYMBOL_GPL(ata_dev_classify);
5838EXPORT_SYMBOL_GPL(ata_dev_pair);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005839EXPORT_SYMBOL_GPL(ata_port_disable);
Jeff Garzik67846b32005-10-05 02:58:32 -04005840EXPORT_SYMBOL_GPL(ata_ratelimit);
Tejun Heoc22daff2006-04-11 22:22:29 +09005841EXPORT_SYMBOL_GPL(ata_wait_register);
Tejun Heo6f8b9952006-01-24 17:05:21 +09005842EXPORT_SYMBOL_GPL(ata_busy_sleep);
Tejun Heo86e45b62006-03-05 15:29:09 +09005843EXPORT_SYMBOL_GPL(ata_port_queue_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005844EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
5845EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005846EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
Tejun Heo83c47bc2006-05-31 18:28:07 +09005847EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
Tejun Heoa6e6ce82006-05-15 21:03:48 +09005848EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005849EXPORT_SYMBOL_GPL(ata_scsi_release);
5850EXPORT_SYMBOL_GPL(ata_host_intr);
Tejun Heo34bf2172006-05-15 20:57:46 +09005851EXPORT_SYMBOL_GPL(sata_scr_valid);
5852EXPORT_SYMBOL_GPL(sata_scr_read);
5853EXPORT_SYMBOL_GPL(sata_scr_write);
5854EXPORT_SYMBOL_GPL(sata_scr_write_flush);
5855EXPORT_SYMBOL_GPL(ata_port_online);
5856EXPORT_SYMBOL_GPL(ata_port_offline);
Tejun Heo6a62a042006-02-13 10:02:46 +09005857EXPORT_SYMBOL_GPL(ata_id_string);
5858EXPORT_SYMBOL_GPL(ata_id_c_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005859EXPORT_SYMBOL_GPL(ata_scsi_simulate);
5860
Alan Cox1bc4ccf2006-01-09 17:18:14 +00005861EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
Alan Cox452503f2005-10-21 19:01:32 -04005862EXPORT_SYMBOL_GPL(ata_timing_compute);
5863EXPORT_SYMBOL_GPL(ata_timing_merge);
5864
Linus Torvalds1da177e2005-04-16 15:20:36 -07005865#ifdef CONFIG_PCI
5866EXPORT_SYMBOL_GPL(pci_test_config_bits);
Jeff Garzik374b1872005-08-30 05:42:52 -04005867EXPORT_SYMBOL_GPL(ata_pci_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005868EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
5869EXPORT_SYMBOL_GPL(ata_pci_init_one);
5870EXPORT_SYMBOL_GPL(ata_pci_remove_one);
Jens Axboe9b847542006-01-06 09:28:07 +01005871EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
5872EXPORT_SYMBOL_GPL(ata_pci_device_resume);
Alan Cox67951ad2006-03-22 15:55:54 +00005873EXPORT_SYMBOL_GPL(ata_pci_default_filter);
5874EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005875#endif /* CONFIG_PCI */
Jens Axboe9b847542006-01-06 09:28:07 +01005876
5877EXPORT_SYMBOL_GPL(ata_device_suspend);
5878EXPORT_SYMBOL_GPL(ata_device_resume);
5879EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
5880EXPORT_SYMBOL_GPL(ata_scsi_device_resume);
Tejun Heoece1d632006-04-02 18:51:53 +09005881
Tejun Heoece1d632006-04-02 18:51:53 +09005882EXPORT_SYMBOL_GPL(ata_eng_timeout);
Tejun Heo7b70fc02006-05-15 20:58:07 +09005883EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
5884EXPORT_SYMBOL_GPL(ata_port_abort);
Tejun Heoe3180492006-05-15 20:58:09 +09005885EXPORT_SYMBOL_GPL(ata_port_freeze);
5886EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
5887EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
Tejun Heoece1d632006-04-02 18:51:53 +09005888EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
5889EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
Tejun Heo022bdb02006-05-15 20:58:22 +09005890EXPORT_SYMBOL_GPL(ata_do_eh);