blob: 1669dae53ce33a134be4f372591cc081180d5c8b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jeff Garzikaf36d7f2005-08-28 20:18:39 -04002 * libata-core.c - helper library for ATA
3 *
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
9 * Copyright 2003-2004 Jeff Garzik
10 *
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 *
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
29 *
30 * Hardware documentation available from http://www.t13.org/ and
31 * http://www.sata-io.org/
32 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 */
34
35#include <linux/config.h>
36#include <linux/kernel.h>
37#include <linux/module.h>
38#include <linux/pci.h>
39#include <linux/init.h>
40#include <linux/list.h>
41#include <linux/mm.h>
42#include <linux/highmem.h>
43#include <linux/spinlock.h>
44#include <linux/blkdev.h>
45#include <linux/delay.h>
46#include <linux/timer.h>
47#include <linux/interrupt.h>
48#include <linux/completion.h>
49#include <linux/suspend.h>
50#include <linux/workqueue.h>
Jeff Garzik67846b32005-10-05 02:58:32 -040051#include <linux/jiffies.h>
David Hardeman378f0582005-09-17 17:55:31 +100052#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <scsi/scsi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include "scsi_priv.h"
Jeff Garzik193515d2005-11-07 00:59:37 -050055#include <scsi/scsi_cmnd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <scsi/scsi_host.h>
57#include <linux/libata.h>
58#include <asm/io.h>
59#include <asm/semaphore.h>
60#include <asm/byteorder.h>
61
62#include "libata.h"
63
Tejun Heo6aff8f12006-02-15 18:24:09 +090064static unsigned int ata_dev_init_params(struct ata_port *ap,
Albert Lee00b6f5e2006-03-27 16:39:18 +080065 struct ata_device *dev,
66 u16 heads,
67 u16 sectors);
Tejun Heo83206a22006-03-24 15:25:31 +090068static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
69 struct ata_device *dev);
Tejun Heoacf356b2006-03-24 14:07:50 +090070static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
72static unsigned int ata_unique_id = 1;
73static struct workqueue_struct *ata_wq;
74
Jeff Garzik418dc1f2006-03-11 20:50:08 -050075int atapi_enabled = 1;
Jeff Garzik1623c812005-08-30 03:37:42 -040076module_param(atapi_enabled, int, 0444);
77MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
78
Albert Lee95de7192006-04-04 10:57:18 +080079int atapi_dmadir = 0;
80module_param(atapi_dmadir, int, 0444);
81MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
82
Jeff Garzikc3c013a2006-02-27 22:31:19 -050083int libata_fua = 0;
84module_param_named(fua, libata_fua, int, 0444);
85MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
86
Linus Torvalds1da177e2005-04-16 15:20:36 -070087MODULE_AUTHOR("Jeff Garzik");
88MODULE_DESCRIPTION("Library module for ATA devices");
89MODULE_LICENSE("GPL");
90MODULE_VERSION(DRV_VERSION);
91
Edward Falk0baab862005-06-02 18:17:13 -040092
93/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
95 * @tf: Taskfile to convert
96 * @fis: Buffer into which data will output
97 * @pmp: Port multiplier port
98 *
99 * Converts a standard ATA taskfile to a Serial ATA
100 * FIS structure (Register - Host to Device).
101 *
102 * LOCKING:
103 * Inherited from caller.
104 */
105
Jeff Garzik057ace52005-10-22 14:27:05 -0400106void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
108 fis[0] = 0x27; /* Register - Host to Device FIS */
109 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
110 bit 7 indicates Command FIS */
111 fis[2] = tf->command;
112 fis[3] = tf->feature;
113
114 fis[4] = tf->lbal;
115 fis[5] = tf->lbam;
116 fis[6] = tf->lbah;
117 fis[7] = tf->device;
118
119 fis[8] = tf->hob_lbal;
120 fis[9] = tf->hob_lbam;
121 fis[10] = tf->hob_lbah;
122 fis[11] = tf->hob_feature;
123
124 fis[12] = tf->nsect;
125 fis[13] = tf->hob_nsect;
126 fis[14] = 0;
127 fis[15] = tf->ctl;
128
129 fis[16] = 0;
130 fis[17] = 0;
131 fis[18] = 0;
132 fis[19] = 0;
133}
134
135/**
136 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
137 * @fis: Buffer from which data will be input
138 * @tf: Taskfile to output
139 *
Mark Lorde12a1be2005-11-12 18:55:45 -0500140 * Converts a serial ATA FIS structure to a standard ATA taskfile.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 *
142 * LOCKING:
143 * Inherited from caller.
144 */
145
Jeff Garzik057ace52005-10-22 14:27:05 -0400146void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
148 tf->command = fis[2]; /* status */
149 tf->feature = fis[3]; /* error */
150
151 tf->lbal = fis[4];
152 tf->lbam = fis[5];
153 tf->lbah = fis[6];
154 tf->device = fis[7];
155
156 tf->hob_lbal = fis[8];
157 tf->hob_lbam = fis[9];
158 tf->hob_lbah = fis[10];
159
160 tf->nsect = fis[12];
161 tf->hob_nsect = fis[13];
162}
163
Albert Lee8cbd6df2005-10-12 15:06:27 +0800164static const u8 ata_rw_cmds[] = {
165 /* pio multi */
166 ATA_CMD_READ_MULTI,
167 ATA_CMD_WRITE_MULTI,
168 ATA_CMD_READ_MULTI_EXT,
169 ATA_CMD_WRITE_MULTI_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100170 0,
171 0,
172 0,
173 ATA_CMD_WRITE_MULTI_FUA_EXT,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800174 /* pio */
175 ATA_CMD_PIO_READ,
176 ATA_CMD_PIO_WRITE,
177 ATA_CMD_PIO_READ_EXT,
178 ATA_CMD_PIO_WRITE_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100179 0,
180 0,
181 0,
182 0,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800183 /* dma */
184 ATA_CMD_READ,
185 ATA_CMD_WRITE,
186 ATA_CMD_READ_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100187 ATA_CMD_WRITE_EXT,
188 0,
189 0,
190 0,
191 ATA_CMD_WRITE_FUA_EXT
Albert Lee8cbd6df2005-10-12 15:06:27 +0800192};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
194/**
Albert Lee8cbd6df2005-10-12 15:06:27 +0800195 * ata_rwcmd_protocol - set taskfile r/w commands and protocol
196 * @qc: command to examine and configure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500198 * Examine the device configuration and tf->flags to calculate
Albert Lee8cbd6df2005-10-12 15:06:27 +0800199 * the proper read/write commands and protocol to use.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 *
201 * LOCKING:
202 * caller.
203 */
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100204int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Albert Lee8cbd6df2005-10-12 15:06:27 +0800206 struct ata_taskfile *tf = &qc->tf;
207 struct ata_device *dev = qc->dev;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100208 u8 cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100210 int index, fua, lba48, write;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500211
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100212 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800213 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
214 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Albert Lee8cbd6df2005-10-12 15:06:27 +0800216 if (dev->flags & ATA_DFLAG_PIO) {
217 tf->protocol = ATA_PROT_PIO;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100218 index = dev->multi_count ? 0 : 8;
Alan Cox8d238e02006-01-17 20:50:31 +0000219 } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
220 /* Unable to use DMA due to host limitation */
221 tf->protocol = ATA_PROT_PIO;
Albert Lee0565c262006-02-13 18:55:25 +0800222 index = dev->multi_count ? 0 : 8;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800223 } else {
224 tf->protocol = ATA_PROT_DMA;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100225 index = 16;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100228 cmd = ata_rw_cmds[index + fua + lba48 + write];
229 if (cmd) {
230 tf->command = cmd;
231 return 0;
232 }
233 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
Tejun Heocb95d562006-03-06 04:31:56 +0900236/**
237 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
238 * @pio_mask: pio_mask
239 * @mwdma_mask: mwdma_mask
240 * @udma_mask: udma_mask
241 *
242 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
243 * unsigned int xfer_mask.
244 *
245 * LOCKING:
246 * None.
247 *
248 * RETURNS:
249 * Packed xfer_mask.
250 */
251static unsigned int ata_pack_xfermask(unsigned int pio_mask,
252 unsigned int mwdma_mask,
253 unsigned int udma_mask)
254{
255 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
256 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
257 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
258}
259
Tejun Heoc0489e42006-03-24 14:07:49 +0900260/**
261 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
262 * @xfer_mask: xfer_mask to unpack
263 * @pio_mask: resulting pio_mask
264 * @mwdma_mask: resulting mwdma_mask
265 * @udma_mask: resulting udma_mask
266 *
267 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
268 * Any NULL distination masks will be ignored.
269 */
270static void ata_unpack_xfermask(unsigned int xfer_mask,
271 unsigned int *pio_mask,
272 unsigned int *mwdma_mask,
273 unsigned int *udma_mask)
274{
275 if (pio_mask)
276 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
277 if (mwdma_mask)
278 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
279 if (udma_mask)
280 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
281}
282
Tejun Heocb95d562006-03-06 04:31:56 +0900283static const struct ata_xfer_ent {
Tejun Heobe9a50c82006-03-31 22:48:52 +0900284 int shift, bits;
Tejun Heocb95d562006-03-06 04:31:56 +0900285 u8 base;
286} ata_xfer_tbl[] = {
287 { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
288 { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
289 { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
290 { -1, },
291};
292
293/**
294 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
295 * @xfer_mask: xfer_mask of interest
296 *
297 * Return matching XFER_* value for @xfer_mask. Only the highest
298 * bit of @xfer_mask is considered.
299 *
300 * LOCKING:
301 * None.
302 *
303 * RETURNS:
304 * Matching XFER_* value, 0 if no match found.
305 */
306static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
307{
308 int highbit = fls(xfer_mask) - 1;
309 const struct ata_xfer_ent *ent;
310
311 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
312 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
313 return ent->base + highbit - ent->shift;
314 return 0;
315}
316
317/**
318 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
319 * @xfer_mode: XFER_* of interest
320 *
321 * Return matching xfer_mask for @xfer_mode.
322 *
323 * LOCKING:
324 * None.
325 *
326 * RETURNS:
327 * Matching xfer_mask, 0 if no match found.
328 */
329static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
330{
331 const struct ata_xfer_ent *ent;
332
333 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
334 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
335 return 1 << (ent->shift + xfer_mode - ent->base);
336 return 0;
337}
338
339/**
340 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
341 * @xfer_mode: XFER_* of interest
342 *
343 * Return matching xfer_shift for @xfer_mode.
344 *
345 * LOCKING:
346 * None.
347 *
348 * RETURNS:
349 * Matching xfer_shift, -1 if no match found.
350 */
351static int ata_xfer_mode2shift(unsigned int xfer_mode)
352{
353 const struct ata_xfer_ent *ent;
354
355 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
356 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
357 return ent->shift;
358 return -1;
359}
360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361/**
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900362 * ata_mode_string - convert xfer_mask to string
363 * @xfer_mask: mask of bits supported; only highest bit counts.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 *
365 * Determine string which represents the highest speed
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900366 * (highest bit in @modemask).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 *
368 * LOCKING:
369 * None.
370 *
371 * RETURNS:
372 * Constant C string representing highest speed listed in
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900373 * @mode_mask, or the constant C string "<n/a>".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 */
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900375static const char *ata_mode_string(unsigned int xfer_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376{
Tejun Heo75f554b2006-03-06 04:31:57 +0900377 static const char * const xfer_mode_str[] = {
378 "PIO0",
379 "PIO1",
380 "PIO2",
381 "PIO3",
382 "PIO4",
383 "MWDMA0",
384 "MWDMA1",
385 "MWDMA2",
386 "UDMA/16",
387 "UDMA/25",
388 "UDMA/33",
389 "UDMA/44",
390 "UDMA/66",
391 "UDMA/100",
392 "UDMA/133",
393 "UDMA7",
394 };
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900395 int highbit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900397 highbit = fls(xfer_mask) - 1;
398 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
399 return xfer_mode_str[highbit];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 return "<n/a>";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401}
402
Tejun Heo4c360c82006-04-01 01:38:17 +0900403static const char *sata_spd_string(unsigned int spd)
404{
405 static const char * const spd_str[] = {
406 "1.5 Gbps",
407 "3.0 Gbps",
408 };
409
410 if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
411 return "<unknown>";
412 return spd_str[spd - 1];
413}
414
Tejun Heo1ad8e7f2006-04-02 18:51:53 +0900415void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
Tejun Heo0b8efb02006-03-24 15:25:31 +0900416{
Tejun Heoe1211e32006-04-01 01:38:18 +0900417 if (ata_dev_enabled(dev)) {
Tejun Heo0b8efb02006-03-24 15:25:31 +0900418 printk(KERN_WARNING "ata%u: dev %u disabled\n",
419 ap->id, dev->devno);
420 dev->class++;
421 }
422}
423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424/**
425 * ata_pio_devchk - PATA device presence detection
426 * @ap: ATA channel to examine
427 * @device: Device to examine (starting at zero)
428 *
429 * This technique was originally described in
430 * Hale Landis's ATADRVR (www.ata-atapi.com), and
431 * later found its way into the ATA/ATAPI spec.
432 *
433 * Write a pattern to the ATA shadow registers,
434 * and if a device is present, it will respond by
435 * correctly storing and echoing back the
436 * ATA shadow register contents.
437 *
438 * LOCKING:
439 * caller.
440 */
441
442static unsigned int ata_pio_devchk(struct ata_port *ap,
443 unsigned int device)
444{
445 struct ata_ioports *ioaddr = &ap->ioaddr;
446 u8 nsect, lbal;
447
448 ap->ops->dev_select(ap, device);
449
450 outb(0x55, ioaddr->nsect_addr);
451 outb(0xaa, ioaddr->lbal_addr);
452
453 outb(0xaa, ioaddr->nsect_addr);
454 outb(0x55, ioaddr->lbal_addr);
455
456 outb(0x55, ioaddr->nsect_addr);
457 outb(0xaa, ioaddr->lbal_addr);
458
459 nsect = inb(ioaddr->nsect_addr);
460 lbal = inb(ioaddr->lbal_addr);
461
462 if ((nsect == 0x55) && (lbal == 0xaa))
463 return 1; /* we found a device */
464
465 return 0; /* nothing found */
466}
467
468/**
469 * ata_mmio_devchk - PATA device presence detection
470 * @ap: ATA channel to examine
471 * @device: Device to examine (starting at zero)
472 *
473 * This technique was originally described in
474 * Hale Landis's ATADRVR (www.ata-atapi.com), and
475 * later found its way into the ATA/ATAPI spec.
476 *
477 * Write a pattern to the ATA shadow registers,
478 * and if a device is present, it will respond by
479 * correctly storing and echoing back the
480 * ATA shadow register contents.
481 *
482 * LOCKING:
483 * caller.
484 */
485
486static unsigned int ata_mmio_devchk(struct ata_port *ap,
487 unsigned int device)
488{
489 struct ata_ioports *ioaddr = &ap->ioaddr;
490 u8 nsect, lbal;
491
492 ap->ops->dev_select(ap, device);
493
494 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
495 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
496
497 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
498 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
499
500 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
501 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
502
503 nsect = readb((void __iomem *) ioaddr->nsect_addr);
504 lbal = readb((void __iomem *) ioaddr->lbal_addr);
505
506 if ((nsect == 0x55) && (lbal == 0xaa))
507 return 1; /* we found a device */
508
509 return 0; /* nothing found */
510}
511
512/**
513 * ata_devchk - PATA device presence detection
514 * @ap: ATA channel to examine
515 * @device: Device to examine (starting at zero)
516 *
517 * Dispatch ATA device presence detection, depending
518 * on whether we are using PIO or MMIO to talk to the
519 * ATA shadow registers.
520 *
521 * LOCKING:
522 * caller.
523 */
524
525static unsigned int ata_devchk(struct ata_port *ap,
526 unsigned int device)
527{
528 if (ap->flags & ATA_FLAG_MMIO)
529 return ata_mmio_devchk(ap, device);
530 return ata_pio_devchk(ap, device);
531}
532
533/**
534 * ata_dev_classify - determine device type based on ATA-spec signature
535 * @tf: ATA taskfile register set for device to be identified
536 *
537 * Determine from taskfile register contents whether a device is
538 * ATA or ATAPI, as per "Signature and persistence" section
539 * of ATA/PI spec (volume 1, sect 5.14).
540 *
541 * LOCKING:
542 * None.
543 *
544 * RETURNS:
545 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
546 * the event of failure.
547 */
548
Jeff Garzik057ace52005-10-22 14:27:05 -0400549unsigned int ata_dev_classify(const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
551 /* Apple's open source Darwin code hints that some devices only
552 * put a proper signature into the LBA mid/high registers,
553 * So, we only check those. It's sufficient for uniqueness.
554 */
555
556 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
557 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
558 DPRINTK("found ATA device by sig\n");
559 return ATA_DEV_ATA;
560 }
561
562 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
563 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
564 DPRINTK("found ATAPI device by sig\n");
565 return ATA_DEV_ATAPI;
566 }
567
568 DPRINTK("unknown device\n");
569 return ATA_DEV_UNKNOWN;
570}
571
572/**
573 * ata_dev_try_classify - Parse returned ATA device signature
574 * @ap: ATA channel to examine
575 * @device: Device to examine (starting at zero)
Tejun Heob4dc7622006-01-24 17:05:22 +0900576 * @r_err: Value of error register on completion
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 *
578 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
579 * an ATA/ATAPI-defined set of values is placed in the ATA
580 * shadow registers, indicating the results of device detection
581 * and diagnostics.
582 *
583 * Select the ATA device, and read the values from the ATA shadow
584 * registers. Then parse according to the Error register value,
585 * and the spec-defined values examined by ata_dev_classify().
586 *
587 * LOCKING:
588 * caller.
Tejun Heob4dc7622006-01-24 17:05:22 +0900589 *
590 * RETURNS:
591 * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 */
593
Tejun Heob4dc7622006-01-24 17:05:22 +0900594static unsigned int
595ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 struct ata_taskfile tf;
598 unsigned int class;
599 u8 err;
600
601 ap->ops->dev_select(ap, device);
602
603 memset(&tf, 0, sizeof(tf));
604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 ap->ops->tf_read(ap, &tf);
Jeff Garzik0169e282005-10-29 21:25:10 -0400606 err = tf.feature;
Tejun Heob4dc7622006-01-24 17:05:22 +0900607 if (r_err)
608 *r_err = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
610 /* see if device passed diags */
611 if (err == 1)
612 /* do nothing */ ;
613 else if ((device == 0) && (err == 0x81))
614 /* do nothing */ ;
615 else
Tejun Heob4dc7622006-01-24 17:05:22 +0900616 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Tejun Heob4dc7622006-01-24 17:05:22 +0900618 /* determine if device is ATA or ATAPI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 class = ata_dev_classify(&tf);
Tejun Heob4dc7622006-01-24 17:05:22 +0900620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 if (class == ATA_DEV_UNKNOWN)
Tejun Heob4dc7622006-01-24 17:05:22 +0900622 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
Tejun Heob4dc7622006-01-24 17:05:22 +0900624 return ATA_DEV_NONE;
625 return class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626}
627
628/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900629 * ata_id_string - Convert IDENTIFY DEVICE page into string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 * @id: IDENTIFY DEVICE results we will examine
631 * @s: string into which data is output
632 * @ofs: offset into identify device page
633 * @len: length of string to return. must be an even number.
634 *
635 * The strings in the IDENTIFY DEVICE page are broken up into
636 * 16-bit chunks. Run through the string, and output each
637 * 8-bit chunk linearly, regardless of platform.
638 *
639 * LOCKING:
640 * caller.
641 */
642
Tejun Heo6a62a042006-02-13 10:02:46 +0900643void ata_id_string(const u16 *id, unsigned char *s,
644 unsigned int ofs, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645{
646 unsigned int c;
647
648 while (len > 0) {
649 c = id[ofs] >> 8;
650 *s = c;
651 s++;
652
653 c = id[ofs] & 0xff;
654 *s = c;
655 s++;
656
657 ofs++;
658 len -= 2;
659 }
660}
661
Tejun Heo0e949ff2006-02-12 22:47:04 +0900662/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900663 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
Tejun Heo0e949ff2006-02-12 22:47:04 +0900664 * @id: IDENTIFY DEVICE results we will examine
665 * @s: string into which data is output
666 * @ofs: offset into identify device page
667 * @len: length of string to return. must be an odd number.
668 *
Tejun Heo6a62a042006-02-13 10:02:46 +0900669 * This function is identical to ata_id_string except that it
Tejun Heo0e949ff2006-02-12 22:47:04 +0900670 * trims trailing spaces and terminates the resulting string with
671 * null. @len must be actual maximum length (even number) + 1.
672 *
673 * LOCKING:
674 * caller.
675 */
Tejun Heo6a62a042006-02-13 10:02:46 +0900676void ata_id_c_string(const u16 *id, unsigned char *s,
677 unsigned int ofs, unsigned int len)
Tejun Heo0e949ff2006-02-12 22:47:04 +0900678{
679 unsigned char *p;
680
681 WARN_ON(!(len & 1));
682
Tejun Heo6a62a042006-02-13 10:02:46 +0900683 ata_id_string(id, s, ofs, len - 1);
Tejun Heo0e949ff2006-02-12 22:47:04 +0900684
685 p = s + strnlen(s, len - 1);
686 while (p > s && p[-1] == ' ')
687 p--;
688 *p = '\0';
689}
Edward Falk0baab862005-06-02 18:17:13 -0400690
Tejun Heo29407402006-02-12 22:47:04 +0900691static u64 ata_id_n_sectors(const u16 *id)
692{
693 if (ata_id_has_lba(id)) {
694 if (ata_id_has_lba48(id))
695 return ata_id_u64(id, 100);
696 else
697 return ata_id_u32(id, 60);
698 } else {
699 if (ata_id_current_chs_valid(id))
700 return ata_id_u32(id, 57);
701 else
702 return id[1] * id[3] * id[6];
703 }
704}
705
Edward Falk0baab862005-06-02 18:17:13 -0400706/**
707 * ata_noop_dev_select - Select device 0/1 on ATA bus
708 * @ap: ATA channel to manipulate
709 * @device: ATA device (numbered from zero) to select
710 *
711 * This function performs no actual function.
712 *
713 * May be used as the dev_select() entry in ata_port_operations.
714 *
715 * LOCKING:
716 * caller.
717 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
719{
720}
721
Edward Falk0baab862005-06-02 18:17:13 -0400722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723/**
724 * ata_std_dev_select - Select device 0/1 on ATA bus
725 * @ap: ATA channel to manipulate
726 * @device: ATA device (numbered from zero) to select
727 *
728 * Use the method defined in the ATA specification to
729 * make either device 0, or device 1, active on the
Edward Falk0baab862005-06-02 18:17:13 -0400730 * ATA channel. Works with both PIO and MMIO.
731 *
732 * May be used as the dev_select() entry in ata_port_operations.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 *
734 * LOCKING:
735 * caller.
736 */
737
738void ata_std_dev_select (struct ata_port *ap, unsigned int device)
739{
740 u8 tmp;
741
742 if (device == 0)
743 tmp = ATA_DEVICE_OBS;
744 else
745 tmp = ATA_DEVICE_OBS | ATA_DEV1;
746
747 if (ap->flags & ATA_FLAG_MMIO) {
748 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
749 } else {
750 outb(tmp, ap->ioaddr.device_addr);
751 }
752 ata_pause(ap); /* needed; also flushes, for mmio */
753}
754
755/**
756 * ata_dev_select - Select device 0/1 on ATA bus
757 * @ap: ATA channel to manipulate
758 * @device: ATA device (numbered from zero) to select
759 * @wait: non-zero to wait for Status register BSY bit to clear
760 * @can_sleep: non-zero if context allows sleeping
761 *
762 * Use the method defined in the ATA specification to
763 * make either device 0, or device 1, active on the
764 * ATA channel.
765 *
766 * This is a high-level version of ata_std_dev_select(),
767 * which additionally provides the services of inserting
768 * the proper pauses and status polling, where needed.
769 *
770 * LOCKING:
771 * caller.
772 */
773
774void ata_dev_select(struct ata_port *ap, unsigned int device,
775 unsigned int wait, unsigned int can_sleep)
776{
777 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
778 ap->id, device, wait);
779
780 if (wait)
781 ata_wait_idle(ap);
782
783 ap->ops->dev_select(ap, device);
784
785 if (wait) {
786 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
787 msleep(150);
788 ata_wait_idle(ap);
789 }
790}
791
792/**
793 * ata_dump_id - IDENTIFY DEVICE info debugging output
Tejun Heo0bd33002006-02-12 22:47:05 +0900794 * @id: IDENTIFY DEVICE page to dump
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 *
Tejun Heo0bd33002006-02-12 22:47:05 +0900796 * Dump selected 16-bit words from the given IDENTIFY DEVICE
797 * page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 *
799 * LOCKING:
800 * caller.
801 */
802
Tejun Heo0bd33002006-02-12 22:47:05 +0900803static inline void ata_dump_id(const u16 *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804{
805 DPRINTK("49==0x%04x "
806 "53==0x%04x "
807 "63==0x%04x "
808 "64==0x%04x "
809 "75==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900810 id[49],
811 id[53],
812 id[63],
813 id[64],
814 id[75]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 DPRINTK("80==0x%04x "
816 "81==0x%04x "
817 "82==0x%04x "
818 "83==0x%04x "
819 "84==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900820 id[80],
821 id[81],
822 id[82],
823 id[83],
824 id[84]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 DPRINTK("88==0x%04x "
826 "93==0x%04x\n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900827 id[88],
828 id[93]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
Tejun Heocb95d562006-03-06 04:31:56 +0900831/**
832 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
833 * @id: IDENTIFY data to compute xfer mask from
834 *
835 * Compute the xfermask for this device. This is not as trivial
836 * as it seems if we must consider early devices correctly.
837 *
838 * FIXME: pre IDE drive timing (do we care ?).
839 *
840 * LOCKING:
841 * None.
842 *
843 * RETURNS:
844 * Computed xfermask
845 */
846static unsigned int ata_id_xfermask(const u16 *id)
847{
848 unsigned int pio_mask, mwdma_mask, udma_mask;
849
850 /* Usual case. Word 53 indicates word 64 is valid */
851 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
852 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
853 pio_mask <<= 3;
854 pio_mask |= 0x7;
855 } else {
856 /* If word 64 isn't valid then Word 51 high byte holds
857 * the PIO timing number for the maximum. Turn it into
858 * a mask.
859 */
860 pio_mask = (2 << (id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
861
862 /* But wait.. there's more. Design your standards by
863 * committee and you too can get a free iordy field to
864 * process. However its the speeds not the modes that
865 * are supported... Note drivers using the timing API
866 * will get this right anyway
867 */
868 }
869
870 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
Tejun Heofb21f0d2006-03-12 12:34:35 +0900871
872 udma_mask = 0;
873 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
874 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
Tejun Heocb95d562006-03-06 04:31:56 +0900875
876 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
877}
878
Tejun Heo86e45b62006-03-05 15:29:09 +0900879/**
880 * ata_port_queue_task - Queue port_task
881 * @ap: The ata_port to queue port_task for
882 *
883 * Schedule @fn(@data) for execution after @delay jiffies using
884 * port_task. There is one port_task per port and it's the
885 * user(low level driver)'s responsibility to make sure that only
886 * one task is active at any given time.
887 *
888 * libata core layer takes care of synchronization between
889 * port_task and EH. ata_port_queue_task() may be ignored for EH
890 * synchronization.
891 *
892 * LOCKING:
893 * Inherited from caller.
894 */
895void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *), void *data,
896 unsigned long delay)
897{
898 int rc;
899
Tejun Heo2e755f62006-03-05 15:29:09 +0900900 if (ap->flags & ATA_FLAG_FLUSH_PORT_TASK)
Tejun Heo86e45b62006-03-05 15:29:09 +0900901 return;
902
903 PREPARE_WORK(&ap->port_task, fn, data);
904
905 if (!delay)
906 rc = queue_work(ata_wq, &ap->port_task);
907 else
908 rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
909
910 /* rc == 0 means that another user is using port task */
911 WARN_ON(rc == 0);
912}
913
914/**
915 * ata_port_flush_task - Flush port_task
916 * @ap: The ata_port to flush port_task for
917 *
918 * After this function completes, port_task is guranteed not to
919 * be running or scheduled.
920 *
921 * LOCKING:
922 * Kernel thread context (may sleep)
923 */
924void ata_port_flush_task(struct ata_port *ap)
925{
926 unsigned long flags;
927
928 DPRINTK("ENTER\n");
929
930 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900931 ap->flags |= ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heo86e45b62006-03-05 15:29:09 +0900932 spin_unlock_irqrestore(&ap->host_set->lock, flags);
933
934 DPRINTK("flush #1\n");
935 flush_workqueue(ata_wq);
936
937 /*
938 * At this point, if a task is running, it's guaranteed to see
939 * the FLUSH flag; thus, it will never queue pio tasks again.
940 * Cancel and flush.
941 */
942 if (!cancel_delayed_work(&ap->port_task)) {
943 DPRINTK("flush #2\n");
944 flush_workqueue(ata_wq);
945 }
946
947 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900948 ap->flags &= ~ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heo86e45b62006-03-05 15:29:09 +0900949 spin_unlock_irqrestore(&ap->host_set->lock, flags);
950
951 DPRINTK("EXIT\n");
952}
953
Tejun Heo77853bf2006-01-23 13:09:36 +0900954void ata_qc_complete_internal(struct ata_queued_cmd *qc)
Tejun Heoa2a7a662005-12-13 14:48:31 +0900955{
Tejun Heo77853bf2006-01-23 13:09:36 +0900956 struct completion *waiting = qc->private_data;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900957
Tejun Heo77853bf2006-01-23 13:09:36 +0900958 qc->ap->ops->tf_read(qc->ap, &qc->tf);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900959 complete(waiting);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900960}
961
962/**
963 * ata_exec_internal - execute libata internal command
964 * @ap: Port to which the command is sent
965 * @dev: Device to which the command is sent
966 * @tf: Taskfile registers for the command and the result
Tejun Heod69cf372006-04-02 18:51:53 +0900967 * @cdb: CDB for packet command
Tejun Heoa2a7a662005-12-13 14:48:31 +0900968 * @dma_dir: Data tranfer direction of the command
969 * @buf: Data buffer of the command
970 * @buflen: Length of data buffer
971 *
972 * Executes libata internal command with timeout. @tf contains
973 * command on entry and result on return. Timeout and error
974 * conditions are reported via return value. No recovery action
975 * is taken after a command times out. It's caller's duty to
976 * clean up after timeout.
977 *
978 * LOCKING:
979 * None. Should be called with kernel context, might sleep.
980 */
981
Tejun Heo1ad8e7f2006-04-02 18:51:53 +0900982unsigned ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
983 struct ata_taskfile *tf, const u8 *cdb,
984 int dma_dir, void *buf, unsigned int buflen)
Tejun Heoa2a7a662005-12-13 14:48:31 +0900985{
986 u8 command = tf->command;
987 struct ata_queued_cmd *qc;
988 DECLARE_COMPLETION(wait);
989 unsigned long flags;
Tejun Heo77853bf2006-01-23 13:09:36 +0900990 unsigned int err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900991
992 spin_lock_irqsave(&ap->host_set->lock, flags);
993
994 qc = ata_qc_new_init(ap, dev);
995 BUG_ON(qc == NULL);
996
997 qc->tf = *tf;
Tejun Heod69cf372006-04-02 18:51:53 +0900998 if (cdb)
999 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001000 qc->dma_dir = dma_dir;
1001 if (dma_dir != DMA_NONE) {
1002 ata_sg_init_one(qc, buf, buflen);
1003 qc->nsect = buflen / ATA_SECT_SIZE;
1004 }
1005
Tejun Heo77853bf2006-01-23 13:09:36 +09001006 qc->private_data = &wait;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001007 qc->complete_fn = ata_qc_complete_internal;
1008
Tejun Heo8e0e6942006-03-31 20:41:11 +09001009 ata_qc_issue(qc);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001010
1011 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1012
1013 if (!wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL)) {
Albert Lee41ade502006-03-14 11:19:04 +08001014 ata_port_flush_task(ap);
1015
Tejun Heoa2a7a662005-12-13 14:48:31 +09001016 spin_lock_irqsave(&ap->host_set->lock, flags);
1017
1018 /* We're racing with irq here. If we lose, the
1019 * following test prevents us from completing the qc
1020 * again. If completion irq occurs after here but
1021 * before the caller cleans up, it will result in a
1022 * spurious interrupt. We can live with that.
1023 */
Tejun Heo77853bf2006-01-23 13:09:36 +09001024 if (qc->flags & ATA_QCFLAG_ACTIVE) {
Tejun Heo11a56d22006-01-23 13:09:36 +09001025 qc->err_mask = AC_ERR_TIMEOUT;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001026 ata_qc_complete(qc);
1027 printk(KERN_WARNING "ata%u: qc timeout (cmd 0x%x)\n",
1028 ap->id, command);
1029 }
1030
1031 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1032 }
1033
Tejun Heo77853bf2006-01-23 13:09:36 +09001034 *tf = qc->tf;
1035 err_mask = qc->err_mask;
1036
1037 ata_qc_free(qc);
1038
Tejun Heo1f7dd3e2006-03-24 15:25:30 +09001039 /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1040 * Until those drivers are fixed, we detect the condition
1041 * here, fail the command with AC_ERR_SYSTEM and reenable the
1042 * port.
1043 *
1044 * Note that this doesn't change any behavior as internal
1045 * command failure results in disabling the device in the
1046 * higher layer for LLDDs without new reset/EH callbacks.
1047 *
1048 * Kill the following code as soon as those drivers are fixed.
1049 */
Tejun Heo198e0fe2006-04-02 18:51:52 +09001050 if (ap->flags & ATA_FLAG_DISABLED) {
Tejun Heo1f7dd3e2006-03-24 15:25:30 +09001051 err_mask |= AC_ERR_SYSTEM;
1052 ata_port_probe(ap);
1053 }
1054
Tejun Heo77853bf2006-01-23 13:09:36 +09001055 return err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001056}
1057
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058/**
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001059 * ata_pio_need_iordy - check if iordy needed
1060 * @adev: ATA device
1061 *
1062 * Check if the current speed of the device requires IORDY. Used
1063 * by various controllers for chip configuration.
1064 */
1065
1066unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1067{
1068 int pio;
1069 int speed = adev->pio_mode - XFER_PIO_0;
1070
1071 if (speed < 2)
1072 return 0;
1073 if (speed > 2)
1074 return 1;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001075
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001076 /* If we have no drive specific rule, then PIO 2 is non IORDY */
1077
1078 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1079 pio = adev->id[ATA_ID_EIDE_PIO];
1080 /* Is the speed faster than the drive allows non IORDY ? */
1081 if (pio) {
1082 /* This is cycle times not frequency - watch the logic! */
1083 if (pio > 240) /* PIO2 is 240nS per cycle */
1084 return 1;
1085 return 0;
1086 }
1087 }
1088 return 0;
1089}
1090
1091/**
Tejun Heo49016ac2006-02-21 02:12:11 +09001092 * ata_dev_read_id - Read ID data from the specified device
1093 * @ap: port on which target device resides
1094 * @dev: target device
1095 * @p_class: pointer to class of the target device (may be changed)
1096 * @post_reset: is this read ID post-reset?
Tejun Heod9572b12006-03-01 16:09:35 +09001097 * @p_id: read IDENTIFY page (newly allocated)
Tejun Heo49016ac2006-02-21 02:12:11 +09001098 *
1099 * Read ID data from the specified device. ATA_CMD_ID_ATA is
1100 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
Tejun Heoaec5c3c2006-03-25 01:33:34 +09001101 * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS
1102 * for pre-ATA4 drives.
Tejun Heo49016ac2006-02-21 02:12:11 +09001103 *
1104 * LOCKING:
1105 * Kernel thread context (may sleep)
1106 *
1107 * RETURNS:
1108 * 0 on success, -errno otherwise.
1109 */
1110static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
Tejun Heod9572b12006-03-01 16:09:35 +09001111 unsigned int *p_class, int post_reset, u16 **p_id)
Tejun Heo49016ac2006-02-21 02:12:11 +09001112{
1113 unsigned int class = *p_class;
Tejun Heo49016ac2006-02-21 02:12:11 +09001114 struct ata_taskfile tf;
1115 unsigned int err_mask = 0;
Tejun Heod9572b12006-03-01 16:09:35 +09001116 u16 *id;
Tejun Heo49016ac2006-02-21 02:12:11 +09001117 const char *reason;
1118 int rc;
1119
1120 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1121
Tejun Heo49016ac2006-02-21 02:12:11 +09001122 ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1123
Tejun Heod9572b12006-03-01 16:09:35 +09001124 id = kmalloc(sizeof(id[0]) * ATA_ID_WORDS, GFP_KERNEL);
1125 if (id == NULL) {
1126 rc = -ENOMEM;
1127 reason = "out of memory";
1128 goto err_out;
1129 }
1130
Tejun Heo49016ac2006-02-21 02:12:11 +09001131 retry:
1132 ata_tf_init(ap, &tf, dev->devno);
1133
1134 switch (class) {
1135 case ATA_DEV_ATA:
1136 tf.command = ATA_CMD_ID_ATA;
1137 break;
1138 case ATA_DEV_ATAPI:
1139 tf.command = ATA_CMD_ID_ATAPI;
1140 break;
1141 default:
1142 rc = -ENODEV;
1143 reason = "unsupported class";
1144 goto err_out;
1145 }
1146
1147 tf.protocol = ATA_PROT_PIO;
1148
Tejun Heod69cf372006-04-02 18:51:53 +09001149 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_FROM_DEVICE,
Tejun Heo49016ac2006-02-21 02:12:11 +09001150 id, sizeof(id[0]) * ATA_ID_WORDS);
Tejun Heo49016ac2006-02-21 02:12:11 +09001151 if (err_mask) {
1152 rc = -EIO;
1153 reason = "I/O error";
Tejun Heo49016ac2006-02-21 02:12:11 +09001154 goto err_out;
1155 }
1156
1157 swap_buf_le16(id, ATA_ID_WORDS);
1158
Tejun Heo49016ac2006-02-21 02:12:11 +09001159 /* sanity check */
Alan Cox692785e2006-03-27 18:49:19 +01001160 if ((class == ATA_DEV_ATA) != (ata_id_is_ata(id) | ata_id_is_cfa(id))) {
Tejun Heo49016ac2006-02-21 02:12:11 +09001161 rc = -EINVAL;
1162 reason = "device reports illegal type";
1163 goto err_out;
1164 }
1165
1166 if (post_reset && class == ATA_DEV_ATA) {
1167 /*
1168 * The exact sequence expected by certain pre-ATA4 drives is:
1169 * SRST RESET
1170 * IDENTIFY
1171 * INITIALIZE DEVICE PARAMETERS
1172 * anything else..
1173 * Some drives were very specific about that exact sequence.
1174 */
1175 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
Albert Lee00b6f5e2006-03-27 16:39:18 +08001176 err_mask = ata_dev_init_params(ap, dev, id[3], id[6]);
Tejun Heo49016ac2006-02-21 02:12:11 +09001177 if (err_mask) {
1178 rc = -EIO;
1179 reason = "INIT_DEV_PARAMS failed";
1180 goto err_out;
1181 }
1182
1183 /* current CHS translation info (id[53-58]) might be
1184 * changed. reread the identify device info.
1185 */
1186 post_reset = 0;
1187 goto retry;
1188 }
1189 }
1190
1191 *p_class = class;
Tejun Heod9572b12006-03-01 16:09:35 +09001192 *p_id = id;
Tejun Heo49016ac2006-02-21 02:12:11 +09001193 return 0;
1194
1195 err_out:
1196 printk(KERN_WARNING "ata%u: dev %u failed to IDENTIFY (%s)\n",
1197 ap->id, dev->devno, reason);
Tejun Heod9572b12006-03-01 16:09:35 +09001198 kfree(id);
Tejun Heo49016ac2006-02-21 02:12:11 +09001199 return rc;
1200}
1201
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001202static inline u8 ata_dev_knobble(const struct ata_port *ap,
1203 struct ata_device *dev)
1204{
1205 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
1206}
1207
Tejun Heo49016ac2006-02-21 02:12:11 +09001208/**
Tejun Heoffeae412006-03-01 16:09:35 +09001209 * ata_dev_configure - Configure the specified ATA/ATAPI device
1210 * @ap: Port on which target device resides
1211 * @dev: Target device to configure
Tejun Heo4c2d7212006-03-05 17:55:58 +09001212 * @print_info: Enable device info printout
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 *
Tejun Heoffeae412006-03-01 16:09:35 +09001214 * Configure @dev according to @dev->id. Generic and low-level
1215 * driver specific fixups are also applied.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 *
1217 * LOCKING:
Tejun Heoffeae412006-03-01 16:09:35 +09001218 * Kernel thread context (may sleep)
1219 *
1220 * RETURNS:
1221 * 0 on success, -errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001223static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
1224 int print_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225{
Tejun Heo1148c3a2006-03-13 19:48:04 +09001226 const u16 *id = dev->id;
Tejun Heoff8854b2006-03-06 04:31:56 +09001227 unsigned int xfer_mask;
Tejun Heo6e7846e2006-02-12 23:32:58 +09001228 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
Tejun Heoe1211e32006-04-01 01:38:18 +09001230 if (!ata_dev_enabled(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
Tejun Heoffeae412006-03-01 16:09:35 +09001232 ap->id, dev->devno);
1233 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 }
1235
Tejun Heoffeae412006-03-01 16:09:35 +09001236 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
Tejun Heoc39f5eb2006-03-13 19:51:19 +09001238 /* print device capabilities */
1239 if (print_info)
1240 printk(KERN_DEBUG "ata%u: dev %u cfg 49:%04x 82:%04x 83:%04x "
1241 "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1242 ap->id, dev->devno, id[49], id[82], id[83],
1243 id[84], id[85], id[86], id[87], id[88]);
1244
Tejun Heo208a9932006-03-05 17:55:58 +09001245 /* initialize to-be-configured parameters */
Tejun Heoea1dd4e2006-04-02 18:51:53 +09001246 dev->flags &= ~ATA_DFLAG_CFG_MASK;
Tejun Heo208a9932006-03-05 17:55:58 +09001247 dev->max_sectors = 0;
1248 dev->cdb_len = 0;
1249 dev->n_sectors = 0;
1250 dev->cylinders = 0;
1251 dev->heads = 0;
1252 dev->sectors = 0;
1253
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 /*
1255 * common ATA, ATAPI feature tests
1256 */
1257
Tejun Heoff8854b2006-03-06 04:31:56 +09001258 /* find max transfer mode; for printk only */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001259 xfer_mask = ata_id_xfermask(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Tejun Heo1148c3a2006-03-13 19:48:04 +09001261 ata_dump_id(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
1263 /* ATA-specific feature tests */
1264 if (dev->class == ATA_DEV_ATA) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001265 dev->n_sectors = ata_id_n_sectors(id);
Tejun Heo29407402006-02-12 22:47:04 +09001266
Tejun Heo1148c3a2006-03-13 19:48:04 +09001267 if (ata_id_has_lba(id)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001268 const char *lba_desc;
Albert Lee8bf62ec2005-05-12 15:29:42 -04001269
Tejun Heo4c2d7212006-03-05 17:55:58 +09001270 lba_desc = "LBA";
1271 dev->flags |= ATA_DFLAG_LBA;
Tejun Heo1148c3a2006-03-13 19:48:04 +09001272 if (ata_id_has_lba48(id)) {
Albert Lee8bf62ec2005-05-12 15:29:42 -04001273 dev->flags |= ATA_DFLAG_LBA48;
Tejun Heo4c2d7212006-03-05 17:55:58 +09001274 lba_desc = "LBA48";
1275 }
Albert Lee8bf62ec2005-05-12 15:29:42 -04001276
1277 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001278 if (print_info)
1279 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1280 "max %s, %Lu sectors: %s\n",
1281 ap->id, dev->devno,
Tejun Heo1148c3a2006-03-13 19:48:04 +09001282 ata_id_major_version(id),
Tejun Heoff8854b2006-03-06 04:31:56 +09001283 ata_mode_string(xfer_mask),
Tejun Heo4c2d7212006-03-05 17:55:58 +09001284 (unsigned long long)dev->n_sectors,
1285 lba_desc);
Tejun Heoffeae412006-03-01 16:09:35 +09001286 } else {
Albert Lee8bf62ec2005-05-12 15:29:42 -04001287 /* CHS */
1288
1289 /* Default translation */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001290 dev->cylinders = id[1];
1291 dev->heads = id[3];
1292 dev->sectors = id[6];
Albert Lee8bf62ec2005-05-12 15:29:42 -04001293
Tejun Heo1148c3a2006-03-13 19:48:04 +09001294 if (ata_id_current_chs_valid(id)) {
Albert Lee8bf62ec2005-05-12 15:29:42 -04001295 /* Current CHS translation is valid. */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001296 dev->cylinders = id[54];
1297 dev->heads = id[55];
1298 dev->sectors = id[56];
Albert Lee8bf62ec2005-05-12 15:29:42 -04001299 }
1300
1301 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001302 if (print_info)
1303 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1304 "max %s, %Lu sectors: CHS %u/%u/%u\n",
1305 ap->id, dev->devno,
Tejun Heo1148c3a2006-03-13 19:48:04 +09001306 ata_id_major_version(id),
Tejun Heoff8854b2006-03-06 04:31:56 +09001307 ata_mode_string(xfer_mask),
Tejun Heo4c2d7212006-03-05 17:55:58 +09001308 (unsigned long long)dev->n_sectors,
1309 dev->cylinders, dev->heads, dev->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 }
1311
Tejun Heo6e7846e2006-02-12 23:32:58 +09001312 dev->cdb_len = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 }
1314
1315 /* ATAPI-specific feature tests */
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05001316 else if (dev->class == ATA_DEV_ATAPI) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001317 rc = atapi_cdb_len(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1319 printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
Tejun Heoffeae412006-03-01 16:09:35 +09001320 rc = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 goto err_out_nosup;
1322 }
Tejun Heo6e7846e2006-02-12 23:32:58 +09001323 dev->cdb_len = (unsigned int) rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
1325 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001326 if (print_info)
1327 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
Tejun Heoff8854b2006-03-06 04:31:56 +09001328 ap->id, dev->devno, ata_mode_string(xfer_mask));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 }
1330
Tejun Heo6e7846e2006-02-12 23:32:58 +09001331 ap->host->max_cmd_len = 0;
1332 for (i = 0; i < ATA_MAX_DEVICES; i++)
1333 ap->host->max_cmd_len = max_t(unsigned int,
1334 ap->host->max_cmd_len,
1335 ap->device[i].cdb_len);
1336
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001337 /* limit bridge transfers to udma5, 200 sectors */
1338 if (ata_dev_knobble(ap, dev)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001339 if (print_info)
1340 printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
1341 ap->id, dev->devno);
Tejun Heo5a529132006-03-24 14:07:50 +09001342 dev->udma_mask &= ATA_UDMA5;
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001343 dev->max_sectors = ATA_MAX_SECTORS;
1344 }
1345
1346 if (ap->ops->dev_config)
1347 ap->ops->dev_config(ap, dev);
1348
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
Tejun Heoffeae412006-03-01 16:09:35 +09001350 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
1352err_out_nosup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 DPRINTK("EXIT, err\n");
Tejun Heoffeae412006-03-01 16:09:35 +09001354 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355}
1356
1357/**
1358 * ata_bus_probe - Reset and probe ATA bus
1359 * @ap: Bus to probe
1360 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001361 * Master ATA bus probing function. Initiates a hardware-dependent
1362 * bus reset, then attempts to identify any devices found on
1363 * the bus.
1364 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001366 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 *
1368 * RETURNS:
Tejun Heo96072e62006-04-01 01:38:17 +09001369 * Zero on success, negative errno otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 */
1371
1372static int ata_bus_probe(struct ata_port *ap)
1373{
Tejun Heo28ca5c52006-03-01 16:09:36 +09001374 unsigned int classes[ATA_MAX_DEVICES];
Tejun Heo14d2bac2006-04-02 17:54:46 +09001375 int tries[ATA_MAX_DEVICES];
1376 int i, rc, down_xfermask;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001377 struct ata_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
Tejun Heo28ca5c52006-03-01 16:09:36 +09001379 ata_port_probe(ap);
1380
Tejun Heo14d2bac2006-04-02 17:54:46 +09001381 for (i = 0; i < ATA_MAX_DEVICES; i++)
1382 tries[i] = ATA_PROBE_MAX_TRIES;
1383
1384 retry:
1385 down_xfermask = 0;
1386
Tejun Heo20444702006-03-13 01:57:01 +09001387 /* reset and determine device classes */
1388 for (i = 0; i < ATA_MAX_DEVICES; i++)
1389 classes[i] = ATA_DEV_UNKNOWN;
Tejun Heo2061a472006-03-12 00:57:39 +09001390
Tejun Heo20444702006-03-13 01:57:01 +09001391 if (ap->ops->probe_reset) {
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001392 rc = ap->ops->probe_reset(ap, classes);
Tejun Heo28ca5c52006-03-01 16:09:36 +09001393 if (rc) {
1394 printk("ata%u: reset failed (errno=%d)\n", ap->id, rc);
1395 return rc;
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001396 }
Tejun Heo28ca5c52006-03-01 16:09:36 +09001397 } else {
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001398 ap->ops->phy_reset(ap);
1399
Tejun Heof8c2c422006-05-15 20:57:30 +09001400 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1401 if (!(ap->flags & ATA_FLAG_DISABLED))
Tejun Heo28ca5c52006-03-01 16:09:36 +09001402 classes[i] = ap->device[i].class;
Tejun Heof8c2c422006-05-15 20:57:30 +09001403 ap->device[i].class = ATA_DEV_UNKNOWN;
1404 }
Tejun Heo20444702006-03-13 01:57:01 +09001405
Tejun Heo28ca5c52006-03-01 16:09:36 +09001406 ata_port_probe(ap);
1407 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
Tejun Heo20444702006-03-13 01:57:01 +09001409 for (i = 0; i < ATA_MAX_DEVICES; i++)
1410 if (classes[i] == ATA_DEV_UNKNOWN)
1411 classes[i] = ATA_DEV_NONE;
1412
Tejun Heo28ca5c52006-03-01 16:09:36 +09001413 /* read IDENTIFY page and configure devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001415 dev = &ap->device[i];
Tejun Heo28ca5c52006-03-01 16:09:36 +09001416
Tejun Heoec573752006-04-11 22:26:29 +09001417 if (tries[i])
1418 dev->class = classes[i];
Tejun Heo14d2bac2006-04-02 17:54:46 +09001419
Tejun Heoe1211e32006-04-01 01:38:18 +09001420 if (!ata_dev_enabled(dev))
Tejun Heoffeae412006-03-01 16:09:35 +09001421 continue;
1422
Tejun Heo14d2bac2006-04-02 17:54:46 +09001423 kfree(dev->id);
1424 dev->id = NULL;
1425 rc = ata_dev_read_id(ap, dev, &dev->class, 1, &dev->id);
1426 if (rc)
1427 goto fail;
Tejun Heoffeae412006-03-01 16:09:35 +09001428
Tejun Heo14d2bac2006-04-02 17:54:46 +09001429 rc = ata_dev_configure(ap, dev, 1);
1430 if (rc)
1431 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 }
1433
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001434 /* configure transfer mode */
1435 if (ap->ops->set_mode) {
1436 /* FIXME: make ->set_mode handle no device case and
1437 * return error code and failing device on failure as
1438 * ata_set_mode() does.
1439 */
Tejun Heo14d2bac2006-04-02 17:54:46 +09001440 for (i = 0; i < ATA_MAX_DEVICES; i++)
1441 if (ata_dev_enabled(&ap->device[i])) {
1442 ap->ops->set_mode(ap);
1443 break;
1444 }
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001445 rc = 0;
Tejun Heo51713d32006-04-11 22:26:29 +09001446 } else
Tejun Heo14d2bac2006-04-02 17:54:46 +09001447 rc = ata_set_mode(ap, &dev);
Tejun Heo51713d32006-04-11 22:26:29 +09001448
1449 if (rc) {
1450 down_xfermask = 1;
1451 goto fail;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001452 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001454 for (i = 0; i < ATA_MAX_DEVICES; i++)
1455 if (ata_dev_enabled(&ap->device[i]))
1456 return 0;
Alan Coxe35a9e02006-03-27 18:46:37 +01001457
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001458 /* no device present, disable port */
1459 ata_port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 ap->ops->port_disable(ap);
Tejun Heo96072e62006-04-01 01:38:17 +09001461 return -ENODEV;
Tejun Heo14d2bac2006-04-02 17:54:46 +09001462
1463 fail:
1464 switch (rc) {
1465 case -EINVAL:
1466 case -ENODEV:
1467 tries[dev->devno] = 0;
1468 break;
1469 case -EIO:
Tejun Heo3c567b72006-05-15 20:57:23 +09001470 sata_down_spd_limit(ap);
Tejun Heo14d2bac2006-04-02 17:54:46 +09001471 /* fall through */
1472 default:
1473 tries[dev->devno]--;
1474 if (down_xfermask &&
1475 ata_down_xfermask_limit(ap, dev, tries[dev->devno] == 1))
1476 tries[dev->devno] = 0;
1477 }
1478
Tejun Heoec573752006-04-11 22:26:29 +09001479 if (!tries[dev->devno]) {
1480 ata_down_xfermask_limit(ap, dev, 1);
1481 ata_dev_disable(ap, dev);
1482 }
1483
Tejun Heo14d2bac2006-04-02 17:54:46 +09001484 goto retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485}
1486
1487/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04001488 * ata_port_probe - Mark port as enabled
1489 * @ap: Port for which we indicate enablement
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001491 * Modify @ap data structure such that the system
1492 * thinks that the entire port is enabled.
1493 *
1494 * LOCKING: host_set lock, or some other form of
1495 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 */
1497
1498void ata_port_probe(struct ata_port *ap)
1499{
Tejun Heo198e0fe2006-04-02 18:51:52 +09001500 ap->flags &= ~ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501}
1502
1503/**
Tejun Heo3be680b2005-12-19 22:35:02 +09001504 * sata_print_link_status - Print SATA link status
1505 * @ap: SATA port to printk link status about
1506 *
1507 * This function prints link speed and status of a SATA link.
1508 *
1509 * LOCKING:
1510 * None.
1511 */
1512static void sata_print_link_status(struct ata_port *ap)
1513{
Tejun Heo6d5f9732006-04-03 00:09:41 +09001514 u32 sstatus, scontrol, tmp;
Tejun Heo3be680b2005-12-19 22:35:02 +09001515
1516 if (!ap->ops->scr_read)
1517 return;
1518
1519 sstatus = scr_read(ap, SCR_STATUS);
Tejun Heo6d5f9732006-04-03 00:09:41 +09001520 scontrol = scr_read(ap, SCR_CONTROL);
Tejun Heo3be680b2005-12-19 22:35:02 +09001521
1522 if (sata_dev_present(ap)) {
1523 tmp = (sstatus >> 4) & 0xf;
Tejun Heo6d5f9732006-04-03 00:09:41 +09001524 printk(KERN_INFO
1525 "ata%u: SATA link up %s (SStatus %X SControl %X)\n",
1526 ap->id, sata_spd_string(tmp), sstatus, scontrol);
Tejun Heo3be680b2005-12-19 22:35:02 +09001527 } else {
Tejun Heo6d5f9732006-04-03 00:09:41 +09001528 printk(KERN_INFO
1529 "ata%u: SATA link down (SStatus %X SControl %X)\n",
1530 ap->id, sstatus, scontrol);
Tejun Heo3be680b2005-12-19 22:35:02 +09001531 }
1532}
1533
1534/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001535 * __sata_phy_reset - Wake/reset a low-level SATA PHY
1536 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001538 * This function issues commands to standard SATA Sxxx
1539 * PHY registers, to wake up the phy (and device), and
1540 * clear any reset condition.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 *
1542 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001543 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 *
1545 */
1546void __sata_phy_reset(struct ata_port *ap)
1547{
1548 u32 sstatus;
1549 unsigned long timeout = jiffies + (HZ * 5);
1550
1551 if (ap->flags & ATA_FLAG_SATA_RESET) {
Brett Russcdcca892005-03-28 15:10:27 -05001552 /* issue phy wake/reset */
1553 scr_write_flush(ap, SCR_CONTROL, 0x301);
Tejun Heo62ba2842005-06-26 23:27:19 +09001554 /* Couldn't find anything in SATA I/II specs, but
1555 * AHCI-1.1 10.4.2 says at least 1 ms. */
1556 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 }
Brett Russcdcca892005-03-28 15:10:27 -05001558 scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559
1560 /* wait for phy to become ready, if necessary */
1561 do {
1562 msleep(200);
1563 sstatus = scr_read(ap, SCR_STATUS);
1564 if ((sstatus & 0xf) != 1)
1565 break;
1566 } while (time_before(jiffies, timeout));
1567
Tejun Heo3be680b2005-12-19 22:35:02 +09001568 /* print link status */
1569 sata_print_link_status(ap);
Jeff Garzik656563e2005-11-20 03:36:45 -05001570
Tejun Heo3be680b2005-12-19 22:35:02 +09001571 /* TODO: phy layer with polling, timeouts, etc. */
1572 if (sata_dev_present(ap))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 ata_port_probe(ap);
Tejun Heo3be680b2005-12-19 22:35:02 +09001574 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 ata_port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
Tejun Heo198e0fe2006-04-02 18:51:52 +09001577 if (ap->flags & ATA_FLAG_DISABLED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 return;
1579
1580 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1581 ata_port_disable(ap);
1582 return;
1583 }
1584
1585 ap->cbl = ATA_CBL_SATA;
1586}
1587
1588/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001589 * sata_phy_reset - Reset SATA bus.
1590 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001592 * This function resets the SATA bus, and then probes
1593 * the bus for devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 *
1595 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001596 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 *
1598 */
1599void sata_phy_reset(struct ata_port *ap)
1600{
1601 __sata_phy_reset(ap);
Tejun Heo198e0fe2006-04-02 18:51:52 +09001602 if (ap->flags & ATA_FLAG_DISABLED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 return;
1604 ata_bus_reset(ap);
1605}
1606
1607/**
Alan Coxebdfca62006-03-23 15:38:34 +00001608 * ata_dev_pair - return other device on cable
1609 * @ap: port
1610 * @adev: device
1611 *
1612 * Obtain the other device on the same cable, or if none is
1613 * present NULL is returned
1614 */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001615
Alan Coxebdfca62006-03-23 15:38:34 +00001616struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
1617{
1618 struct ata_device *pair = &ap->device[1 - adev->devno];
Tejun Heoe1211e32006-04-01 01:38:18 +09001619 if (!ata_dev_enabled(pair))
Alan Coxebdfca62006-03-23 15:38:34 +00001620 return NULL;
1621 return pair;
1622}
1623
1624/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001625 * ata_port_disable - Disable port.
1626 * @ap: Port to be disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001628 * Modify @ap data structure such that the system
1629 * thinks that the entire port is disabled, and should
1630 * never attempt to probe or communicate with devices
1631 * on this port.
1632 *
1633 * LOCKING: host_set lock, or some other form of
1634 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 */
1636
1637void ata_port_disable(struct ata_port *ap)
1638{
1639 ap->device[0].class = ATA_DEV_NONE;
1640 ap->device[1].class = ATA_DEV_NONE;
Tejun Heo198e0fe2006-04-02 18:51:52 +09001641 ap->flags |= ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642}
1643
Tejun Heo1c3fae42006-04-02 20:53:28 +09001644/**
Tejun Heo3c567b72006-05-15 20:57:23 +09001645 * sata_down_spd_limit - adjust SATA spd limit downward
Tejun Heo1c3fae42006-04-02 20:53:28 +09001646 * @ap: Port to adjust SATA spd limit for
1647 *
1648 * Adjust SATA spd limit of @ap downward. Note that this
1649 * function only adjusts the limit. The change must be applied
Tejun Heo3c567b72006-05-15 20:57:23 +09001650 * using sata_set_spd().
Tejun Heo1c3fae42006-04-02 20:53:28 +09001651 *
1652 * LOCKING:
1653 * Inherited from caller.
1654 *
1655 * RETURNS:
1656 * 0 on success, negative errno on failure
1657 */
Tejun Heo3c567b72006-05-15 20:57:23 +09001658int sata_down_spd_limit(struct ata_port *ap)
Tejun Heo1c3fae42006-04-02 20:53:28 +09001659{
1660 u32 spd, mask;
1661 int highbit;
1662
1663 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1664 return -EOPNOTSUPP;
1665
1666 mask = ap->sata_spd_limit;
1667 if (mask <= 1)
1668 return -EINVAL;
1669 highbit = fls(mask) - 1;
1670 mask &= ~(1 << highbit);
1671
1672 spd = (scr_read(ap, SCR_STATUS) >> 4) & 0xf;
1673 if (spd <= 1)
1674 return -EINVAL;
1675 spd--;
1676 mask &= (1 << spd) - 1;
1677 if (!mask)
1678 return -EINVAL;
1679
1680 ap->sata_spd_limit = mask;
1681
1682 printk(KERN_WARNING "ata%u: limiting SATA link speed to %s\n",
1683 ap->id, sata_spd_string(fls(mask)));
1684
1685 return 0;
1686}
1687
Tejun Heo3c567b72006-05-15 20:57:23 +09001688static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
Tejun Heo1c3fae42006-04-02 20:53:28 +09001689{
1690 u32 spd, limit;
1691
1692 if (ap->sata_spd_limit == UINT_MAX)
1693 limit = 0;
1694 else
1695 limit = fls(ap->sata_spd_limit);
1696
1697 spd = (*scontrol >> 4) & 0xf;
1698 *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
1699
1700 return spd != limit;
1701}
1702
1703/**
Tejun Heo3c567b72006-05-15 20:57:23 +09001704 * sata_set_spd_needed - is SATA spd configuration needed
Tejun Heo1c3fae42006-04-02 20:53:28 +09001705 * @ap: Port in question
1706 *
1707 * Test whether the spd limit in SControl matches
1708 * @ap->sata_spd_limit. This function is used to determine
1709 * whether hardreset is necessary to apply SATA spd
1710 * configuration.
1711 *
1712 * LOCKING:
1713 * Inherited from caller.
1714 *
1715 * RETURNS:
1716 * 1 if SATA spd configuration is needed, 0 otherwise.
1717 */
Tejun Heo3c567b72006-05-15 20:57:23 +09001718int sata_set_spd_needed(struct ata_port *ap)
Tejun Heo1c3fae42006-04-02 20:53:28 +09001719{
1720 u32 scontrol;
1721
1722 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1723 return 0;
1724
1725 scontrol = scr_read(ap, SCR_CONTROL);
1726
Tejun Heo3c567b72006-05-15 20:57:23 +09001727 return __sata_set_spd_needed(ap, &scontrol);
Tejun Heo1c3fae42006-04-02 20:53:28 +09001728}
1729
1730/**
Tejun Heo3c567b72006-05-15 20:57:23 +09001731 * sata_set_spd - set SATA spd according to spd limit
Tejun Heo1c3fae42006-04-02 20:53:28 +09001732 * @ap: Port to set SATA spd for
1733 *
1734 * Set SATA spd of @ap according to sata_spd_limit.
1735 *
1736 * LOCKING:
1737 * Inherited from caller.
1738 *
1739 * RETURNS:
1740 * 0 if spd doesn't need to be changed, 1 if spd has been
1741 * changed. -EOPNOTSUPP if SCR registers are inaccessible.
1742 */
Tejun Heo3c567b72006-05-15 20:57:23 +09001743int sata_set_spd(struct ata_port *ap)
Tejun Heo1c3fae42006-04-02 20:53:28 +09001744{
1745 u32 scontrol;
1746
1747 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1748 return -EOPNOTSUPP;
1749
1750 scontrol = scr_read(ap, SCR_CONTROL);
Tejun Heo3c567b72006-05-15 20:57:23 +09001751 if (!__sata_set_spd_needed(ap, &scontrol))
Tejun Heo1c3fae42006-04-02 20:53:28 +09001752 return 0;
1753
1754 scr_write(ap, SCR_CONTROL, scontrol);
1755 return 1;
1756}
1757
Alan Cox452503f2005-10-21 19:01:32 -04001758/*
1759 * This mode timing computation functionality is ported over from
1760 * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
1761 */
1762/*
1763 * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
1764 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
1765 * for PIO 5, which is a nonstandard extension and UDMA6, which
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001766 * is currently supported only by Maxtor drives.
Alan Cox452503f2005-10-21 19:01:32 -04001767 */
1768
1769static const struct ata_timing ata_timing[] = {
1770
1771 { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 },
1772 { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 },
1773 { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 },
1774 { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 },
1775
1776 { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 },
1777 { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 },
1778 { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 },
1779
1780/* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001781
Alan Cox452503f2005-10-21 19:01:32 -04001782 { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 },
1783 { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 },
1784 { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 },
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001785
Alan Cox452503f2005-10-21 19:01:32 -04001786 { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 },
1787 { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 },
1788 { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 },
1789
1790/* { XFER_PIO_5, 20, 50, 30, 100, 50, 30, 100, 0 }, */
1791 { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 },
1792 { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 },
1793
1794 { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 },
1795 { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 },
1796 { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 },
1797
1798/* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */
1799
1800 { 0xFF }
1801};
1802
1803#define ENOUGH(v,unit) (((v)-1)/(unit)+1)
1804#define EZ(v,unit) ((v)?ENOUGH(v,unit):0)
1805
1806static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
1807{
1808 q->setup = EZ(t->setup * 1000, T);
1809 q->act8b = EZ(t->act8b * 1000, T);
1810 q->rec8b = EZ(t->rec8b * 1000, T);
1811 q->cyc8b = EZ(t->cyc8b * 1000, T);
1812 q->active = EZ(t->active * 1000, T);
1813 q->recover = EZ(t->recover * 1000, T);
1814 q->cycle = EZ(t->cycle * 1000, T);
1815 q->udma = EZ(t->udma * 1000, UT);
1816}
1817
1818void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
1819 struct ata_timing *m, unsigned int what)
1820{
1821 if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup);
1822 if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b);
1823 if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b);
1824 if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b);
1825 if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active);
1826 if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
1827 if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle);
1828 if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma);
1829}
1830
1831static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
1832{
1833 const struct ata_timing *t;
1834
1835 for (t = ata_timing; t->mode != speed; t++)
Alan Cox91190752005-10-26 12:17:46 -04001836 if (t->mode == 0xFF)
Alan Cox452503f2005-10-21 19:01:32 -04001837 return NULL;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001838 return t;
Alan Cox452503f2005-10-21 19:01:32 -04001839}
1840
1841int ata_timing_compute(struct ata_device *adev, unsigned short speed,
1842 struct ata_timing *t, int T, int UT)
1843{
1844 const struct ata_timing *s;
1845 struct ata_timing p;
1846
1847 /*
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001848 * Find the mode.
Albert Lee75b1f2f2005-11-16 17:06:18 +08001849 */
Alan Cox452503f2005-10-21 19:01:32 -04001850
1851 if (!(s = ata_timing_find_mode(speed)))
1852 return -EINVAL;
1853
Albert Lee75b1f2f2005-11-16 17:06:18 +08001854 memcpy(t, s, sizeof(*s));
1855
Alan Cox452503f2005-10-21 19:01:32 -04001856 /*
1857 * If the drive is an EIDE drive, it can tell us it needs extended
1858 * PIO/MW_DMA cycle timing.
1859 */
1860
1861 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
1862 memset(&p, 0, sizeof(p));
1863 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
1864 if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
1865 else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
1866 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
1867 p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
1868 }
1869 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
1870 }
1871
1872 /*
1873 * Convert the timing to bus clock counts.
1874 */
1875
Albert Lee75b1f2f2005-11-16 17:06:18 +08001876 ata_timing_quantize(t, t, T, UT);
Alan Cox452503f2005-10-21 19:01:32 -04001877
1878 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001879 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
1880 * S.M.A.R.T * and some other commands. We have to ensure that the
1881 * DMA cycle timing is slower/equal than the fastest PIO timing.
Alan Cox452503f2005-10-21 19:01:32 -04001882 */
1883
1884 if (speed > XFER_PIO_4) {
1885 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
1886 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
1887 }
1888
1889 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001890 * Lengthen active & recovery time so that cycle time is correct.
Alan Cox452503f2005-10-21 19:01:32 -04001891 */
1892
1893 if (t->act8b + t->rec8b < t->cyc8b) {
1894 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
1895 t->rec8b = t->cyc8b - t->act8b;
1896 }
1897
1898 if (t->active + t->recover < t->cycle) {
1899 t->active += (t->cycle - (t->active + t->recover)) / 2;
1900 t->recover = t->cycle - t->active;
1901 }
1902
1903 return 0;
1904}
1905
Tejun Heocf176e12006-04-02 17:54:46 +09001906/**
1907 * ata_down_xfermask_limit - adjust dev xfer masks downward
1908 * @ap: Port associated with device @dev
1909 * @dev: Device to adjust xfer masks
1910 * @force_pio0: Force PIO0
1911 *
1912 * Adjust xfer masks of @dev downward. Note that this function
1913 * does not apply the change. Invoking ata_set_mode() afterwards
1914 * will apply the limit.
1915 *
1916 * LOCKING:
1917 * Inherited from caller.
1918 *
1919 * RETURNS:
1920 * 0 on success, negative errno on failure
1921 */
Tejun Heo1ad8e7f2006-04-02 18:51:53 +09001922int ata_down_xfermask_limit(struct ata_port *ap, struct ata_device *dev,
1923 int force_pio0)
Tejun Heocf176e12006-04-02 17:54:46 +09001924{
1925 unsigned long xfer_mask;
1926 int highbit;
1927
1928 xfer_mask = ata_pack_xfermask(dev->pio_mask, dev->mwdma_mask,
1929 dev->udma_mask);
1930
1931 if (!xfer_mask)
1932 goto fail;
1933 /* don't gear down to MWDMA from UDMA, go directly to PIO */
1934 if (xfer_mask & ATA_MASK_UDMA)
1935 xfer_mask &= ~ATA_MASK_MWDMA;
1936
1937 highbit = fls(xfer_mask) - 1;
1938 xfer_mask &= ~(1 << highbit);
1939 if (force_pio0)
1940 xfer_mask &= 1 << ATA_SHIFT_PIO;
1941 if (!xfer_mask)
1942 goto fail;
1943
1944 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
1945 &dev->udma_mask);
1946
1947 printk(KERN_WARNING "ata%u: dev %u limiting speed to %s\n",
1948 ap->id, dev->devno, ata_mode_string(xfer_mask));
1949
1950 return 0;
1951
1952 fail:
1953 return -EINVAL;
1954}
1955
Tejun Heo83206a22006-03-24 15:25:31 +09001956static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957{
Tejun Heo83206a22006-03-24 15:25:31 +09001958 unsigned int err_mask;
1959 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960
Tejun Heoe8384602006-04-02 18:51:53 +09001961 dev->flags &= ~ATA_DFLAG_PIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 if (dev->xfer_shift == ATA_SHIFT_PIO)
1963 dev->flags |= ATA_DFLAG_PIO;
1964
Tejun Heo83206a22006-03-24 15:25:31 +09001965 err_mask = ata_dev_set_xfermode(ap, dev);
1966 if (err_mask) {
1967 printk(KERN_ERR
1968 "ata%u: failed to set xfermode (err_mask=0x%x)\n",
1969 ap->id, err_mask);
1970 return -EIO;
1971 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
Tejun Heo83206a22006-03-24 15:25:31 +09001973 rc = ata_dev_revalidate(ap, dev, 0);
Tejun Heo5eb45c02006-04-02 18:51:52 +09001974 if (rc)
Tejun Heo83206a22006-03-24 15:25:31 +09001975 return rc;
Tejun Heo48a8a142006-03-05 17:55:58 +09001976
Tejun Heo23e71c32006-03-06 04:31:57 +09001977 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
1978 dev->xfer_shift, (int)dev->xfer_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
1980 printk(KERN_INFO "ata%u: dev %u configured for %s\n",
Tejun Heo23e71c32006-03-06 04:31:57 +09001981 ap->id, dev->devno,
1982 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
Tejun Heo83206a22006-03-24 15:25:31 +09001983 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984}
1985
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986/**
1987 * ata_set_mode - Program timings and issue SET FEATURES - XFER
1988 * @ap: port on which timings will be programmed
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001989 * @r_failed_dev: out paramter for failed device
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 *
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001991 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
1992 * ata_set_mode() fails, pointer to the failing device is
1993 * returned in @r_failed_dev.
Jeff Garzik780a87f2005-05-30 15:41:05 -04001994 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001996 * PCI/etc. bus probe sem.
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001997 *
1998 * RETURNS:
1999 * 0 on success, negative errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 */
Tejun Heo1ad8e7f2006-04-02 18:51:53 +09002001int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002{
Tejun Heoe8e06192006-04-01 01:38:18 +09002003 struct ata_device *dev;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002004 int i, rc = 0, used_dma = 0, found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005
Tejun Heoa6d5a512006-03-06 04:31:57 +09002006 /* step 1: calculate xfer_mask */
2007 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoacf356b2006-03-24 14:07:50 +09002008 unsigned int pio_mask, dma_mask;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002009
Tejun Heoe8e06192006-04-01 01:38:18 +09002010 dev = &ap->device[i];
2011
Tejun Heoe1211e32006-04-01 01:38:18 +09002012 if (!ata_dev_enabled(dev))
Tejun Heoa6d5a512006-03-06 04:31:57 +09002013 continue;
2014
Tejun Heoacf356b2006-03-24 14:07:50 +09002015 ata_dev_xfermask(ap, dev);
Tejun Heoa6d5a512006-03-06 04:31:57 +09002016
Tejun Heoacf356b2006-03-24 14:07:50 +09002017 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
2018 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
2019 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
2020 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
Alan Cox5444a6f2006-03-27 18:58:20 +01002021
Tejun Heo4f659772006-04-01 01:38:18 +09002022 found = 1;
Alan Cox5444a6f2006-03-27 18:58:20 +01002023 if (dev->dma_mode)
2024 used_dma = 1;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002025 }
Tejun Heo4f659772006-04-01 01:38:18 +09002026 if (!found)
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002027 goto out;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002028
2029 /* step 2: always set host PIO timings */
Tejun Heoe8e06192006-04-01 01:38:18 +09002030 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2031 dev = &ap->device[i];
2032 if (!ata_dev_enabled(dev))
2033 continue;
2034
2035 if (!dev->pio_mode) {
2036 printk(KERN_WARNING "ata%u: dev %u no PIO support\n",
2037 ap->id, dev->devno);
2038 rc = -EINVAL;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002039 goto out;
Tejun Heoe8e06192006-04-01 01:38:18 +09002040 }
2041
2042 dev->xfer_mode = dev->pio_mode;
2043 dev->xfer_shift = ATA_SHIFT_PIO;
2044 if (ap->ops->set_piomode)
2045 ap->ops->set_piomode(ap, dev);
2046 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047
Tejun Heoa6d5a512006-03-06 04:31:57 +09002048 /* step 3: set host DMA timings */
Tejun Heoe8e06192006-04-01 01:38:18 +09002049 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2050 dev = &ap->device[i];
2051
2052 if (!ata_dev_enabled(dev) || !dev->dma_mode)
2053 continue;
2054
2055 dev->xfer_mode = dev->dma_mode;
2056 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
2057 if (ap->ops->set_dmamode)
2058 ap->ops->set_dmamode(ap, dev);
2059 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060
2061 /* step 4: update devices' xfer mode */
Tejun Heo83206a22006-03-24 15:25:31 +09002062 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoe8e06192006-04-01 01:38:18 +09002063 dev = &ap->device[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064
Tejun Heoe1211e32006-04-01 01:38:18 +09002065 if (!ata_dev_enabled(dev))
Tejun Heo83206a22006-03-24 15:25:31 +09002066 continue;
2067
Tejun Heo5bbc53f2006-04-01 01:38:17 +09002068 rc = ata_dev_set_mode(ap, dev);
2069 if (rc)
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002070 goto out;
Tejun Heo83206a22006-03-24 15:25:31 +09002071 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072
Tejun Heoe8e06192006-04-01 01:38:18 +09002073 /* Record simplex status. If we selected DMA then the other
2074 * host channels are not permitted to do so.
Alan Cox5444a6f2006-03-27 18:58:20 +01002075 */
Alan Cox5444a6f2006-03-27 18:58:20 +01002076 if (used_dma && (ap->host_set->flags & ATA_HOST_SIMPLEX))
2077 ap->host_set->simplex_claimed = 1;
2078
Tejun Heoe8e06192006-04-01 01:38:18 +09002079 /* step5: chip specific finalisation */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 if (ap->ops->post_set_mode)
2081 ap->ops->post_set_mode(ap);
2082
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002083 out:
2084 if (rc)
2085 *r_failed_dev = dev;
2086 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087}
2088
2089/**
Jeff Garzik1fdffbc2006-02-09 05:15:27 -05002090 * ata_tf_to_host - issue ATA taskfile to host controller
2091 * @ap: port to which command is being issued
2092 * @tf: ATA taskfile register set
2093 *
2094 * Issues ATA taskfile register set to ATA host controller,
2095 * with proper synchronization with interrupt handler and
2096 * other threads.
2097 *
2098 * LOCKING:
2099 * spin_lock_irqsave(host_set lock)
2100 */
2101
2102static inline void ata_tf_to_host(struct ata_port *ap,
2103 const struct ata_taskfile *tf)
2104{
2105 ap->ops->tf_load(ap, tf);
2106 ap->ops->exec_command(ap, tf);
2107}
2108
2109/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 * ata_busy_sleep - sleep until BSY clears, or timeout
2111 * @ap: port containing status register to be polled
2112 * @tmout_pat: impatience timeout
2113 * @tmout: overall timeout
2114 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002115 * Sleep until ATA Status register bit BSY clears,
2116 * or a timeout occurs.
2117 *
2118 * LOCKING: None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 */
2120
Tejun Heo6f8b9952006-01-24 17:05:21 +09002121unsigned int ata_busy_sleep (struct ata_port *ap,
2122 unsigned long tmout_pat, unsigned long tmout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123{
2124 unsigned long timer_start, timeout;
2125 u8 status;
2126
2127 status = ata_busy_wait(ap, ATA_BUSY, 300);
2128 timer_start = jiffies;
2129 timeout = timer_start + tmout_pat;
2130 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2131 msleep(50);
2132 status = ata_busy_wait(ap, ATA_BUSY, 3);
2133 }
2134
2135 if (status & ATA_BUSY)
2136 printk(KERN_WARNING "ata%u is slow to respond, "
2137 "please be patient\n", ap->id);
2138
2139 timeout = timer_start + tmout;
2140 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2141 msleep(50);
2142 status = ata_chk_status(ap);
2143 }
2144
2145 if (status & ATA_BUSY) {
2146 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
2147 ap->id, tmout / HZ);
2148 return 1;
2149 }
2150
2151 return 0;
2152}
2153
2154static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
2155{
2156 struct ata_ioports *ioaddr = &ap->ioaddr;
2157 unsigned int dev0 = devmask & (1 << 0);
2158 unsigned int dev1 = devmask & (1 << 1);
2159 unsigned long timeout;
2160
2161 /* if device 0 was found in ata_devchk, wait for its
2162 * BSY bit to clear
2163 */
2164 if (dev0)
2165 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2166
2167 /* if device 1 was found in ata_devchk, wait for
2168 * register access, then wait for BSY to clear
2169 */
2170 timeout = jiffies + ATA_TMOUT_BOOT;
2171 while (dev1) {
2172 u8 nsect, lbal;
2173
2174 ap->ops->dev_select(ap, 1);
2175 if (ap->flags & ATA_FLAG_MMIO) {
2176 nsect = readb((void __iomem *) ioaddr->nsect_addr);
2177 lbal = readb((void __iomem *) ioaddr->lbal_addr);
2178 } else {
2179 nsect = inb(ioaddr->nsect_addr);
2180 lbal = inb(ioaddr->lbal_addr);
2181 }
2182 if ((nsect == 1) && (lbal == 1))
2183 break;
2184 if (time_after(jiffies, timeout)) {
2185 dev1 = 0;
2186 break;
2187 }
2188 msleep(50); /* give drive a breather */
2189 }
2190 if (dev1)
2191 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2192
2193 /* is all this really necessary? */
2194 ap->ops->dev_select(ap, 0);
2195 if (dev1)
2196 ap->ops->dev_select(ap, 1);
2197 if (dev0)
2198 ap->ops->dev_select(ap, 0);
2199}
2200
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201static unsigned int ata_bus_softreset(struct ata_port *ap,
2202 unsigned int devmask)
2203{
2204 struct ata_ioports *ioaddr = &ap->ioaddr;
2205
2206 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
2207
2208 /* software reset. causes dev0 to be selected */
2209 if (ap->flags & ATA_FLAG_MMIO) {
2210 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2211 udelay(20); /* FIXME: flush */
2212 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
2213 udelay(20); /* FIXME: flush */
2214 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2215 } else {
2216 outb(ap->ctl, ioaddr->ctl_addr);
2217 udelay(10);
2218 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2219 udelay(10);
2220 outb(ap->ctl, ioaddr->ctl_addr);
2221 }
2222
2223 /* spec mandates ">= 2ms" before checking status.
2224 * We wait 150ms, because that was the magic delay used for
2225 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
2226 * between when the ATA command register is written, and then
2227 * status is checked. Because waiting for "a while" before
2228 * checking status is fine, post SRST, we perform this magic
2229 * delay here as well.
Alan Cox09c7ad72006-03-22 15:52:40 +00002230 *
2231 * Old drivers/ide uses the 2mS rule and then waits for ready
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 */
2233 msleep(150);
2234
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002235 /* Before we perform post reset processing we want to see if
Tejun Heo298a41c2006-03-25 02:58:13 +09002236 * the bus shows 0xFF because the odd clown forgets the D7
2237 * pulldown resistor.
2238 */
Tejun Heo987d2f02006-04-11 22:16:45 +09002239 if (ata_check_status(ap) == 0xFF) {
2240 printk(KERN_ERR "ata%u: SRST failed (status 0xFF)\n", ap->id);
Tejun Heo298a41c2006-03-25 02:58:13 +09002241 return AC_ERR_OTHER;
Tejun Heo987d2f02006-04-11 22:16:45 +09002242 }
Alan Cox09c7ad72006-03-22 15:52:40 +00002243
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 ata_bus_post_reset(ap, devmask);
2245
2246 return 0;
2247}
2248
2249/**
2250 * ata_bus_reset - reset host port and associated ATA channel
2251 * @ap: port to reset
2252 *
2253 * This is typically the first time we actually start issuing
2254 * commands to the ATA channel. We wait for BSY to clear, then
2255 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
2256 * result. Determine what devices, if any, are on the channel
2257 * by looking at the device 0/1 error register. Look at the signature
2258 * stored in each device's taskfile registers, to determine if
2259 * the device is ATA or ATAPI.
2260 *
2261 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002262 * PCI/etc. bus probe sem.
2263 * Obtains host_set lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 *
2265 * SIDE EFFECTS:
Tejun Heo198e0fe2006-04-02 18:51:52 +09002266 * Sets ATA_FLAG_DISABLED if bus reset fails.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 */
2268
2269void ata_bus_reset(struct ata_port *ap)
2270{
2271 struct ata_ioports *ioaddr = &ap->ioaddr;
2272 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2273 u8 err;
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002274 unsigned int dev0, dev1 = 0, devmask = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275
2276 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
2277
2278 /* determine if device 0/1 are present */
2279 if (ap->flags & ATA_FLAG_SATA_RESET)
2280 dev0 = 1;
2281 else {
2282 dev0 = ata_devchk(ap, 0);
2283 if (slave_possible)
2284 dev1 = ata_devchk(ap, 1);
2285 }
2286
2287 if (dev0)
2288 devmask |= (1 << 0);
2289 if (dev1)
2290 devmask |= (1 << 1);
2291
2292 /* select device 0 again */
2293 ap->ops->dev_select(ap, 0);
2294
2295 /* issue bus reset */
2296 if (ap->flags & ATA_FLAG_SRST)
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002297 if (ata_bus_softreset(ap, devmask))
2298 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299
2300 /*
2301 * determine by signature whether we have ATA or ATAPI devices
2302 */
Tejun Heob4dc7622006-01-24 17:05:22 +09002303 ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 if ((slave_possible) && (err != 0x81))
Tejun Heob4dc7622006-01-24 17:05:22 +09002305 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306
2307 /* re-enable interrupts */
2308 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2309 ata_irq_on(ap);
2310
2311 /* is double-select really necessary? */
2312 if (ap->device[1].class != ATA_DEV_NONE)
2313 ap->ops->dev_select(ap, 1);
2314 if (ap->device[0].class != ATA_DEV_NONE)
2315 ap->ops->dev_select(ap, 0);
2316
2317 /* if no devices were detected, disable this port */
2318 if ((ap->device[0].class == ATA_DEV_NONE) &&
2319 (ap->device[1].class == ATA_DEV_NONE))
2320 goto err_out;
2321
2322 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2323 /* set up device control for ATA_FLAG_SATA_RESET */
2324 if (ap->flags & ATA_FLAG_MMIO)
2325 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2326 else
2327 outb(ap->ctl, ioaddr->ctl_addr);
2328 }
2329
2330 DPRINTK("EXIT\n");
2331 return;
2332
2333err_out:
2334 printk(KERN_ERR "ata%u: disabling port\n", ap->id);
2335 ap->ops->port_disable(ap);
2336
2337 DPRINTK("EXIT\n");
2338}
2339
Tejun Heo7a7921e2006-02-02 18:20:00 +09002340static int sata_phy_resume(struct ata_port *ap)
2341{
2342 unsigned long timeout = jiffies + (HZ * 5);
Tejun Heo852ee162006-04-01 01:38:18 +09002343 u32 scontrol, sstatus;
Tejun Heo7a7921e2006-02-02 18:20:00 +09002344
Tejun Heo852ee162006-04-01 01:38:18 +09002345 scontrol = scr_read(ap, SCR_CONTROL);
2346 scontrol = (scontrol & 0x0f0) | 0x300;
2347 scr_write_flush(ap, SCR_CONTROL, scontrol);
Tejun Heo7a7921e2006-02-02 18:20:00 +09002348
2349 /* Wait for phy to become ready, if necessary. */
2350 do {
2351 msleep(200);
2352 sstatus = scr_read(ap, SCR_STATUS);
2353 if ((sstatus & 0xf) != 1)
2354 return 0;
2355 } while (time_before(jiffies, timeout));
2356
2357 return -1;
2358}
2359
Tejun Heoc2bd5802006-01-24 17:05:22 +09002360/**
Tejun Heo8a19ac82006-02-02 18:20:00 +09002361 * ata_std_probeinit - initialize probing
2362 * @ap: port to be probed
2363 *
2364 * @ap is about to be probed. Initialize it. This function is
2365 * to be used as standard callback for ata_drive_probe_reset().
Tejun Heo3a397462006-02-10 23:58:48 +09002366 *
2367 * NOTE!!! Do not use this function as probeinit if a low level
2368 * driver implements only hardreset. Just pass NULL as probeinit
2369 * in that case. Using this function is probably okay but doing
2370 * so makes reset sequence different from the original
2371 * ->phy_reset implementation and Jeff nervous. :-P
Tejun Heo8a19ac82006-02-02 18:20:00 +09002372 */
Alan Cox17efc5f2006-03-27 19:01:32 +01002373void ata_std_probeinit(struct ata_port *ap)
Tejun Heo8a19ac82006-02-02 18:20:00 +09002374{
Alan Cox17efc5f2006-03-27 19:01:32 +01002375 if ((ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read) {
Tejun Heo1c3fae42006-04-02 20:53:28 +09002376 u32 spd;
2377
Tejun Heodb70fef2006-04-11 22:16:44 +09002378 /* set cable type and resume link */
2379 ap->cbl = ATA_CBL_SATA;
Tejun Heo8a19ac82006-02-02 18:20:00 +09002380 sata_phy_resume(ap);
Tejun Heo1c3fae42006-04-02 20:53:28 +09002381
Tejun Heodb70fef2006-04-11 22:16:44 +09002382 /* init sata_spd_limit to the current value */
Tejun Heo1c3fae42006-04-02 20:53:28 +09002383 spd = (scr_read(ap, SCR_CONTROL) & 0xf0) >> 4;
2384 if (spd)
2385 ap->sata_spd_limit &= (1 << spd) - 1;
2386
Tejun Heodb70fef2006-04-11 22:16:44 +09002387 /* wait for device */
Tejun Heo3a397462006-02-10 23:58:48 +09002388 if (sata_dev_present(ap))
2389 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2390 }
Tejun Heo8a19ac82006-02-02 18:20:00 +09002391}
2392
2393/**
Tejun Heoc2bd5802006-01-24 17:05:22 +09002394 * ata_std_softreset - reset host port via ATA SRST
2395 * @ap: port to reset
Tejun Heoc2bd5802006-01-24 17:05:22 +09002396 * @classes: resulting classes of attached devices
2397 *
2398 * Reset host port using ATA SRST. This function is to be used
2399 * as standard callback for ata_drive_*_reset() functions.
2400 *
2401 * LOCKING:
2402 * Kernel thread context (may sleep)
2403 *
2404 * RETURNS:
2405 * 0 on success, -errno otherwise.
2406 */
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002407int ata_std_softreset(struct ata_port *ap, unsigned int *classes)
Tejun Heoc2bd5802006-01-24 17:05:22 +09002408{
2409 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2410 unsigned int devmask = 0, err_mask;
2411 u8 err;
2412
2413 DPRINTK("ENTER\n");
2414
Tejun Heo3a397462006-02-10 23:58:48 +09002415 if (ap->ops->scr_read && !sata_dev_present(ap)) {
2416 classes[0] = ATA_DEV_NONE;
2417 goto out;
2418 }
2419
Tejun Heoc2bd5802006-01-24 17:05:22 +09002420 /* determine if device 0/1 are present */
2421 if (ata_devchk(ap, 0))
2422 devmask |= (1 << 0);
2423 if (slave_possible && ata_devchk(ap, 1))
2424 devmask |= (1 << 1);
2425
Tejun Heoc2bd5802006-01-24 17:05:22 +09002426 /* select device 0 again */
2427 ap->ops->dev_select(ap, 0);
2428
2429 /* issue bus reset */
2430 DPRINTK("about to softreset, devmask=%x\n", devmask);
2431 err_mask = ata_bus_softreset(ap, devmask);
2432 if (err_mask) {
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002433 printk(KERN_ERR "ata%u: SRST failed (err_mask=0x%x)\n",
2434 ap->id, err_mask);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002435 return -EIO;
2436 }
2437
2438 /* determine by signature whether we have ATA or ATAPI devices */
2439 classes[0] = ata_dev_try_classify(ap, 0, &err);
2440 if (slave_possible && err != 0x81)
2441 classes[1] = ata_dev_try_classify(ap, 1, &err);
2442
Tejun Heo3a397462006-02-10 23:58:48 +09002443 out:
Tejun Heoc2bd5802006-01-24 17:05:22 +09002444 DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
2445 return 0;
2446}
2447
2448/**
2449 * sata_std_hardreset - reset host port via SATA phy reset
2450 * @ap: port to reset
Tejun Heoc2bd5802006-01-24 17:05:22 +09002451 * @class: resulting class of attached device
2452 *
2453 * SATA phy-reset host port using DET bits of SControl register.
2454 * This function is to be used as standard callback for
2455 * ata_drive_*_reset().
2456 *
2457 * LOCKING:
2458 * Kernel thread context (may sleep)
2459 *
2460 * RETURNS:
2461 * 0 on success, -errno otherwise.
2462 */
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002463int sata_std_hardreset(struct ata_port *ap, unsigned int *class)
Tejun Heoc2bd5802006-01-24 17:05:22 +09002464{
Tejun Heo852ee162006-04-01 01:38:18 +09002465 u32 scontrol;
2466
Tejun Heoc2bd5802006-01-24 17:05:22 +09002467 DPRINTK("ENTER\n");
2468
Tejun Heo3c567b72006-05-15 20:57:23 +09002469 if (sata_set_spd_needed(ap)) {
Tejun Heo1c3fae42006-04-02 20:53:28 +09002470 /* SATA spec says nothing about how to reconfigure
2471 * spd. To be on the safe side, turn off phy during
2472 * reconfiguration. This works for at least ICH7 AHCI
2473 * and Sil3124.
2474 */
2475 scontrol = scr_read(ap, SCR_CONTROL);
2476 scontrol = (scontrol & 0x0f0) | 0x302;
2477 scr_write_flush(ap, SCR_CONTROL, scontrol);
2478
Tejun Heo3c567b72006-05-15 20:57:23 +09002479 sata_set_spd(ap);
Tejun Heo1c3fae42006-04-02 20:53:28 +09002480 }
2481
2482 /* issue phy wake/reset */
Tejun Heo852ee162006-04-01 01:38:18 +09002483 scontrol = scr_read(ap, SCR_CONTROL);
2484 scontrol = (scontrol & 0x0f0) | 0x301;
2485 scr_write_flush(ap, SCR_CONTROL, scontrol);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002486
Tejun Heo1c3fae42006-04-02 20:53:28 +09002487 /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
Tejun Heoc2bd5802006-01-24 17:05:22 +09002488 * 10.4.2 says at least 1 ms.
2489 */
2490 msleep(1);
2491
Tejun Heo1c3fae42006-04-02 20:53:28 +09002492 /* bring phy back */
Tejun Heo7a7921e2006-02-02 18:20:00 +09002493 sata_phy_resume(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002494
Tejun Heoc2bd5802006-01-24 17:05:22 +09002495 /* TODO: phy layer with polling, timeouts, etc. */
2496 if (!sata_dev_present(ap)) {
2497 *class = ATA_DEV_NONE;
2498 DPRINTK("EXIT, link offline\n");
2499 return 0;
2500 }
2501
2502 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
Tejun Heo987d2f02006-04-11 22:16:45 +09002503 printk(KERN_ERR
2504 "ata%u: COMRESET failed (device not ready)\n", ap->id);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002505 return -EIO;
2506 }
2507
Tejun Heo3a397462006-02-10 23:58:48 +09002508 ap->ops->dev_select(ap, 0); /* probably unnecessary */
2509
Tejun Heoc2bd5802006-01-24 17:05:22 +09002510 *class = ata_dev_try_classify(ap, 0, NULL);
2511
2512 DPRINTK("EXIT, class=%u\n", *class);
2513 return 0;
2514}
2515
2516/**
2517 * ata_std_postreset - standard postreset callback
2518 * @ap: the target ata_port
2519 * @classes: classes of attached devices
2520 *
2521 * This function is invoked after a successful reset. Note that
2522 * the device might have been reset more than once using
2523 * different reset methods before postreset is invoked.
Tejun Heoc2bd5802006-01-24 17:05:22 +09002524 *
2525 * This function is to be used as standard callback for
2526 * ata_drive_*_reset().
2527 *
2528 * LOCKING:
2529 * Kernel thread context (may sleep)
2530 */
2531void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
2532{
2533 DPRINTK("ENTER\n");
2534
Tejun Heoc2bd5802006-01-24 17:05:22 +09002535 /* print link status */
2536 if (ap->cbl == ATA_CBL_SATA)
2537 sata_print_link_status(ap);
2538
Tejun Heo3a397462006-02-10 23:58:48 +09002539 /* re-enable interrupts */
2540 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2541 ata_irq_on(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002542
2543 /* is double-select really necessary? */
2544 if (classes[0] != ATA_DEV_NONE)
2545 ap->ops->dev_select(ap, 1);
2546 if (classes[1] != ATA_DEV_NONE)
2547 ap->ops->dev_select(ap, 0);
2548
Tejun Heo3a397462006-02-10 23:58:48 +09002549 /* bail out if no device is present */
2550 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2551 DPRINTK("EXIT, no device\n");
2552 return;
2553 }
2554
2555 /* set up device control */
2556 if (ap->ioaddr.ctl_addr) {
2557 if (ap->flags & ATA_FLAG_MMIO)
2558 writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
2559 else
2560 outb(ap->ctl, ap->ioaddr.ctl_addr);
2561 }
Tejun Heoc2bd5802006-01-24 17:05:22 +09002562
2563 DPRINTK("EXIT\n");
2564}
2565
2566/**
2567 * ata_std_probe_reset - standard probe reset method
2568 * @ap: prot to perform probe-reset
2569 * @classes: resulting classes of attached devices
2570 *
2571 * The stock off-the-shelf ->probe_reset method.
2572 *
2573 * LOCKING:
2574 * Kernel thread context (may sleep)
2575 *
2576 * RETURNS:
2577 * 0 on success, -errno otherwise.
2578 */
2579int ata_std_probe_reset(struct ata_port *ap, unsigned int *classes)
2580{
2581 ata_reset_fn_t hardreset;
2582
2583 hardreset = NULL;
Tejun Heodb70fef2006-04-11 22:16:44 +09002584 if (ap->cbl == ATA_CBL_SATA && ap->ops->scr_read)
Tejun Heoc2bd5802006-01-24 17:05:22 +09002585 hardreset = sata_std_hardreset;
2586
Tejun Heo8a19ac82006-02-02 18:20:00 +09002587 return ata_drive_probe_reset(ap, ata_std_probeinit,
Tejun Heo7944ea92006-02-02 18:20:00 +09002588 ata_std_softreset, hardreset,
Tejun Heoc2bd5802006-01-24 17:05:22 +09002589 ata_std_postreset, classes);
2590}
2591
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002592int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
2593 ata_postreset_fn_t postreset, unsigned int *classes)
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002594{
2595 int i, rc;
2596
2597 for (i = 0; i < ATA_MAX_DEVICES; i++)
2598 classes[i] = ATA_DEV_UNKNOWN;
2599
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002600 rc = reset(ap, classes);
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002601 if (rc)
2602 return rc;
2603
2604 /* If any class isn't ATA_DEV_UNKNOWN, consider classification
2605 * is complete and convert all ATA_DEV_UNKNOWN to
2606 * ATA_DEV_NONE.
2607 */
2608 for (i = 0; i < ATA_MAX_DEVICES; i++)
2609 if (classes[i] != ATA_DEV_UNKNOWN)
2610 break;
2611
2612 if (i < ATA_MAX_DEVICES)
2613 for (i = 0; i < ATA_MAX_DEVICES; i++)
2614 if (classes[i] == ATA_DEV_UNKNOWN)
2615 classes[i] = ATA_DEV_NONE;
2616
2617 if (postreset)
2618 postreset(ap, classes);
2619
Tejun Heo9974e7c2006-04-01 01:38:17 +09002620 return 0;
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002621}
2622
2623/**
2624 * ata_drive_probe_reset - Perform probe reset with given methods
2625 * @ap: port to reset
Tejun Heo7944ea92006-02-02 18:20:00 +09002626 * @probeinit: probeinit method (can be NULL)
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002627 * @softreset: softreset method (can be NULL)
2628 * @hardreset: hardreset method (can be NULL)
2629 * @postreset: postreset method (can be NULL)
2630 * @classes: resulting classes of attached devices
2631 *
2632 * Reset the specified port and classify attached devices using
2633 * given methods. This function prefers softreset but tries all
2634 * possible reset sequences to reset and classify devices. This
2635 * function is intended to be used for constructing ->probe_reset
2636 * callback by low level drivers.
2637 *
2638 * Reset methods should follow the following rules.
2639 *
2640 * - Return 0 on sucess, -errno on failure.
2641 * - If classification is supported, fill classes[] with
2642 * recognized class codes.
2643 * - If classification is not supported, leave classes[] alone.
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002644 *
2645 * LOCKING:
2646 * Kernel thread context (may sleep)
2647 *
2648 * RETURNS:
2649 * 0 on success, -EINVAL if no reset method is avaliable, -ENODEV
2650 * if classification fails, and any error code from reset
2651 * methods.
2652 */
Tejun Heo7944ea92006-02-02 18:20:00 +09002653int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002654 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2655 ata_postreset_fn_t postreset, unsigned int *classes)
2656{
2657 int rc = -EINVAL;
2658
Tejun Heo7944ea92006-02-02 18:20:00 +09002659 if (probeinit)
2660 probeinit(ap);
2661
Tejun Heo3c567b72006-05-15 20:57:23 +09002662 if (softreset && !sata_set_spd_needed(ap)) {
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002663 rc = ata_do_reset(ap, softreset, postreset, classes);
Tejun Heo9974e7c2006-04-01 01:38:17 +09002664 if (rc == 0 && classes[0] != ATA_DEV_UNKNOWN)
2665 goto done;
Tejun Heoedbabd82006-04-02 20:55:02 +09002666 printk(KERN_INFO "ata%u: softreset failed, will try "
2667 "hardreset in 5 secs\n", ap->id);
2668 ssleep(5);
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002669 }
2670
2671 if (!hardreset)
Tejun Heo9974e7c2006-04-01 01:38:17 +09002672 goto done;
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002673
Tejun Heo90dac022006-04-02 17:54:46 +09002674 while (1) {
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002675 rc = ata_do_reset(ap, hardreset, postreset, classes);
Tejun Heo90dac022006-04-02 17:54:46 +09002676 if (rc == 0) {
2677 if (classes[0] != ATA_DEV_UNKNOWN)
2678 goto done;
2679 break;
2680 }
2681
Tejun Heo3c567b72006-05-15 20:57:23 +09002682 if (sata_down_spd_limit(ap))
Tejun Heo90dac022006-04-02 17:54:46 +09002683 goto done;
Tejun Heoedbabd82006-04-02 20:55:02 +09002684
2685 printk(KERN_INFO "ata%u: hardreset failed, will retry "
2686 "in 5 secs\n", ap->id);
2687 ssleep(5);
Tejun Heo90dac022006-04-02 17:54:46 +09002688 }
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002689
Tejun Heoedbabd82006-04-02 20:55:02 +09002690 if (softreset) {
2691 printk(KERN_INFO "ata%u: hardreset succeeded without "
2692 "classification, will retry softreset in 5 secs\n",
2693 ap->id);
2694 ssleep(5);
2695
Tejun Heo2bf2cb22006-04-11 22:16:45 +09002696 rc = ata_do_reset(ap, softreset, postreset, classes);
Tejun Heoedbabd82006-04-02 20:55:02 +09002697 }
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002698
Tejun Heo9974e7c2006-04-01 01:38:17 +09002699 done:
2700 if (rc == 0 && classes[0] == ATA_DEV_UNKNOWN)
2701 rc = -ENODEV;
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002702 return rc;
2703}
2704
Tejun Heo623a3122006-03-05 17:55:58 +09002705/**
2706 * ata_dev_same_device - Determine whether new ID matches configured device
2707 * @ap: port on which the device to compare against resides
2708 * @dev: device to compare against
2709 * @new_class: class of the new device
2710 * @new_id: IDENTIFY page of the new device
2711 *
2712 * Compare @new_class and @new_id against @dev and determine
2713 * whether @dev is the device indicated by @new_class and
2714 * @new_id.
2715 *
2716 * LOCKING:
2717 * None.
2718 *
2719 * RETURNS:
2720 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
2721 */
2722static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
2723 unsigned int new_class, const u16 *new_id)
2724{
2725 const u16 *old_id = dev->id;
2726 unsigned char model[2][41], serial[2][21];
2727 u64 new_n_sectors;
2728
2729 if (dev->class != new_class) {
2730 printk(KERN_INFO
2731 "ata%u: dev %u class mismatch %d != %d\n",
2732 ap->id, dev->devno, dev->class, new_class);
2733 return 0;
2734 }
2735
2736 ata_id_c_string(old_id, model[0], ATA_ID_PROD_OFS, sizeof(model[0]));
2737 ata_id_c_string(new_id, model[1], ATA_ID_PROD_OFS, sizeof(model[1]));
2738 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO_OFS, sizeof(serial[0]));
2739 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO_OFS, sizeof(serial[1]));
2740 new_n_sectors = ata_id_n_sectors(new_id);
2741
2742 if (strcmp(model[0], model[1])) {
2743 printk(KERN_INFO
2744 "ata%u: dev %u model number mismatch '%s' != '%s'\n",
2745 ap->id, dev->devno, model[0], model[1]);
2746 return 0;
2747 }
2748
2749 if (strcmp(serial[0], serial[1])) {
2750 printk(KERN_INFO
2751 "ata%u: dev %u serial number mismatch '%s' != '%s'\n",
2752 ap->id, dev->devno, serial[0], serial[1]);
2753 return 0;
2754 }
2755
2756 if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
2757 printk(KERN_INFO
2758 "ata%u: dev %u n_sectors mismatch %llu != %llu\n",
2759 ap->id, dev->devno, (unsigned long long)dev->n_sectors,
2760 (unsigned long long)new_n_sectors);
2761 return 0;
2762 }
2763
2764 return 1;
2765}
2766
2767/**
2768 * ata_dev_revalidate - Revalidate ATA device
2769 * @ap: port on which the device to revalidate resides
2770 * @dev: device to revalidate
2771 * @post_reset: is this revalidation after reset?
2772 *
2773 * Re-read IDENTIFY page and make sure @dev is still attached to
2774 * the port.
2775 *
2776 * LOCKING:
2777 * Kernel thread context (may sleep)
2778 *
2779 * RETURNS:
2780 * 0 on success, negative errno otherwise
2781 */
2782int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
2783 int post_reset)
2784{
Tejun Heo5eb45c02006-04-02 18:51:52 +09002785 unsigned int class = dev->class;
2786 u16 *id = NULL;
Tejun Heo623a3122006-03-05 17:55:58 +09002787 int rc;
2788
Tejun Heo5eb45c02006-04-02 18:51:52 +09002789 if (!ata_dev_enabled(dev)) {
2790 rc = -ENODEV;
2791 goto fail;
2792 }
Tejun Heo623a3122006-03-05 17:55:58 +09002793
2794 /* allocate & read ID data */
2795 rc = ata_dev_read_id(ap, dev, &class, post_reset, &id);
2796 if (rc)
2797 goto fail;
2798
2799 /* is the device still there? */
2800 if (!ata_dev_same_device(ap, dev, class, id)) {
2801 rc = -ENODEV;
2802 goto fail;
2803 }
2804
2805 kfree(dev->id);
2806 dev->id = id;
2807
2808 /* configure device according to the new ID */
Tejun Heo5eb45c02006-04-02 18:51:52 +09002809 rc = ata_dev_configure(ap, dev, 0);
2810 if (rc == 0)
2811 return 0;
Tejun Heo623a3122006-03-05 17:55:58 +09002812
2813 fail:
2814 printk(KERN_ERR "ata%u: dev %u revalidation failed (errno=%d)\n",
2815 ap->id, dev->devno, rc);
2816 kfree(id);
2817 return rc;
2818}
2819
Arjan van de Ven98ac62d2005-11-28 10:06:23 +01002820static const char * const ata_dma_blacklist [] = {
Alan Coxf4b15fe2006-03-22 15:54:04 +00002821 "WDC AC11000H", NULL,
2822 "WDC AC22100H", NULL,
2823 "WDC AC32500H", NULL,
2824 "WDC AC33100H", NULL,
2825 "WDC AC31600H", NULL,
2826 "WDC AC32100H", "24.09P07",
2827 "WDC AC23200L", "21.10N21",
2828 "Compaq CRD-8241B", NULL,
2829 "CRD-8400B", NULL,
2830 "CRD-8480B", NULL,
2831 "CRD-8482B", NULL,
2832 "CRD-84", NULL,
2833 "SanDisk SDP3B", NULL,
2834 "SanDisk SDP3B-64", NULL,
2835 "SANYO CD-ROM CRD", NULL,
2836 "HITACHI CDR-8", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002837 "HITACHI CDR-8335", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002838 "HITACHI CDR-8435", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002839 "Toshiba CD-ROM XM-6202B", NULL,
2840 "TOSHIBA CD-ROM XM-1702BC", NULL,
2841 "CD-532E-A", NULL,
2842 "E-IDE CD-ROM CR-840", NULL,
2843 "CD-ROM Drive/F5A", NULL,
2844 "WPI CDD-820", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002845 "SAMSUNG CD-ROM SC-148C", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002846 "SAMSUNG CD-ROM SC", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002847 "SanDisk SDP3B-64", NULL,
2848 "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
2849 "_NEC DV5800A", NULL,
2850 "SAMSUNG CD-ROM SN-124", "N001"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851};
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002852
Alan Coxf4b15fe2006-03-22 15:54:04 +00002853static int ata_strim(char *s, size_t len)
2854{
2855 len = strnlen(s, len);
2856
2857 /* ATAPI specifies that empty space is blank-filled; remove blanks */
2858 while ((len > 0) && (s[len - 1] == ' ')) {
2859 len--;
2860 s[len] = 0;
2861 }
2862 return len;
2863}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864
Jeff Garzik057ace52005-10-22 14:27:05 -04002865static int ata_dma_blacklisted(const struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866{
Alan Coxf4b15fe2006-03-22 15:54:04 +00002867 unsigned char model_num[40];
2868 unsigned char model_rev[16];
2869 unsigned int nlen, rlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870 int i;
2871
Alan Coxf4b15fe2006-03-22 15:54:04 +00002872 ata_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
2873 sizeof(model_num));
2874 ata_id_string(dev->id, model_rev, ATA_ID_FW_REV_OFS,
2875 sizeof(model_rev));
2876 nlen = ata_strim(model_num, sizeof(model_num));
2877 rlen = ata_strim(model_rev, sizeof(model_rev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878
Alan Coxf4b15fe2006-03-22 15:54:04 +00002879 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i += 2) {
2880 if (!strncmp(ata_dma_blacklist[i], model_num, nlen)) {
2881 if (ata_dma_blacklist[i+1] == NULL)
2882 return 1;
2883 if (!strncmp(ata_dma_blacklist[i], model_rev, rlen))
2884 return 1;
2885 }
2886 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 return 0;
2888}
2889
Tejun Heoa6d5a512006-03-06 04:31:57 +09002890/**
2891 * ata_dev_xfermask - Compute supported xfermask of the given device
2892 * @ap: Port on which the device to compute xfermask for resides
2893 * @dev: Device to compute xfermask for
2894 *
Tejun Heoacf356b2006-03-24 14:07:50 +09002895 * Compute supported xfermask of @dev and store it in
2896 * dev->*_mask. This function is responsible for applying all
2897 * known limits including host controller limits, device
2898 * blacklist, etc...
Tejun Heoa6d5a512006-03-06 04:31:57 +09002899 *
Tejun Heo600511e2006-03-25 11:14:07 +09002900 * FIXME: The current implementation limits all transfer modes to
2901 * the fastest of the lowested device on the port. This is not
Tejun Heo05c8e0a2006-03-25 14:28:57 +09002902 * required on most controllers.
Tejun Heo600511e2006-03-25 11:14:07 +09002903 *
Tejun Heoa6d5a512006-03-06 04:31:57 +09002904 * LOCKING:
2905 * None.
Tejun Heoa6d5a512006-03-06 04:31:57 +09002906 */
Tejun Heoacf356b2006-03-24 14:07:50 +09002907static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908{
Alan Cox5444a6f2006-03-27 18:58:20 +01002909 struct ata_host_set *hs = ap->host_set;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002910 unsigned long xfer_mask;
2911 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912
Tejun Heo565083e2006-04-02 17:54:47 +09002913 xfer_mask = ata_pack_xfermask(ap->pio_mask,
2914 ap->mwdma_mask, ap->udma_mask);
2915
2916 /* Apply cable rule here. Don't apply it early because when
2917 * we handle hot plug the cable type can itself change.
2918 */
2919 if (ap->cbl == ATA_CBL_PATA40)
2920 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921
Alan Cox5444a6f2006-03-27 18:58:20 +01002922 /* FIXME: Use port-wide xfermask for now */
Tejun Heoa6d5a512006-03-06 04:31:57 +09002923 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2924 struct ata_device *d = &ap->device[i];
Tejun Heo565083e2006-04-02 17:54:47 +09002925
2926 if (ata_dev_absent(d))
Tejun Heoa6d5a512006-03-06 04:31:57 +09002927 continue;
Tejun Heo565083e2006-04-02 17:54:47 +09002928
2929 if (ata_dev_disabled(d)) {
2930 /* to avoid violating device selection timing */
2931 xfer_mask &= ata_pack_xfermask(d->pio_mask,
2932 UINT_MAX, UINT_MAX);
2933 continue;
2934 }
2935
2936 xfer_mask &= ata_pack_xfermask(d->pio_mask,
2937 d->mwdma_mask, d->udma_mask);
Tejun Heoa6d5a512006-03-06 04:31:57 +09002938 xfer_mask &= ata_id_xfermask(d->id);
2939 if (ata_dma_blacklisted(d))
2940 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941 }
2942
Tejun Heoa6d5a512006-03-06 04:31:57 +09002943 if (ata_dma_blacklisted(dev))
2944 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, "
2945 "disabling DMA\n", ap->id, dev->devno);
2946
Alan Cox5444a6f2006-03-27 18:58:20 +01002947 if (hs->flags & ATA_HOST_SIMPLEX) {
2948 if (hs->simplex_claimed)
2949 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
2950 }
Tejun Heo565083e2006-04-02 17:54:47 +09002951
Alan Cox5444a6f2006-03-27 18:58:20 +01002952 if (ap->ops->mode_filter)
2953 xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask);
2954
Tejun Heo565083e2006-04-02 17:54:47 +09002955 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
2956 &dev->mwdma_mask, &dev->udma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957}
2958
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
2961 * @ap: Port associated with device @dev
2962 * @dev: Device to which command will be sent
2963 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002964 * Issue SET FEATURES - XFER MODE command to device @dev
2965 * on port @ap.
2966 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002968 * PCI/etc. bus probe sem.
Tejun Heo83206a22006-03-24 15:25:31 +09002969 *
2970 * RETURNS:
2971 * 0 on success, AC_ERR_* mask otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 */
2973
Tejun Heo83206a22006-03-24 15:25:31 +09002974static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
2975 struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976{
Tejun Heoa0123702005-12-13 14:49:31 +09002977 struct ata_taskfile tf;
Tejun Heo83206a22006-03-24 15:25:31 +09002978 unsigned int err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979
2980 /* set up set-features taskfile */
2981 DPRINTK("set features - xfer mode\n");
2982
Tejun Heoa0123702005-12-13 14:49:31 +09002983 ata_tf_init(ap, &tf, dev->devno);
2984 tf.command = ATA_CMD_SET_FEATURES;
2985 tf.feature = SETFEATURES_XFER;
2986 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2987 tf.protocol = ATA_PROT_NODATA;
2988 tf.nsect = dev->xfer_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989
Tejun Heod69cf372006-04-02 18:51:53 +09002990 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991
Tejun Heo83206a22006-03-24 15:25:31 +09002992 DPRINTK("EXIT, err_mask=%x\n", err_mask);
2993 return err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994}
2995
2996/**
Albert Lee8bf62ec2005-05-12 15:29:42 -04002997 * ata_dev_init_params - Issue INIT DEV PARAMS command
2998 * @ap: Port associated with device @dev
2999 * @dev: Device to which command will be sent
3000 *
3001 * LOCKING:
Tejun Heo6aff8f12006-02-15 18:24:09 +09003002 * Kernel thread context (may sleep)
3003 *
3004 * RETURNS:
3005 * 0 on success, AC_ERR_* mask otherwise.
Albert Lee8bf62ec2005-05-12 15:29:42 -04003006 */
3007
Tejun Heo6aff8f12006-02-15 18:24:09 +09003008static unsigned int ata_dev_init_params(struct ata_port *ap,
Albert Lee00b6f5e2006-03-27 16:39:18 +08003009 struct ata_device *dev,
3010 u16 heads,
3011 u16 sectors)
Albert Lee8bf62ec2005-05-12 15:29:42 -04003012{
Tejun Heoa0123702005-12-13 14:49:31 +09003013 struct ata_taskfile tf;
Tejun Heo6aff8f12006-02-15 18:24:09 +09003014 unsigned int err_mask;
Albert Lee8bf62ec2005-05-12 15:29:42 -04003015
3016 /* Number of sectors per track 1-255. Number of heads 1-16 */
3017 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
Albert Lee00b6f5e2006-03-27 16:39:18 +08003018 return AC_ERR_INVALID;
Albert Lee8bf62ec2005-05-12 15:29:42 -04003019
3020 /* set up init dev params taskfile */
3021 DPRINTK("init dev params \n");
3022
Tejun Heoa0123702005-12-13 14:49:31 +09003023 ata_tf_init(ap, &tf, dev->devno);
3024 tf.command = ATA_CMD_INIT_DEV_PARAMS;
3025 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3026 tf.protocol = ATA_PROT_NODATA;
3027 tf.nsect = sectors;
3028 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
Albert Lee8bf62ec2005-05-12 15:29:42 -04003029
Tejun Heod69cf372006-04-02 18:51:53 +09003030 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
Albert Lee8bf62ec2005-05-12 15:29:42 -04003031
Tejun Heo6aff8f12006-02-15 18:24:09 +09003032 DPRINTK("EXIT, err_mask=%x\n", err_mask);
3033 return err_mask;
Albert Lee8bf62ec2005-05-12 15:29:42 -04003034}
3035
3036/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003037 * ata_sg_clean - Unmap DMA memory associated with command
3038 * @qc: Command containing DMA memory to be released
3039 *
3040 * Unmap all mapped DMA memory associated with this command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041 *
3042 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003043 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 */
3045
3046static void ata_sg_clean(struct ata_queued_cmd *qc)
3047{
3048 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003049 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003051 void *pad_buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052
Tejun Heoa4631472006-02-11 19:11:13 +09003053 WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
3054 WARN_ON(sg == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055
3056 if (qc->flags & ATA_QCFLAG_SINGLE)
Jeff Garzikf1318832006-02-20 16:55:56 -05003057 WARN_ON(qc->n_elem > 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05003059 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003061 /* if we padded the buffer out to 32-bit bound, and data
3062 * xfer direction is from-device, we must copy from the
3063 * pad buffer back into the supplied buffer
3064 */
3065 if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
3066 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3067
3068 if (qc->flags & ATA_QCFLAG_SG) {
Jeff Garzike1410f22005-11-14 14:06:26 -05003069 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06003070 dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003071 /* restore last sg */
3072 sg[qc->orig_n_elem - 1].length += qc->pad_len;
3073 if (pad_buf) {
3074 struct scatterlist *psg = &qc->pad_sgent;
3075 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3076 memcpy(addr + psg->offset, pad_buf, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05003077 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003078 }
3079 } else {
Tejun Heo2e242fa2006-02-20 23:48:38 +09003080 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06003081 dma_unmap_single(ap->dev,
Jeff Garzike1410f22005-11-14 14:06:26 -05003082 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
3083 dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003084 /* restore sg */
3085 sg->length += qc->pad_len;
3086 if (pad_buf)
3087 memcpy(qc->buf_virt + sg->length - qc->pad_len,
3088 pad_buf, qc->pad_len);
3089 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090
3091 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003092 qc->__sg = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093}
3094
3095/**
3096 * ata_fill_sg - Fill PCI IDE PRD table
3097 * @qc: Metadata associated with taskfile to be transferred
3098 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003099 * Fill PCI IDE PRD (scatter-gather) table with segments
3100 * associated with the current disk command.
3101 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102 * LOCKING:
Jeff Garzik780a87f2005-05-30 15:41:05 -04003103 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104 *
3105 */
3106static void ata_fill_sg(struct ata_queued_cmd *qc)
3107{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003109 struct scatterlist *sg;
3110 unsigned int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111
Tejun Heoa4631472006-02-11 19:11:13 +09003112 WARN_ON(qc->__sg == NULL);
Jeff Garzikf1318832006-02-20 16:55:56 -05003113 WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114
3115 idx = 0;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003116 ata_for_each_sg(sg, qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 u32 addr, offset;
3118 u32 sg_len, len;
3119
3120 /* determine if physical DMA addr spans 64K boundary.
3121 * Note h/w doesn't support 64-bit, so we unconditionally
3122 * truncate dma_addr_t to u32.
3123 */
3124 addr = (u32) sg_dma_address(sg);
3125 sg_len = sg_dma_len(sg);
3126
3127 while (sg_len) {
3128 offset = addr & 0xffff;
3129 len = sg_len;
3130 if ((offset + sg_len) > 0x10000)
3131 len = 0x10000 - offset;
3132
3133 ap->prd[idx].addr = cpu_to_le32(addr);
3134 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
3135 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
3136
3137 idx++;
3138 sg_len -= len;
3139 addr += len;
3140 }
3141 }
3142
3143 if (idx)
3144 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
3145}
3146/**
3147 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
3148 * @qc: Metadata associated with taskfile to check
3149 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003150 * Allow low-level driver to filter ATA PACKET commands, returning
3151 * a status indicating whether or not it is OK to use DMA for the
3152 * supplied PACKET command.
3153 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003155 * spin_lock_irqsave(host_set lock)
3156 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157 * RETURNS: 0 when ATAPI DMA can be used
3158 * nonzero otherwise
3159 */
3160int ata_check_atapi_dma(struct ata_queued_cmd *qc)
3161{
3162 struct ata_port *ap = qc->ap;
3163 int rc = 0; /* Assume ATAPI DMA is OK by default */
3164
3165 if (ap->ops->check_atapi_dma)
3166 rc = ap->ops->check_atapi_dma(qc);
3167
3168 return rc;
3169}
3170/**
3171 * ata_qc_prep - Prepare taskfile for submission
3172 * @qc: Metadata associated with taskfile to be prepared
3173 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003174 * Prepare ATA taskfile for submission.
3175 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003176 * LOCKING:
3177 * spin_lock_irqsave(host_set lock)
3178 */
3179void ata_qc_prep(struct ata_queued_cmd *qc)
3180{
3181 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
3182 return;
3183
3184 ata_fill_sg(qc);
3185}
3186
Brian Kinge46834c2006-03-17 17:04:03 -06003187void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
3188
Jeff Garzik0cba6322005-05-30 19:49:12 -04003189/**
3190 * ata_sg_init_one - Associate command with memory buffer
3191 * @qc: Command to be associated
3192 * @buf: Memory buffer
3193 * @buflen: Length of memory buffer, in bytes.
3194 *
3195 * Initialize the data-related elements of queued_cmd @qc
3196 * to point to a single memory buffer, @buf of byte length @buflen.
3197 *
3198 * LOCKING:
3199 * spin_lock_irqsave(host_set lock)
3200 */
3201
Linus Torvalds1da177e2005-04-16 15:20:36 -07003202void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
3203{
3204 struct scatterlist *sg;
3205
3206 qc->flags |= ATA_QCFLAG_SINGLE;
3207
3208 memset(&qc->sgent, 0, sizeof(qc->sgent));
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003209 qc->__sg = &qc->sgent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003210 qc->n_elem = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003211 qc->orig_n_elem = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212 qc->buf_virt = buf;
3213
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003214 sg = qc->__sg;
Jeff Garzikf0612bb2005-10-30 01:58:18 -05003215 sg_init_one(sg, buf, buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003216}
3217
Jeff Garzik0cba6322005-05-30 19:49:12 -04003218/**
3219 * ata_sg_init - Associate command with scatter-gather table.
3220 * @qc: Command to be associated
3221 * @sg: Scatter-gather table.
3222 * @n_elem: Number of elements in s/g table.
3223 *
3224 * Initialize the data-related elements of queued_cmd @qc
3225 * to point to a scatter-gather table @sg, containing @n_elem
3226 * elements.
3227 *
3228 * LOCKING:
3229 * spin_lock_irqsave(host_set lock)
3230 */
3231
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
3233 unsigned int n_elem)
3234{
3235 qc->flags |= ATA_QCFLAG_SG;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003236 qc->__sg = sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 qc->n_elem = n_elem;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003238 qc->orig_n_elem = n_elem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003239}
3240
3241/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003242 * ata_sg_setup_one - DMA-map the memory buffer associated with a command.
3243 * @qc: Command with memory buffer to be mapped.
3244 *
3245 * DMA-map the memory buffer associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246 *
3247 * LOCKING:
3248 * spin_lock_irqsave(host_set lock)
3249 *
3250 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003251 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003252 */
3253
3254static int ata_sg_setup_one(struct ata_queued_cmd *qc)
3255{
3256 struct ata_port *ap = qc->ap;
3257 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003258 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259 dma_addr_t dma_address;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003260 int trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003261
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003262 /* we must lengthen transfers to end on a 32-bit boundary */
3263 qc->pad_len = sg->length & 3;
3264 if (qc->pad_len) {
3265 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3266 struct scatterlist *psg = &qc->pad_sgent;
3267
Tejun Heoa4631472006-02-11 19:11:13 +09003268 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003269
3270 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3271
3272 if (qc->tf.flags & ATA_TFLAG_WRITE)
3273 memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
3274 qc->pad_len);
3275
3276 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3277 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3278 /* trim sg */
3279 sg->length -= qc->pad_len;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003280 if (sg->length == 0)
3281 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003282
3283 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
3284 sg->length, qc->pad_len);
3285 }
3286
Tejun Heo2e242fa2006-02-20 23:48:38 +09003287 if (trim_sg) {
3288 qc->n_elem--;
Jeff Garzike1410f22005-11-14 14:06:26 -05003289 goto skip_map;
3290 }
3291
Brian King2f1f6102006-03-23 17:30:15 -06003292 dma_address = dma_map_single(ap->dev, qc->buf_virt,
Albert Lee32529e02005-05-26 03:49:42 -04003293 sg->length, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003294 if (dma_mapping_error(dma_address)) {
3295 /* restore sg */
3296 sg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003297 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003298 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003299
3300 sg_dma_address(sg) = dma_address;
Albert Lee32529e02005-05-26 03:49:42 -04003301 sg_dma_len(sg) = sg->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302
Tejun Heo2e242fa2006-02-20 23:48:38 +09003303skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003304 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
3305 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3306
3307 return 0;
3308}
3309
3310/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003311 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
3312 * @qc: Command with scatter-gather table to be mapped.
3313 *
3314 * DMA-map the scatter-gather table associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003315 *
3316 * LOCKING:
3317 * spin_lock_irqsave(host_set lock)
3318 *
3319 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003320 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003321 *
3322 */
3323
3324static int ata_sg_setup(struct ata_queued_cmd *qc)
3325{
3326 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003327 struct scatterlist *sg = qc->__sg;
3328 struct scatterlist *lsg = &sg[qc->n_elem - 1];
Jeff Garzike1410f22005-11-14 14:06:26 -05003329 int n_elem, pre_n_elem, dir, trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003330
3331 VPRINTK("ENTER, ata%u\n", ap->id);
Tejun Heoa4631472006-02-11 19:11:13 +09003332 WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003334 /* we must lengthen transfers to end on a 32-bit boundary */
3335 qc->pad_len = lsg->length & 3;
3336 if (qc->pad_len) {
3337 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3338 struct scatterlist *psg = &qc->pad_sgent;
3339 unsigned int offset;
3340
Tejun Heoa4631472006-02-11 19:11:13 +09003341 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003342
3343 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3344
3345 /*
3346 * psg->page/offset are used to copy to-be-written
3347 * data in this function or read data in ata_sg_clean.
3348 */
3349 offset = lsg->offset + lsg->length - qc->pad_len;
3350 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
3351 psg->offset = offset_in_page(offset);
3352
3353 if (qc->tf.flags & ATA_TFLAG_WRITE) {
3354 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3355 memcpy(pad_buf, addr + psg->offset, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05003356 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003357 }
3358
3359 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3360 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3361 /* trim last sg */
3362 lsg->length -= qc->pad_len;
Jeff Garzike1410f22005-11-14 14:06:26 -05003363 if (lsg->length == 0)
3364 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003365
3366 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
3367 qc->n_elem - 1, lsg->length, qc->pad_len);
3368 }
3369
Jeff Garzike1410f22005-11-14 14:06:26 -05003370 pre_n_elem = qc->n_elem;
3371 if (trim_sg && pre_n_elem)
3372 pre_n_elem--;
3373
3374 if (!pre_n_elem) {
3375 n_elem = 0;
3376 goto skip_map;
3377 }
3378
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379 dir = qc->dma_dir;
Brian King2f1f6102006-03-23 17:30:15 -06003380 n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003381 if (n_elem < 1) {
3382 /* restore last sg */
3383 lsg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003384 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003385 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003386
3387 DPRINTK("%d sg elements mapped\n", n_elem);
3388
Jeff Garzike1410f22005-11-14 14:06:26 -05003389skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003390 qc->n_elem = n_elem;
3391
3392 return 0;
3393}
3394
3395/**
Tejun Heo40e8c822005-08-22 17:12:45 +09003396 * ata_poll_qc_complete - turn irq back on and finish qc
3397 * @qc: Command to complete
Randy Dunlap8e8b77d2005-11-01 21:29:27 -08003398 * @err_mask: ATA status register content
Tejun Heo40e8c822005-08-22 17:12:45 +09003399 *
3400 * LOCKING:
3401 * None. (grabs host lock)
3402 */
3403
Albert Leea22e2eb2005-12-05 15:38:02 +08003404void ata_poll_qc_complete(struct ata_queued_cmd *qc)
Tejun Heo40e8c822005-08-22 17:12:45 +09003405{
3406 struct ata_port *ap = qc->ap;
Jeff Garzikb8f61532005-08-25 22:01:20 -04003407 unsigned long flags;
Tejun Heo40e8c822005-08-22 17:12:45 +09003408
Jeff Garzikb8f61532005-08-25 22:01:20 -04003409 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo40e8c822005-08-22 17:12:45 +09003410 ap->flags &= ~ATA_FLAG_NOINTR;
3411 ata_irq_on(ap);
Albert Leea22e2eb2005-12-05 15:38:02 +08003412 ata_qc_complete(qc);
Jeff Garzikb8f61532005-08-25 22:01:20 -04003413 spin_unlock_irqrestore(&ap->host_set->lock, flags);
Tejun Heo40e8c822005-08-22 17:12:45 +09003414}
3415
3416/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003417 * ata_pio_poll - poll using PIO, depending on current state
Tejun Heoc91af2c2006-04-02 18:51:53 +09003418 * @qc: qc in progress
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419 *
3420 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003421 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003422 *
3423 * RETURNS:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003424 * timeout value to use
Linus Torvalds1da177e2005-04-16 15:20:36 -07003425 */
Tejun Heoc91af2c2006-04-02 18:51:53 +09003426static unsigned long ata_pio_poll(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003428 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003429 u8 status;
Albert Lee14be71f2005-09-27 17:36:35 +08003430 unsigned int poll_state = HSM_ST_UNKNOWN;
3431 unsigned int reg_state = HSM_ST_UNKNOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003432
Albert Lee14be71f2005-09-27 17:36:35 +08003433 switch (ap->hsm_task_state) {
3434 case HSM_ST:
3435 case HSM_ST_POLL:
3436 poll_state = HSM_ST_POLL;
3437 reg_state = HSM_ST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438 break;
Albert Lee14be71f2005-09-27 17:36:35 +08003439 case HSM_ST_LAST:
3440 case HSM_ST_LAST_POLL:
3441 poll_state = HSM_ST_LAST_POLL;
3442 reg_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443 break;
3444 default:
3445 BUG();
3446 break;
3447 }
3448
3449 status = ata_chk_status(ap);
3450 if (status & ATA_BUSY) {
3451 if (time_after(jiffies, ap->pio_task_timeout)) {
Tejun Heo11a56d22006-01-23 13:09:36 +09003452 qc->err_mask |= AC_ERR_TIMEOUT;
Albert Lee7c398332005-11-09 13:03:30 +08003453 ap->hsm_task_state = HSM_ST_TMOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003454 return 0;
3455 }
Albert Lee14be71f2005-09-27 17:36:35 +08003456 ap->hsm_task_state = poll_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457 return ATA_SHORT_PAUSE;
3458 }
3459
Albert Lee14be71f2005-09-27 17:36:35 +08003460 ap->hsm_task_state = reg_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461 return 0;
3462}
3463
3464/**
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003465 * ata_pio_complete - check if drive is busy or idle
Tejun Heoc91af2c2006-04-02 18:51:53 +09003466 * @qc: qc to complete
Linus Torvalds1da177e2005-04-16 15:20:36 -07003467 *
3468 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003469 * None. (executing in kernel thread context)
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003470 *
3471 * RETURNS:
3472 * Non-zero if qc completed, zero otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003473 */
Tejun Heoc91af2c2006-04-02 18:51:53 +09003474static int ata_pio_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003475{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003476 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 u8 drv_stat;
3478
3479 /*
Alan Cox31433ea2005-08-26 15:56:47 +01003480 * This is purely heuristic. This is a fast path. Sometimes when
3481 * we enter, BSY will be cleared in a chk-status or two. If not,
3482 * the drive is probably seeking or something. Snooze for a couple
3483 * msecs, then chk-status again. If still busy, fall back to
Albert Lee14be71f2005-09-27 17:36:35 +08003484 * HSM_ST_POLL state.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485 */
Albert Leefe79e682005-12-06 11:34:59 +08003486 drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
3487 if (drv_stat & ATA_BUSY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488 msleep(2);
Albert Leefe79e682005-12-06 11:34:59 +08003489 drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
3490 if (drv_stat & ATA_BUSY) {
Albert Lee14be71f2005-09-27 17:36:35 +08003491 ap->hsm_task_state = HSM_ST_LAST_POLL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003492 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003493 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003494 }
3495 }
3496
3497 drv_stat = ata_wait_idle(ap);
3498 if (!ata_ok(drv_stat)) {
Albert Lee1c848982005-12-05 15:40:15 +08003499 qc->err_mask |= __ac_err_mask(drv_stat);
Albert Lee14be71f2005-09-27 17:36:35 +08003500 ap->hsm_task_state = HSM_ST_ERR;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003501 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502 }
3503
Albert Lee14be71f2005-09-27 17:36:35 +08003504 ap->hsm_task_state = HSM_ST_IDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505
Tejun Heoa4631472006-02-11 19:11:13 +09003506 WARN_ON(qc->err_mask);
Albert Leea22e2eb2005-12-05 15:38:02 +08003507 ata_poll_qc_complete(qc);
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003508
3509 /* another command may start at this point */
3510
3511 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512}
3513
Edward Falk0baab862005-06-02 18:17:13 -04003514
3515/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003516 * swap_buf_le16 - swap halves of 16-bit words in place
Edward Falk0baab862005-06-02 18:17:13 -04003517 * @buf: Buffer to swap
3518 * @buf_words: Number of 16-bit words in buffer.
3519 *
3520 * Swap halves of 16-bit words if needed to convert from
3521 * little-endian byte order to native cpu byte order, or
3522 * vice-versa.
3523 *
3524 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003525 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04003526 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527void swap_buf_le16(u16 *buf, unsigned int buf_words)
3528{
3529#ifdef __BIG_ENDIAN
3530 unsigned int i;
3531
3532 for (i = 0; i < buf_words; i++)
3533 buf[i] = le16_to_cpu(buf[i]);
3534#endif /* __BIG_ENDIAN */
3535}
3536
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003537/**
3538 * ata_mmio_data_xfer - Transfer data by MMIO
3539 * @ap: port to read/write
3540 * @buf: data buffer
3541 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003542 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003543 *
3544 * Transfer data from/to the device data register by MMIO.
3545 *
3546 * LOCKING:
3547 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003548 */
3549
Linus Torvalds1da177e2005-04-16 15:20:36 -07003550static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
3551 unsigned int buflen, int write_data)
3552{
3553 unsigned int i;
3554 unsigned int words = buflen >> 1;
3555 u16 *buf16 = (u16 *) buf;
3556 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
3557
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003558 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003559 if (write_data) {
3560 for (i = 0; i < words; i++)
3561 writew(le16_to_cpu(buf16[i]), mmio);
3562 } else {
3563 for (i = 0; i < words; i++)
3564 buf16[i] = cpu_to_le16(readw(mmio));
3565 }
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003566
3567 /* Transfer trailing 1 byte, if any. */
3568 if (unlikely(buflen & 0x01)) {
3569 u16 align_buf[1] = { 0 };
3570 unsigned char *trailing_buf = buf + buflen - 1;
3571
3572 if (write_data) {
3573 memcpy(align_buf, trailing_buf, 1);
3574 writew(le16_to_cpu(align_buf[0]), mmio);
3575 } else {
3576 align_buf[0] = cpu_to_le16(readw(mmio));
3577 memcpy(trailing_buf, align_buf, 1);
3578 }
3579 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003580}
3581
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003582/**
3583 * ata_pio_data_xfer - Transfer data by PIO
3584 * @ap: port to read/write
3585 * @buf: data buffer
3586 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003587 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003588 *
3589 * Transfer data from/to the device data register by PIO.
3590 *
3591 * LOCKING:
3592 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003593 */
3594
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
3596 unsigned int buflen, int write_data)
3597{
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003598 unsigned int words = buflen >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003599
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003600 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601 if (write_data)
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003602 outsw(ap->ioaddr.data_addr, buf, words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603 else
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003604 insw(ap->ioaddr.data_addr, buf, words);
3605
3606 /* Transfer trailing 1 byte, if any. */
3607 if (unlikely(buflen & 0x01)) {
3608 u16 align_buf[1] = { 0 };
3609 unsigned char *trailing_buf = buf + buflen - 1;
3610
3611 if (write_data) {
3612 memcpy(align_buf, trailing_buf, 1);
3613 outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
3614 } else {
3615 align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
3616 memcpy(trailing_buf, align_buf, 1);
3617 }
3618 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619}
3620
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003621/**
3622 * ata_data_xfer - Transfer data from/to the data register.
3623 * @ap: port to read/write
3624 * @buf: data buffer
3625 * @buflen: buffer length
3626 * @do_write: read/write
3627 *
3628 * Transfer data from/to the device data register.
3629 *
3630 * LOCKING:
3631 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003632 */
3633
Linus Torvalds1da177e2005-04-16 15:20:36 -07003634static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
3635 unsigned int buflen, int do_write)
3636{
Alan Coxa1bd9e62006-01-17 20:53:50 +00003637 /* Make the crap hardware pay the costs not the good stuff */
3638 if (unlikely(ap->flags & ATA_FLAG_IRQ_MASK)) {
3639 unsigned long flags;
3640 local_irq_save(flags);
3641 if (ap->flags & ATA_FLAG_MMIO)
3642 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3643 else
3644 ata_pio_data_xfer(ap, buf, buflen, do_write);
3645 local_irq_restore(flags);
3646 } else {
3647 if (ap->flags & ATA_FLAG_MMIO)
3648 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3649 else
3650 ata_pio_data_xfer(ap, buf, buflen, do_write);
3651 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003652}
3653
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003654/**
3655 * ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
3656 * @qc: Command on going
3657 *
3658 * Transfer ATA_SECT_SIZE of data from/to the ATA device.
3659 *
3660 * LOCKING:
3661 * Inherited from caller.
3662 */
3663
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664static void ata_pio_sector(struct ata_queued_cmd *qc)
3665{
3666 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003667 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668 struct ata_port *ap = qc->ap;
3669 struct page *page;
3670 unsigned int offset;
3671 unsigned char *buf;
3672
3673 if (qc->cursect == (qc->nsect - 1))
Albert Lee14be71f2005-09-27 17:36:35 +08003674 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003675
3676 page = sg[qc->cursg].page;
3677 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
3678
3679 /* get the current page and offset */
3680 page = nth_page(page, (offset >> PAGE_SHIFT));
3681 offset %= PAGE_SIZE;
3682
3683 buf = kmap(page) + offset;
3684
3685 qc->cursect++;
3686 qc->cursg_ofs++;
3687
Albert Lee32529e02005-05-26 03:49:42 -04003688 if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003689 qc->cursg++;
3690 qc->cursg_ofs = 0;
3691 }
3692
3693 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3694
3695 /* do the actual data transfer */
3696 do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3697 ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
3698
3699 kunmap(page);
3700}
3701
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003702/**
3703 * __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3704 * @qc: Command on going
3705 * @bytes: number of bytes
3706 *
3707 * Transfer Transfer data from/to the ATAPI device.
3708 *
3709 * LOCKING:
3710 * Inherited from caller.
3711 *
3712 */
3713
Linus Torvalds1da177e2005-04-16 15:20:36 -07003714static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3715{
3716 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003717 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003718 struct ata_port *ap = qc->ap;
3719 struct page *page;
3720 unsigned char *buf;
3721 unsigned int offset, count;
3722
Albert Lee563a6e12005-08-12 14:17:50 +08003723 if (qc->curbytes + bytes >= qc->nbytes)
Albert Lee14be71f2005-09-27 17:36:35 +08003724 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003725
3726next_sg:
Albert Lee563a6e12005-08-12 14:17:50 +08003727 if (unlikely(qc->cursg >= qc->n_elem)) {
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003728 /*
Albert Lee563a6e12005-08-12 14:17:50 +08003729 * The end of qc->sg is reached and the device expects
3730 * more data to transfer. In order not to overrun qc->sg
3731 * and fulfill length specified in the byte count register,
3732 * - for read case, discard trailing data from the device
3733 * - for write case, padding zero data to the device
3734 */
3735 u16 pad_buf[1] = { 0 };
3736 unsigned int words = bytes >> 1;
3737 unsigned int i;
3738
3739 if (words) /* warning if bytes > 1 */
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003740 printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
Albert Lee563a6e12005-08-12 14:17:50 +08003741 ap->id, bytes);
3742
3743 for (i = 0; i < words; i++)
3744 ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
3745
Albert Lee14be71f2005-09-27 17:36:35 +08003746 ap->hsm_task_state = HSM_ST_LAST;
Albert Lee563a6e12005-08-12 14:17:50 +08003747 return;
3748 }
3749
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003750 sg = &qc->__sg[qc->cursg];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003751
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752 page = sg->page;
3753 offset = sg->offset + qc->cursg_ofs;
3754
3755 /* get the current page and offset */
3756 page = nth_page(page, (offset >> PAGE_SHIFT));
3757 offset %= PAGE_SIZE;
3758
Albert Lee6952df02005-06-06 15:56:03 +08003759 /* don't overrun current sg */
Albert Lee32529e02005-05-26 03:49:42 -04003760 count = min(sg->length - qc->cursg_ofs, bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003761
3762 /* don't cross page boundaries */
3763 count = min(count, (unsigned int)PAGE_SIZE - offset);
3764
3765 buf = kmap(page) + offset;
3766
3767 bytes -= count;
3768 qc->curbytes += count;
3769 qc->cursg_ofs += count;
3770
Albert Lee32529e02005-05-26 03:49:42 -04003771 if (qc->cursg_ofs == sg->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003772 qc->cursg++;
3773 qc->cursg_ofs = 0;
3774 }
3775
3776 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3777
3778 /* do the actual data transfer */
3779 ata_data_xfer(ap, buf, count, do_write);
3780
3781 kunmap(page);
3782
Albert Lee563a6e12005-08-12 14:17:50 +08003783 if (bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003784 goto next_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003785}
3786
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003787/**
3788 * atapi_pio_bytes - Transfer data from/to the ATAPI device.
3789 * @qc: Command on going
3790 *
3791 * Transfer Transfer data from/to the ATAPI device.
3792 *
3793 * LOCKING:
3794 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003795 */
3796
Linus Torvalds1da177e2005-04-16 15:20:36 -07003797static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3798{
3799 struct ata_port *ap = qc->ap;
3800 struct ata_device *dev = qc->dev;
3801 unsigned int ireason, bc_lo, bc_hi, bytes;
3802 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3803
3804 ap->ops->tf_read(ap, &qc->tf);
3805 ireason = qc->tf.nsect;
3806 bc_lo = qc->tf.lbam;
3807 bc_hi = qc->tf.lbah;
3808 bytes = (bc_hi << 8) | bc_lo;
3809
3810 /* shall be cleared to zero, indicating xfer of data */
3811 if (ireason & (1 << 0))
3812 goto err_out;
3813
3814 /* make sure transfer direction matches expected */
3815 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3816 if (do_write != i_write)
3817 goto err_out;
3818
3819 __atapi_pio_bytes(qc, bytes);
3820
3821 return;
3822
3823err_out:
3824 printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
3825 ap->id, dev->devno);
Tejun Heo11a56d22006-01-23 13:09:36 +09003826 qc->err_mask |= AC_ERR_HSM;
Albert Lee14be71f2005-09-27 17:36:35 +08003827 ap->hsm_task_state = HSM_ST_ERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003828}
3829
3830/**
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003831 * ata_pio_block - start PIO on a block
Tejun Heoc91af2c2006-04-02 18:51:53 +09003832 * @qc: qc to transfer block for
Linus Torvalds1da177e2005-04-16 15:20:36 -07003833 *
3834 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003835 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003836 */
Tejun Heoc91af2c2006-04-02 18:51:53 +09003837static void ata_pio_block(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003839 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003840 u8 status;
3841
3842 /*
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003843 * This is purely heuristic. This is a fast path.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003844 * Sometimes when we enter, BSY will be cleared in
3845 * a chk-status or two. If not, the drive is probably seeking
3846 * or something. Snooze for a couple msecs, then
3847 * chk-status again. If still busy, fall back to
Albert Lee14be71f2005-09-27 17:36:35 +08003848 * HSM_ST_POLL state.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003849 */
3850 status = ata_busy_wait(ap, ATA_BUSY, 5);
3851 if (status & ATA_BUSY) {
3852 msleep(2);
3853 status = ata_busy_wait(ap, ATA_BUSY, 10);
3854 if (status & ATA_BUSY) {
Albert Lee14be71f2005-09-27 17:36:35 +08003855 ap->hsm_task_state = HSM_ST_POLL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003856 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
3857 return;
3858 }
3859 }
3860
Albert Leefe79e682005-12-06 11:34:59 +08003861 /* check error */
3862 if (status & (ATA_ERR | ATA_DF)) {
3863 qc->err_mask |= AC_ERR_DEV;
3864 ap->hsm_task_state = HSM_ST_ERR;
3865 return;
3866 }
3867
3868 /* transfer data if any */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003869 if (is_atapi_taskfile(&qc->tf)) {
Albert Leefe79e682005-12-06 11:34:59 +08003870 /* DRQ=0 means no more data to transfer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003871 if ((status & ATA_DRQ) == 0) {
Albert Lee14be71f2005-09-27 17:36:35 +08003872 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003873 return;
3874 }
3875
3876 atapi_pio_bytes(qc);
3877 } else {
3878 /* handle BSY=0, DRQ=0 as error */
3879 if ((status & ATA_DRQ) == 0) {
Tejun Heo11a56d22006-01-23 13:09:36 +09003880 qc->err_mask |= AC_ERR_HSM;
Albert Lee14be71f2005-09-27 17:36:35 +08003881 ap->hsm_task_state = HSM_ST_ERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003882 return;
3883 }
3884
3885 ata_pio_sector(qc);
3886 }
3887}
3888
Tejun Heoc91af2c2006-04-02 18:51:53 +09003889static void ata_pio_error(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003890{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003891 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003892
Albert Lee0565c262006-02-13 18:55:25 +08003893 if (qc->tf.command != ATA_CMD_PACKET)
Tejun Heod63cb4a2006-04-02 18:51:52 +09003894 printk(KERN_WARNING "ata%u: dev %u PIO error\n",
3895 ap->id, qc->dev->devno);
Albert Lee0565c262006-02-13 18:55:25 +08003896
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05003897 /* make sure qc->err_mask is available to
Albert Lee1c848982005-12-05 15:40:15 +08003898 * know what's wrong and recover
3899 */
Tejun Heoa4631472006-02-11 19:11:13 +09003900 WARN_ON(qc->err_mask == 0);
Albert Lee1c848982005-12-05 15:40:15 +08003901
Albert Lee14be71f2005-09-27 17:36:35 +08003902 ap->hsm_task_state = HSM_ST_IDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003903
Albert Leea22e2eb2005-12-05 15:38:02 +08003904 ata_poll_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003905}
3906
3907static void ata_pio_task(void *_data)
3908{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003909 struct ata_queued_cmd *qc = _data;
3910 struct ata_port *ap = qc->ap;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003911 unsigned long timeout;
3912 int qc_completed;
3913
3914fsm_start:
3915 timeout = 0;
3916 qc_completed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003917
Albert Lee14be71f2005-09-27 17:36:35 +08003918 switch (ap->hsm_task_state) {
3919 case HSM_ST_IDLE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920 return;
3921
Albert Lee14be71f2005-09-27 17:36:35 +08003922 case HSM_ST:
Tejun Heoc91af2c2006-04-02 18:51:53 +09003923 ata_pio_block(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924 break;
3925
Albert Lee14be71f2005-09-27 17:36:35 +08003926 case HSM_ST_LAST:
Tejun Heoc91af2c2006-04-02 18:51:53 +09003927 qc_completed = ata_pio_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003928 break;
3929
Albert Lee14be71f2005-09-27 17:36:35 +08003930 case HSM_ST_POLL:
3931 case HSM_ST_LAST_POLL:
Tejun Heoc91af2c2006-04-02 18:51:53 +09003932 timeout = ata_pio_poll(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003933 break;
3934
Albert Lee14be71f2005-09-27 17:36:35 +08003935 case HSM_ST_TMOUT:
3936 case HSM_ST_ERR:
Tejun Heoc91af2c2006-04-02 18:51:53 +09003937 ata_pio_error(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003938 return;
3939 }
3940
3941 if (timeout)
Tejun Heoc91af2c2006-04-02 18:51:53 +09003942 ata_port_queue_task(ap, ata_pio_task, qc, timeout);
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003943 else if (!qc_completed)
3944 goto fsm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945}
3946
Linus Torvalds1da177e2005-04-16 15:20:36 -07003947/**
Tejun Heo8061f5f2006-03-05 15:29:09 +09003948 * atapi_packet_task - Write CDB bytes to hardware
Tejun Heoc91af2c2006-04-02 18:51:53 +09003949 * @_data: qc in progress
Tejun Heo8061f5f2006-03-05 15:29:09 +09003950 *
3951 * When device has indicated its readiness to accept
3952 * a CDB, this function is called. Send the CDB.
3953 * If DMA is to be performed, exit immediately.
3954 * Otherwise, we are in polling mode, so poll
3955 * status under operation succeeds or fails.
3956 *
3957 * LOCKING:
3958 * Kernel thread context (may sleep)
3959 */
Tejun Heo8061f5f2006-03-05 15:29:09 +09003960static void atapi_packet_task(void *_data)
3961{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003962 struct ata_queued_cmd *qc = _data;
3963 struct ata_port *ap = qc->ap;
Tejun Heo8061f5f2006-03-05 15:29:09 +09003964 u8 status;
3965
Tejun Heo8061f5f2006-03-05 15:29:09 +09003966 /* sleep-wait for BSY to clear */
3967 DPRINTK("busy wait\n");
3968 if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB)) {
3969 qc->err_mask |= AC_ERR_TIMEOUT;
3970 goto err_out;
3971 }
3972
3973 /* make sure DRQ is set */
3974 status = ata_chk_status(ap);
3975 if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ) {
3976 qc->err_mask |= AC_ERR_HSM;
3977 goto err_out;
3978 }
3979
3980 /* send SCSI cdb */
3981 DPRINTK("send cdb\n");
3982 WARN_ON(qc->dev->cdb_len < 12);
3983
3984 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA ||
3985 qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3986 unsigned long flags;
3987
3988 /* Once we're done issuing command and kicking bmdma,
3989 * irq handler takes over. To not lose irq, we need
3990 * to clear NOINTR flag before sending cdb, but
3991 * interrupt handler shouldn't be invoked before we're
3992 * finished. Hence, the following locking.
3993 */
3994 spin_lock_irqsave(&ap->host_set->lock, flags);
3995 ap->flags &= ~ATA_FLAG_NOINTR;
3996 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
3997 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
3998 ap->ops->bmdma_start(qc); /* initiate bmdma */
3999 spin_unlock_irqrestore(&ap->host_set->lock, flags);
4000 } else {
4001 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
4002
4003 /* PIO commands are handled by polling */
4004 ap->hsm_task_state = HSM_ST;
Tejun Heoc91af2c2006-04-02 18:51:53 +09004005 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Tejun Heo8061f5f2006-03-05 15:29:09 +09004006 }
4007
4008 return;
4009
4010err_out:
4011 ata_poll_qc_complete(qc);
4012}
4013
4014/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004015 * ata_qc_new - Request an available ATA command, for queueing
4016 * @ap: Port associated with device @dev
4017 * @dev: Device from whom we request an available command structure
4018 *
4019 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004020 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004021 */
4022
4023static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
4024{
4025 struct ata_queued_cmd *qc = NULL;
4026 unsigned int i;
4027
4028 for (i = 0; i < ATA_MAX_QUEUE; i++)
4029 if (!test_and_set_bit(i, &ap->qactive)) {
4030 qc = ata_qc_from_tag(ap, i);
4031 break;
4032 }
4033
4034 if (qc)
4035 qc->tag = i;
4036
4037 return qc;
4038}
4039
4040/**
4041 * ata_qc_new_init - Request an available ATA command, and initialize it
4042 * @ap: Port associated with device @dev
4043 * @dev: Device from whom we request an available command structure
4044 *
4045 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004046 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004047 */
4048
4049struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
4050 struct ata_device *dev)
4051{
4052 struct ata_queued_cmd *qc;
4053
4054 qc = ata_qc_new(ap);
4055 if (qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004056 qc->scsicmd = NULL;
4057 qc->ap = ap;
4058 qc->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004059
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05004060 ata_qc_reinit(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004061 }
4062
4063 return qc;
4064}
4065
Linus Torvalds1da177e2005-04-16 15:20:36 -07004066/**
4067 * ata_qc_free - free unused ata_queued_cmd
4068 * @qc: Command to complete
4069 *
4070 * Designed to free unused ata_queued_cmd object
4071 * in case something prevents using it.
4072 *
4073 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004074 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004075 */
4076void ata_qc_free(struct ata_queued_cmd *qc)
4077{
Tejun Heo4ba946e2006-01-23 13:09:36 +09004078 struct ata_port *ap = qc->ap;
4079 unsigned int tag;
4080
Tejun Heoa4631472006-02-11 19:11:13 +09004081 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004082
Tejun Heo4ba946e2006-01-23 13:09:36 +09004083 qc->flags = 0;
4084 tag = qc->tag;
4085 if (likely(ata_tag_valid(tag))) {
4086 if (tag == ap->active_tag)
4087 ap->active_tag = ATA_TAG_POISON;
4088 qc->tag = ATA_TAG_POISON;
4089 clear_bit(tag, &ap->qactive);
4090 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004091}
4092
Tejun Heo76014422006-02-11 15:13:49 +09004093void __ata_qc_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094{
Tejun Heoa4631472006-02-11 19:11:13 +09004095 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4096 WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004097
4098 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4099 ata_sg_clean(qc);
4100
Albert Lee3f3791d2005-08-16 14:25:38 +08004101 /* atapi: mark qc as inactive to prevent the interrupt handler
4102 * from completing the command twice later, before the error handler
4103 * is called. (when rc != 0 and atapi request sense is needed)
4104 */
4105 qc->flags &= ~ATA_QCFLAG_ACTIVE;
4106
Linus Torvalds1da177e2005-04-16 15:20:36 -07004107 /* call completion callback */
Tejun Heo77853bf2006-01-23 13:09:36 +09004108 qc->complete_fn(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004109}
4110
4111static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
4112{
4113 struct ata_port *ap = qc->ap;
4114
4115 switch (qc->tf.protocol) {
4116 case ATA_PROT_DMA:
4117 case ATA_PROT_ATAPI_DMA:
4118 return 1;
4119
4120 case ATA_PROT_ATAPI:
4121 case ATA_PROT_PIO:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004122 if (ap->flags & ATA_FLAG_PIO_DMA)
4123 return 1;
4124
4125 /* fall through */
4126
4127 default:
4128 return 0;
4129 }
4130
4131 /* never reached */
4132}
4133
4134/**
4135 * ata_qc_issue - issue taskfile to device
4136 * @qc: command to issue to device
4137 *
4138 * Prepare an ATA command to submission to device.
4139 * This includes mapping the data into a DMA-able
4140 * area, filling in the S/G table, and finally
4141 * writing the taskfile to hardware, starting the command.
4142 *
4143 * LOCKING:
4144 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004145 */
Tejun Heo8e0e6942006-03-31 20:41:11 +09004146void ata_qc_issue(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004147{
4148 struct ata_port *ap = qc->ap;
4149
Tejun Heoe4a70e72006-03-31 20:36:47 +09004150 qc->ap->active_tag = qc->tag;
4151 qc->flags |= ATA_QCFLAG_ACTIVE;
4152
Linus Torvalds1da177e2005-04-16 15:20:36 -07004153 if (ata_should_dma_map(qc)) {
4154 if (qc->flags & ATA_QCFLAG_SG) {
4155 if (ata_sg_setup(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004156 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004157 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
4158 if (ata_sg_setup_one(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004159 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004160 }
4161 } else {
4162 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4163 }
4164
4165 ap->ops->qc_prep(qc);
4166
Tejun Heo8e0e6942006-03-31 20:41:11 +09004167 qc->err_mask |= ap->ops->qc_issue(qc);
4168 if (unlikely(qc->err_mask))
4169 goto err;
4170 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004171
Tejun Heo8e436af2006-01-23 13:09:36 +09004172sg_err:
4173 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Tejun Heo8e0e6942006-03-31 20:41:11 +09004174 qc->err_mask |= AC_ERR_SYSTEM;
4175err:
4176 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004177}
4178
4179/**
4180 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
4181 * @qc: command to issue to device
4182 *
4183 * Using various libata functions and hooks, this function
4184 * starts an ATA command. ATA commands are grouped into
4185 * classes called "protocols", and issuing each type of protocol
4186 * is slightly different.
4187 *
Edward Falk0baab862005-06-02 18:17:13 -04004188 * May be used as the qc_issue() entry in ata_port_operations.
4189 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004190 * LOCKING:
4191 * spin_lock_irqsave(host_set lock)
4192 *
4193 * RETURNS:
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004194 * Zero on success, AC_ERR_* mask on failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004195 */
4196
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004197unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004198{
4199 struct ata_port *ap = qc->ap;
4200
4201 ata_dev_select(ap, qc->dev->devno, 1, 0);
4202
4203 switch (qc->tf.protocol) {
4204 case ATA_PROT_NODATA:
Jeff Garzike5338252005-10-30 21:37:17 -05004205 ata_tf_to_host(ap, &qc->tf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004206 break;
4207
4208 case ATA_PROT_DMA:
4209 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4210 ap->ops->bmdma_setup(qc); /* set up bmdma */
4211 ap->ops->bmdma_start(qc); /* initiate bmdma */
4212 break;
4213
4214 case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
4215 ata_qc_set_polling(qc);
Jeff Garzike5338252005-10-30 21:37:17 -05004216 ata_tf_to_host(ap, &qc->tf);
Albert Lee14be71f2005-09-27 17:36:35 +08004217 ap->hsm_task_state = HSM_ST;
Tejun Heoc91af2c2006-04-02 18:51:53 +09004218 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004219 break;
4220
4221 case ATA_PROT_ATAPI:
4222 ata_qc_set_polling(qc);
Jeff Garzike5338252005-10-30 21:37:17 -05004223 ata_tf_to_host(ap, &qc->tf);
Tejun Heoc91af2c2006-04-02 18:51:53 +09004224 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004225 break;
4226
4227 case ATA_PROT_ATAPI_NODATA:
Tejun Heoc1389502005-08-22 14:59:24 +09004228 ap->flags |= ATA_FLAG_NOINTR;
Jeff Garzike5338252005-10-30 21:37:17 -05004229 ata_tf_to_host(ap, &qc->tf);
Tejun Heoc91af2c2006-04-02 18:51:53 +09004230 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004231 break;
4232
4233 case ATA_PROT_ATAPI_DMA:
Tejun Heoc1389502005-08-22 14:59:24 +09004234 ap->flags |= ATA_FLAG_NOINTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004235 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4236 ap->ops->bmdma_setup(qc); /* set up bmdma */
Tejun Heoc91af2c2006-04-02 18:51:53 +09004237 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004238 break;
4239
4240 default:
4241 WARN_ON(1);
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004242 return AC_ERR_SYSTEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004243 }
4244
4245 return 0;
4246}
4247
4248/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004249 * ata_host_intr - Handle host interrupt for given (port, task)
4250 * @ap: Port on which interrupt arrived (possibly...)
4251 * @qc: Taskfile currently active in engine
4252 *
4253 * Handle host interrupt for given queued command. Currently,
4254 * only DMA interrupts are handled. All other commands are
4255 * handled via polling with interrupts disabled (nIEN bit).
4256 *
4257 * LOCKING:
4258 * spin_lock_irqsave(host_set lock)
4259 *
4260 * RETURNS:
4261 * One if interrupt was handled, zero if not (shared irq).
4262 */
4263
4264inline unsigned int ata_host_intr (struct ata_port *ap,
4265 struct ata_queued_cmd *qc)
4266{
4267 u8 status, host_stat;
4268
4269 switch (qc->tf.protocol) {
4270
4271 case ATA_PROT_DMA:
4272 case ATA_PROT_ATAPI_DMA:
4273 case ATA_PROT_ATAPI:
4274 /* check status of DMA engine */
4275 host_stat = ap->ops->bmdma_status(ap);
4276 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
4277
4278 /* if it's not our irq... */
4279 if (!(host_stat & ATA_DMA_INTR))
4280 goto idle_irq;
4281
4282 /* before we do anything else, clear DMA-Start bit */
Alan Coxb73fc892005-08-26 16:03:19 +01004283 ap->ops->bmdma_stop(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004284
4285 /* fall through */
4286
4287 case ATA_PROT_ATAPI_NODATA:
4288 case ATA_PROT_NODATA:
4289 /* check altstatus */
4290 status = ata_altstatus(ap);
4291 if (status & ATA_BUSY)
4292 goto idle_irq;
4293
4294 /* check main status, clearing INTRQ */
4295 status = ata_chk_status(ap);
4296 if (unlikely(status & ATA_BUSY))
4297 goto idle_irq;
4298 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
4299 ap->id, qc->tf.protocol, status);
4300
4301 /* ack bmdma irq events */
4302 ap->ops->irq_clear(ap);
4303
4304 /* complete taskfile transaction */
Albert Leea22e2eb2005-12-05 15:38:02 +08004305 qc->err_mask |= ac_err_mask(status);
4306 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004307 break;
4308
4309 default:
4310 goto idle_irq;
4311 }
4312
4313 return 1; /* irq handled */
4314
4315idle_irq:
4316 ap->stats.idle_irq++;
4317
4318#ifdef ATA_IRQ_TRAP
4319 if ((ap->stats.idle_irq % 1000) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004320 ata_irq_ack(ap, 0); /* debug trap */
4321 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
Alan Cox23cfce82006-03-21 16:06:53 +00004322 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004323 }
4324#endif
4325 return 0; /* irq not handled */
4326}
4327
4328/**
4329 * ata_interrupt - Default ATA host interrupt handler
Jeff Garzik0cba6322005-05-30 19:49:12 -04004330 * @irq: irq line (unused)
4331 * @dev_instance: pointer to our ata_host_set information structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004332 * @regs: unused
4333 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004334 * Default interrupt handler for PCI IDE devices. Calls
4335 * ata_host_intr() for each port that is not disabled.
4336 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004337 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004338 * Obtains host_set lock during operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004339 *
4340 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004341 * IRQ_NONE or IRQ_HANDLED.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004342 */
4343
4344irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
4345{
4346 struct ata_host_set *host_set = dev_instance;
4347 unsigned int i;
4348 unsigned int handled = 0;
4349 unsigned long flags;
4350
4351 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
4352 spin_lock_irqsave(&host_set->lock, flags);
4353
4354 for (i = 0; i < host_set->n_ports; i++) {
4355 struct ata_port *ap;
4356
4357 ap = host_set->ports[i];
Tejun Heoc1389502005-08-22 14:59:24 +09004358 if (ap &&
Tejun Heo198e0fe2006-04-02 18:51:52 +09004359 !(ap->flags & (ATA_FLAG_DISABLED | ATA_FLAG_NOINTR))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004360 struct ata_queued_cmd *qc;
4361
4362 qc = ata_qc_from_tag(ap, ap->active_tag);
Albert Lee21b1ed72005-04-29 17:34:59 +08004363 if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
4364 (qc->flags & ATA_QCFLAG_ACTIVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004365 handled |= ata_host_intr(ap, qc);
4366 }
4367 }
4368
4369 spin_unlock_irqrestore(&host_set->lock, flags);
4370
4371 return IRQ_RETVAL(handled);
4372}
4373
Edward Falk0baab862005-06-02 18:17:13 -04004374
Jens Axboe9b847542006-01-06 09:28:07 +01004375/*
4376 * Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
4377 * without filling any other registers
4378 */
4379static int ata_do_simple_cmd(struct ata_port *ap, struct ata_device *dev,
4380 u8 cmd)
4381{
4382 struct ata_taskfile tf;
4383 int err;
4384
4385 ata_tf_init(ap, &tf, dev->devno);
4386
4387 tf.command = cmd;
4388 tf.flags |= ATA_TFLAG_DEVICE;
4389 tf.protocol = ATA_PROT_NODATA;
4390
Tejun Heod69cf372006-04-02 18:51:53 +09004391 err = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
Jens Axboe9b847542006-01-06 09:28:07 +01004392 if (err)
4393 printk(KERN_ERR "%s: ata command failed: %d\n",
4394 __FUNCTION__, err);
4395
4396 return err;
4397}
4398
4399static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
4400{
4401 u8 cmd;
4402
4403 if (!ata_try_flush_cache(dev))
4404 return 0;
4405
4406 if (ata_id_has_flush_ext(dev->id))
4407 cmd = ATA_CMD_FLUSH_EXT;
4408 else
4409 cmd = ATA_CMD_FLUSH;
4410
4411 return ata_do_simple_cmd(ap, dev, cmd);
4412}
4413
4414static int ata_standby_drive(struct ata_port *ap, struct ata_device *dev)
4415{
4416 return ata_do_simple_cmd(ap, dev, ATA_CMD_STANDBYNOW1);
4417}
4418
4419static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
4420{
4421 return ata_do_simple_cmd(ap, dev, ATA_CMD_IDLEIMMEDIATE);
4422}
4423
4424/**
4425 * ata_device_resume - wakeup a previously suspended devices
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004426 * @ap: port the device is connected to
4427 * @dev: the device to resume
Jens Axboe9b847542006-01-06 09:28:07 +01004428 *
4429 * Kick the drive back into action, by sending it an idle immediate
4430 * command and making sure its transfer mode matches between drive
4431 * and host.
4432 *
4433 */
4434int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
4435{
4436 if (ap->flags & ATA_FLAG_SUSPENDED) {
Tejun Heoe82cbdb2006-04-01 01:38:18 +09004437 struct ata_device *failed_dev;
Jens Axboe9b847542006-01-06 09:28:07 +01004438 ap->flags &= ~ATA_FLAG_SUSPENDED;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09004439 while (ata_set_mode(ap, &failed_dev))
4440 ata_dev_disable(ap, failed_dev);
Jens Axboe9b847542006-01-06 09:28:07 +01004441 }
Tejun Heoe1211e32006-04-01 01:38:18 +09004442 if (!ata_dev_enabled(dev))
Jens Axboe9b847542006-01-06 09:28:07 +01004443 return 0;
4444 if (dev->class == ATA_DEV_ATA)
4445 ata_start_drive(ap, dev);
4446
4447 return 0;
4448}
4449
4450/**
4451 * ata_device_suspend - prepare a device for suspend
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004452 * @ap: port the device is connected to
4453 * @dev: the device to suspend
Jens Axboe9b847542006-01-06 09:28:07 +01004454 *
4455 * Flush the cache on the drive, if appropriate, then issue a
4456 * standbynow command.
Jens Axboe9b847542006-01-06 09:28:07 +01004457 */
Nigel Cunningham082776e2006-03-23 23:22:16 +10004458int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
Jens Axboe9b847542006-01-06 09:28:07 +01004459{
Tejun Heoe1211e32006-04-01 01:38:18 +09004460 if (!ata_dev_enabled(dev))
Jens Axboe9b847542006-01-06 09:28:07 +01004461 return 0;
4462 if (dev->class == ATA_DEV_ATA)
4463 ata_flush_cache(ap, dev);
4464
Nigel Cunningham082776e2006-03-23 23:22:16 +10004465 if (state.event != PM_EVENT_FREEZE)
4466 ata_standby_drive(ap, dev);
Jens Axboe9b847542006-01-06 09:28:07 +01004467 ap->flags |= ATA_FLAG_SUSPENDED;
4468 return 0;
4469}
4470
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004471/**
4472 * ata_port_start - Set port up for dma.
4473 * @ap: Port to initialize
4474 *
4475 * Called just after data structures for each port are
4476 * initialized. Allocates space for PRD table.
4477 *
4478 * May be used as the port_start() entry in ata_port_operations.
4479 *
4480 * LOCKING:
4481 * Inherited from caller.
4482 */
4483
Linus Torvalds1da177e2005-04-16 15:20:36 -07004484int ata_port_start (struct ata_port *ap)
4485{
Brian King2f1f6102006-03-23 17:30:15 -06004486 struct device *dev = ap->dev;
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004487 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004488
4489 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
4490 if (!ap->prd)
4491 return -ENOMEM;
4492
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004493 rc = ata_pad_alloc(ap, dev);
4494 if (rc) {
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004495 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004496 return rc;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004497 }
4498
Linus Torvalds1da177e2005-04-16 15:20:36 -07004499 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
4500
4501 return 0;
4502}
4503
Edward Falk0baab862005-06-02 18:17:13 -04004504
4505/**
4506 * ata_port_stop - Undo ata_port_start()
4507 * @ap: Port to shut down
4508 *
4509 * Frees the PRD table.
4510 *
4511 * May be used as the port_stop() entry in ata_port_operations.
4512 *
4513 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004514 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04004515 */
4516
Linus Torvalds1da177e2005-04-16 15:20:36 -07004517void ata_port_stop (struct ata_port *ap)
4518{
Brian King2f1f6102006-03-23 17:30:15 -06004519 struct device *dev = ap->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004520
4521 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004522 ata_pad_free(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004523}
4524
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04004525void ata_host_stop (struct ata_host_set *host_set)
4526{
4527 if (host_set->mmio_base)
4528 iounmap(host_set->mmio_base);
4529}
4530
4531
Linus Torvalds1da177e2005-04-16 15:20:36 -07004532/**
4533 * ata_host_remove - Unregister SCSI host structure with upper layers
4534 * @ap: Port to unregister
4535 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
4536 *
4537 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004538 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004539 */
4540
4541static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
4542{
4543 struct Scsi_Host *sh = ap->host;
4544
4545 DPRINTK("ENTER\n");
4546
4547 if (do_unregister)
4548 scsi_remove_host(sh);
4549
4550 ap->ops->port_stop(ap);
4551}
4552
4553/**
4554 * ata_host_init - Initialize an ata_port structure
4555 * @ap: Structure to initialize
4556 * @host: associated SCSI mid-layer structure
4557 * @host_set: Collection of hosts to which @ap belongs
4558 * @ent: Probe information provided by low-level driver
4559 * @port_no: Port number associated with this ata_port
4560 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004561 * Initialize a new ata_port structure, and its associated
4562 * scsi_host.
4563 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004564 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004565 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004566 */
4567
4568static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
4569 struct ata_host_set *host_set,
Jeff Garzik057ace52005-10-22 14:27:05 -04004570 const struct ata_probe_ent *ent, unsigned int port_no)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004571{
4572 unsigned int i;
4573
4574 host->max_id = 16;
4575 host->max_lun = 1;
4576 host->max_channel = 1;
4577 host->unique_id = ata_unique_id++;
4578 host->max_cmd_len = 12;
Christoph Hellwig12413192005-06-11 01:05:01 +02004579
Tejun Heo198e0fe2006-04-02 18:51:52 +09004580 ap->flags = ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004581 ap->id = host->unique_id;
4582 ap->host = host;
4583 ap->ctl = ATA_DEVCTL_OBS;
4584 ap->host_set = host_set;
Brian King2f1f6102006-03-23 17:30:15 -06004585 ap->dev = ent->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004586 ap->port_no = port_no;
4587 ap->hard_port_no =
4588 ent->legacy_mode ? ent->hard_port_no : port_no;
4589 ap->pio_mask = ent->pio_mask;
4590 ap->mwdma_mask = ent->mwdma_mask;
4591 ap->udma_mask = ent->udma_mask;
4592 ap->flags |= ent->host_flags;
4593 ap->ops = ent->port_ops;
4594 ap->cbl = ATA_CBL_NONE;
Tejun Heo1c3fae42006-04-02 20:53:28 +09004595 ap->sata_spd_limit = UINT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596 ap->active_tag = ATA_TAG_POISON;
4597 ap->last_ctl = 0xFF;
4598
Tejun Heo86e45b62006-03-05 15:29:09 +09004599 INIT_WORK(&ap->port_task, NULL, NULL);
Tejun Heoa72ec4c2006-01-23 13:09:37 +09004600 INIT_LIST_HEAD(&ap->eh_done_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004601
Tejun Heoacf356b2006-03-24 14:07:50 +09004602 for (i = 0; i < ATA_MAX_DEVICES; i++) {
4603 struct ata_device *dev = &ap->device[i];
4604 dev->devno = i;
4605 dev->pio_mask = UINT_MAX;
4606 dev->mwdma_mask = UINT_MAX;
4607 dev->udma_mask = UINT_MAX;
4608 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004609
4610#ifdef ATA_IRQ_TRAP
4611 ap->stats.unhandled_irq = 1;
4612 ap->stats.idle_irq = 1;
4613#endif
4614
4615 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
4616}
4617
4618/**
4619 * ata_host_add - Attach low-level ATA driver to system
4620 * @ent: Information provided by low-level driver
4621 * @host_set: Collections of ports to which we add
4622 * @port_no: Port number associated with this host
4623 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004624 * Attach low-level ATA driver to system.
4625 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004626 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004627 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004628 *
4629 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004630 * New ata_port on success, for NULL on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004631 */
4632
Jeff Garzik057ace52005-10-22 14:27:05 -04004633static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004634 struct ata_host_set *host_set,
4635 unsigned int port_no)
4636{
4637 struct Scsi_Host *host;
4638 struct ata_port *ap;
4639 int rc;
4640
4641 DPRINTK("ENTER\n");
Tejun Heoaec5c3c2006-03-25 01:33:34 +09004642
4643 if (!ent->port_ops->probe_reset &&
4644 !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
4645 printk(KERN_ERR "ata%u: no reset mechanism available\n",
4646 port_no);
4647 return NULL;
4648 }
4649
Linus Torvalds1da177e2005-04-16 15:20:36 -07004650 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
4651 if (!host)
4652 return NULL;
4653
Tejun Heo30afc842006-03-18 18:40:14 +09004654 host->transportt = &ata_scsi_transport_template;
4655
Jeff Garzik35bb94b2006-04-11 13:12:34 -04004656 ap = ata_shost_to_port(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004657
4658 ata_host_init(ap, host, host_set, ent, port_no);
4659
4660 rc = ap->ops->port_start(ap);
4661 if (rc)
4662 goto err_out;
4663
4664 return ap;
4665
4666err_out:
4667 scsi_host_put(host);
4668 return NULL;
4669}
4670
4671/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04004672 * ata_device_add - Register hardware device with ATA and SCSI layers
4673 * @ent: Probe information describing hardware device to be registered
4674 *
4675 * This function processes the information provided in the probe
4676 * information struct @ent, allocates the necessary ATA and SCSI
4677 * host information structures, initializes them, and registers
4678 * everything with requisite kernel subsystems.
4679 *
4680 * This function requests irqs, probes the ATA bus, and probes
4681 * the SCSI bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004682 *
4683 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004684 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004685 *
4686 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004687 * Number of ports registered. Zero on error (no ports registered).
Linus Torvalds1da177e2005-04-16 15:20:36 -07004688 */
4689
Jeff Garzik057ace52005-10-22 14:27:05 -04004690int ata_device_add(const struct ata_probe_ent *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004691{
4692 unsigned int count = 0, i;
4693 struct device *dev = ent->dev;
4694 struct ata_host_set *host_set;
4695
4696 DPRINTK("ENTER\n");
4697 /* alloc a container for our list of ATA ports (buses) */
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004698 host_set = kzalloc(sizeof(struct ata_host_set) +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004699 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
4700 if (!host_set)
4701 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004702 spin_lock_init(&host_set->lock);
4703
4704 host_set->dev = dev;
4705 host_set->n_ports = ent->n_ports;
4706 host_set->irq = ent->irq;
4707 host_set->mmio_base = ent->mmio_base;
4708 host_set->private_data = ent->private_data;
4709 host_set->ops = ent->port_ops;
Alan Cox5444a6f2006-03-27 18:58:20 +01004710 host_set->flags = ent->host_set_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004711
4712 /* register each port bound to this device */
4713 for (i = 0; i < ent->n_ports; i++) {
4714 struct ata_port *ap;
4715 unsigned long xfer_mode_mask;
4716
4717 ap = ata_host_add(ent, host_set, i);
4718 if (!ap)
4719 goto err_out;
4720
4721 host_set->ports[i] = ap;
4722 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
4723 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
4724 (ap->pio_mask << ATA_SHIFT_PIO);
4725
4726 /* print per-port info to dmesg */
4727 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
4728 "bmdma 0x%lX irq %lu\n",
4729 ap->id,
4730 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
4731 ata_mode_string(xfer_mode_mask),
4732 ap->ioaddr.cmd_addr,
4733 ap->ioaddr.ctl_addr,
4734 ap->ioaddr.bmdma_addr,
4735 ent->irq);
4736
4737 ata_chk_status(ap);
4738 host_set->ops->irq_clear(ap);
4739 count++;
4740 }
4741
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004742 if (!count)
4743 goto err_free_ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004744
4745 /* obtain irq, that is shared between channels */
4746 if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
4747 DRV_NAME, host_set))
4748 goto err_out;
4749
4750 /* perform each probe synchronously */
4751 DPRINTK("probe begin\n");
4752 for (i = 0; i < count; i++) {
4753 struct ata_port *ap;
4754 int rc;
4755
4756 ap = host_set->ports[i];
4757
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004758 DPRINTK("ata%u: bus probe begin\n", ap->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004759 rc = ata_bus_probe(ap);
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004760 DPRINTK("ata%u: bus probe end\n", ap->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004761
4762 if (rc) {
4763 /* FIXME: do something useful here?
4764 * Current libata behavior will
4765 * tear down everything when
4766 * the module is removed
4767 * or the h/w is unplugged.
4768 */
4769 }
4770
4771 rc = scsi_add_host(ap->host, dev);
4772 if (rc) {
4773 printk(KERN_ERR "ata%u: scsi_add_host failed\n",
4774 ap->id);
4775 /* FIXME: do something useful here */
4776 /* FIXME: handle unconditional calls to
4777 * scsi_scan_host and ata_host_remove, below,
4778 * at the very least
4779 */
4780 }
4781 }
4782
4783 /* probes are done, now scan each port's disk(s) */
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004784 DPRINTK("host probe begin\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004785 for (i = 0; i < count; i++) {
4786 struct ata_port *ap = host_set->ports[i];
4787
Jeff Garzik644dd0c2005-10-03 15:55:19 -04004788 ata_scsi_scan_host(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004789 }
4790
4791 dev_set_drvdata(dev, host_set);
4792
4793 VPRINTK("EXIT, returning %u\n", ent->n_ports);
4794 return ent->n_ports; /* success */
4795
4796err_out:
4797 for (i = 0; i < count; i++) {
4798 ata_host_remove(host_set->ports[i], 1);
4799 scsi_host_put(host_set->ports[i]->host);
4800 }
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004801err_free_ret:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004802 kfree(host_set);
4803 VPRINTK("EXIT, returning 0\n");
4804 return 0;
4805}
4806
4807/**
Alan Cox17b14452005-09-15 15:44:00 +01004808 * ata_host_set_remove - PCI layer callback for device removal
4809 * @host_set: ATA host set that was removed
4810 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05004811 * Unregister all objects associated with this host set. Free those
Alan Cox17b14452005-09-15 15:44:00 +01004812 * objects.
4813 *
4814 * LOCKING:
4815 * Inherited from calling layer (may sleep).
4816 */
4817
Alan Cox17b14452005-09-15 15:44:00 +01004818void ata_host_set_remove(struct ata_host_set *host_set)
4819{
4820 struct ata_port *ap;
4821 unsigned int i;
4822
4823 for (i = 0; i < host_set->n_ports; i++) {
4824 ap = host_set->ports[i];
4825 scsi_remove_host(ap->host);
4826 }
4827
4828 free_irq(host_set->irq, host_set);
4829
4830 for (i = 0; i < host_set->n_ports; i++) {
4831 ap = host_set->ports[i];
4832
4833 ata_scsi_release(ap->host);
4834
4835 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
4836 struct ata_ioports *ioaddr = &ap->ioaddr;
4837
4838 if (ioaddr->cmd_addr == 0x1f0)
4839 release_region(0x1f0, 8);
4840 else if (ioaddr->cmd_addr == 0x170)
4841 release_region(0x170, 8);
4842 }
4843
4844 scsi_host_put(ap->host);
4845 }
4846
4847 if (host_set->ops->host_stop)
4848 host_set->ops->host_stop(host_set);
4849
4850 kfree(host_set);
4851}
4852
4853/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004854 * ata_scsi_release - SCSI layer callback hook for host unload
4855 * @host: libata host to be unloaded
4856 *
4857 * Performs all duties necessary to shut down a libata port...
4858 * Kill port kthread, disable port, and release resources.
4859 *
4860 * LOCKING:
4861 * Inherited from SCSI layer.
4862 *
4863 * RETURNS:
4864 * One.
4865 */
4866
4867int ata_scsi_release(struct Scsi_Host *host)
4868{
Jeff Garzik35bb94b2006-04-11 13:12:34 -04004869 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heod9572b12006-03-01 16:09:35 +09004870 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004871
4872 DPRINTK("ENTER\n");
4873
4874 ap->ops->port_disable(ap);
4875 ata_host_remove(ap, 0);
Tejun Heod9572b12006-03-01 16:09:35 +09004876 for (i = 0; i < ATA_MAX_DEVICES; i++)
4877 kfree(ap->device[i].id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004878
4879 DPRINTK("EXIT\n");
4880 return 1;
4881}
4882
4883/**
4884 * ata_std_ports - initialize ioaddr with standard port offsets.
4885 * @ioaddr: IO address structure to be initialized
Edward Falk0baab862005-06-02 18:17:13 -04004886 *
4887 * Utility function which initializes data_addr, error_addr,
4888 * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
4889 * device_addr, status_addr, and command_addr to standard offsets
4890 * relative to cmd_addr.
4891 *
4892 * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004893 */
Edward Falk0baab862005-06-02 18:17:13 -04004894
Linus Torvalds1da177e2005-04-16 15:20:36 -07004895void ata_std_ports(struct ata_ioports *ioaddr)
4896{
4897 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
4898 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
4899 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
4900 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
4901 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
4902 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
4903 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
4904 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
4905 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
4906 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
4907}
4908
Edward Falk0baab862005-06-02 18:17:13 -04004909
Jeff Garzik374b1872005-08-30 05:42:52 -04004910#ifdef CONFIG_PCI
4911
4912void ata_pci_host_stop (struct ata_host_set *host_set)
4913{
4914 struct pci_dev *pdev = to_pci_dev(host_set->dev);
4915
4916 pci_iounmap(pdev, host_set->mmio_base);
4917}
4918
Edward Falk0baab862005-06-02 18:17:13 -04004919/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004920 * ata_pci_remove_one - PCI layer callback for device removal
4921 * @pdev: PCI device that was removed
4922 *
4923 * PCI layer indicates to libata via this hook that
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004924 * hot-unplug or module unload event has occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004925 * Handle this by unregistering all objects associated
4926 * with this PCI device. Free those objects. Then finally
4927 * release PCI resources and disable device.
4928 *
4929 * LOCKING:
4930 * Inherited from PCI layer (may sleep).
4931 */
4932
4933void ata_pci_remove_one (struct pci_dev *pdev)
4934{
4935 struct device *dev = pci_dev_to_dev(pdev);
4936 struct ata_host_set *host_set = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004937
Alan Cox17b14452005-09-15 15:44:00 +01004938 ata_host_set_remove(host_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004939 pci_release_regions(pdev);
4940 pci_disable_device(pdev);
4941 dev_set_drvdata(dev, NULL);
4942}
4943
4944/* move to PCI subsystem */
Jeff Garzik057ace52005-10-22 14:27:05 -04004945int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004946{
4947 unsigned long tmp = 0;
4948
4949 switch (bits->width) {
4950 case 1: {
4951 u8 tmp8 = 0;
4952 pci_read_config_byte(pdev, bits->reg, &tmp8);
4953 tmp = tmp8;
4954 break;
4955 }
4956 case 2: {
4957 u16 tmp16 = 0;
4958 pci_read_config_word(pdev, bits->reg, &tmp16);
4959 tmp = tmp16;
4960 break;
4961 }
4962 case 4: {
4963 u32 tmp32 = 0;
4964 pci_read_config_dword(pdev, bits->reg, &tmp32);
4965 tmp = tmp32;
4966 break;
4967 }
4968
4969 default:
4970 return -EINVAL;
4971 }
4972
4973 tmp &= bits->mask;
4974
4975 return (tmp == bits->val) ? 1 : 0;
4976}
Jens Axboe9b847542006-01-06 09:28:07 +01004977
4978int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state)
4979{
4980 pci_save_state(pdev);
4981 pci_disable_device(pdev);
4982 pci_set_power_state(pdev, PCI_D3hot);
4983 return 0;
4984}
4985
4986int ata_pci_device_resume(struct pci_dev *pdev)
4987{
4988 pci_set_power_state(pdev, PCI_D0);
4989 pci_restore_state(pdev);
4990 pci_enable_device(pdev);
4991 pci_set_master(pdev);
4992 return 0;
4993}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004994#endif /* CONFIG_PCI */
4995
4996
Linus Torvalds1da177e2005-04-16 15:20:36 -07004997static int __init ata_init(void)
4998{
4999 ata_wq = create_workqueue("ata");
5000 if (!ata_wq)
5001 return -ENOMEM;
5002
5003 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
5004 return 0;
5005}
5006
5007static void __exit ata_exit(void)
5008{
5009 destroy_workqueue(ata_wq);
5010}
5011
5012module_init(ata_init);
5013module_exit(ata_exit);
5014
Jeff Garzik67846b32005-10-05 02:58:32 -04005015static unsigned long ratelimit_time;
5016static spinlock_t ata_ratelimit_lock = SPIN_LOCK_UNLOCKED;
5017
5018int ata_ratelimit(void)
5019{
5020 int rc;
5021 unsigned long flags;
5022
5023 spin_lock_irqsave(&ata_ratelimit_lock, flags);
5024
5025 if (time_after(jiffies, ratelimit_time)) {
5026 rc = 1;
5027 ratelimit_time = jiffies + (HZ/5);
5028 } else
5029 rc = 0;
5030
5031 spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
5032
5033 return rc;
5034}
5035
Tejun Heoc22daff2006-04-11 22:22:29 +09005036/**
5037 * ata_wait_register - wait until register value changes
5038 * @reg: IO-mapped register
5039 * @mask: Mask to apply to read register value
5040 * @val: Wait condition
5041 * @interval_msec: polling interval in milliseconds
5042 * @timeout_msec: timeout in milliseconds
5043 *
5044 * Waiting for some bits of register to change is a common
5045 * operation for ATA controllers. This function reads 32bit LE
5046 * IO-mapped register @reg and tests for the following condition.
5047 *
5048 * (*@reg & mask) != val
5049 *
5050 * If the condition is met, it returns; otherwise, the process is
5051 * repeated after @interval_msec until timeout.
5052 *
5053 * LOCKING:
5054 * Kernel thread context (may sleep)
5055 *
5056 * RETURNS:
5057 * The final register value.
5058 */
5059u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
5060 unsigned long interval_msec,
5061 unsigned long timeout_msec)
5062{
5063 unsigned long timeout;
5064 u32 tmp;
5065
5066 tmp = ioread32(reg);
5067
5068 /* Calculate timeout _after_ the first read to make sure
5069 * preceding writes reach the controller before starting to
5070 * eat away the timeout.
5071 */
5072 timeout = jiffies + (timeout_msec * HZ) / 1000;
5073
5074 while ((tmp & mask) == val && time_before(jiffies, timeout)) {
5075 msleep(interval_msec);
5076 tmp = ioread32(reg);
5077 }
5078
5079 return tmp;
5080}
5081
Linus Torvalds1da177e2005-04-16 15:20:36 -07005082/*
5083 * libata is essentially a library of internal helper functions for
5084 * low-level ATA host controller drivers. As such, the API/ABI is
5085 * likely to change as new drivers are added and updated.
5086 * Do not depend on ABI/API stability.
5087 */
5088
5089EXPORT_SYMBOL_GPL(ata_std_bios_param);
5090EXPORT_SYMBOL_GPL(ata_std_ports);
5091EXPORT_SYMBOL_GPL(ata_device_add);
Alan Cox17b14452005-09-15 15:44:00 +01005092EXPORT_SYMBOL_GPL(ata_host_set_remove);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005093EXPORT_SYMBOL_GPL(ata_sg_init);
5094EXPORT_SYMBOL_GPL(ata_sg_init_one);
Tejun Heo76014422006-02-11 15:13:49 +09005095EXPORT_SYMBOL_GPL(__ata_qc_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005096EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005097EXPORT_SYMBOL_GPL(ata_tf_load);
5098EXPORT_SYMBOL_GPL(ata_tf_read);
5099EXPORT_SYMBOL_GPL(ata_noop_dev_select);
5100EXPORT_SYMBOL_GPL(ata_std_dev_select);
5101EXPORT_SYMBOL_GPL(ata_tf_to_fis);
5102EXPORT_SYMBOL_GPL(ata_tf_from_fis);
5103EXPORT_SYMBOL_GPL(ata_check_status);
5104EXPORT_SYMBOL_GPL(ata_altstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005105EXPORT_SYMBOL_GPL(ata_exec_command);
5106EXPORT_SYMBOL_GPL(ata_port_start);
5107EXPORT_SYMBOL_GPL(ata_port_stop);
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04005108EXPORT_SYMBOL_GPL(ata_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005109EXPORT_SYMBOL_GPL(ata_interrupt);
5110EXPORT_SYMBOL_GPL(ata_qc_prep);
Brian Kinge46834c2006-03-17 17:04:03 -06005111EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005112EXPORT_SYMBOL_GPL(ata_bmdma_setup);
5113EXPORT_SYMBOL_GPL(ata_bmdma_start);
5114EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
5115EXPORT_SYMBOL_GPL(ata_bmdma_status);
5116EXPORT_SYMBOL_GPL(ata_bmdma_stop);
5117EXPORT_SYMBOL_GPL(ata_port_probe);
Tejun Heo3c567b72006-05-15 20:57:23 +09005118EXPORT_SYMBOL_GPL(sata_set_spd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005119EXPORT_SYMBOL_GPL(sata_phy_reset);
5120EXPORT_SYMBOL_GPL(__sata_phy_reset);
5121EXPORT_SYMBOL_GPL(ata_bus_reset);
Tejun Heo8a19ac82006-02-02 18:20:00 +09005122EXPORT_SYMBOL_GPL(ata_std_probeinit);
Tejun Heoc2bd5802006-01-24 17:05:22 +09005123EXPORT_SYMBOL_GPL(ata_std_softreset);
5124EXPORT_SYMBOL_GPL(sata_std_hardreset);
5125EXPORT_SYMBOL_GPL(ata_std_postreset);
5126EXPORT_SYMBOL_GPL(ata_std_probe_reset);
Tejun Heoa62c0fc2006-01-24 17:05:22 +09005127EXPORT_SYMBOL_GPL(ata_drive_probe_reset);
Tejun Heo623a3122006-03-05 17:55:58 +09005128EXPORT_SYMBOL_GPL(ata_dev_revalidate);
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05005129EXPORT_SYMBOL_GPL(ata_dev_classify);
5130EXPORT_SYMBOL_GPL(ata_dev_pair);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005131EXPORT_SYMBOL_GPL(ata_port_disable);
Jeff Garzik67846b32005-10-05 02:58:32 -04005132EXPORT_SYMBOL_GPL(ata_ratelimit);
Tejun Heoc22daff2006-04-11 22:22:29 +09005133EXPORT_SYMBOL_GPL(ata_wait_register);
Tejun Heo6f8b9952006-01-24 17:05:21 +09005134EXPORT_SYMBOL_GPL(ata_busy_sleep);
Tejun Heo86e45b62006-03-05 15:29:09 +09005135EXPORT_SYMBOL_GPL(ata_port_queue_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005136EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
5137EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005138EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
5139EXPORT_SYMBOL_GPL(ata_scsi_release);
5140EXPORT_SYMBOL_GPL(ata_host_intr);
Tejun Heo6a62a042006-02-13 10:02:46 +09005141EXPORT_SYMBOL_GPL(ata_id_string);
5142EXPORT_SYMBOL_GPL(ata_id_c_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005143EXPORT_SYMBOL_GPL(ata_scsi_simulate);
5144
Alan Cox1bc4ccf2006-01-09 17:18:14 +00005145EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
Alan Cox452503f2005-10-21 19:01:32 -04005146EXPORT_SYMBOL_GPL(ata_timing_compute);
5147EXPORT_SYMBOL_GPL(ata_timing_merge);
5148
Linus Torvalds1da177e2005-04-16 15:20:36 -07005149#ifdef CONFIG_PCI
5150EXPORT_SYMBOL_GPL(pci_test_config_bits);
Jeff Garzik374b1872005-08-30 05:42:52 -04005151EXPORT_SYMBOL_GPL(ata_pci_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005152EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
5153EXPORT_SYMBOL_GPL(ata_pci_init_one);
5154EXPORT_SYMBOL_GPL(ata_pci_remove_one);
Jens Axboe9b847542006-01-06 09:28:07 +01005155EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
5156EXPORT_SYMBOL_GPL(ata_pci_device_resume);
Alan Cox67951ad2006-03-22 15:55:54 +00005157EXPORT_SYMBOL_GPL(ata_pci_default_filter);
5158EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005159#endif /* CONFIG_PCI */
Jens Axboe9b847542006-01-06 09:28:07 +01005160
5161EXPORT_SYMBOL_GPL(ata_device_suspend);
5162EXPORT_SYMBOL_GPL(ata_device_resume);
5163EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
5164EXPORT_SYMBOL_GPL(ata_scsi_device_resume);
Tejun Heoece1d632006-04-02 18:51:53 +09005165
Tejun Heoece1d632006-04-02 18:51:53 +09005166EXPORT_SYMBOL_GPL(ata_eng_timeout);
5167EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
5168EXPORT_SYMBOL_GPL(ata_eh_qc_retry);