blob: 59cb12993f958c838faec674ff89cd09b7489aea [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,
65 struct ata_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066static void ata_set_mode(struct ata_port *ap);
Tejun Heo83206a22006-03-24 15:25:31 +090067static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
68 struct ata_device *dev);
Tejun Heoacf356b2006-03-24 14:07:50 +090069static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71static unsigned int ata_unique_id = 1;
72static struct workqueue_struct *ata_wq;
73
Jeff Garzik418dc1f2006-03-11 20:50:08 -050074int atapi_enabled = 1;
Jeff Garzik1623c812005-08-30 03:37:42 -040075module_param(atapi_enabled, int, 0444);
76MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
77
Jeff Garzikc3c013a2006-02-27 22:31:19 -050078int libata_fua = 0;
79module_param_named(fua, libata_fua, int, 0444);
80MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
81
Linus Torvalds1da177e2005-04-16 15:20:36 -070082MODULE_AUTHOR("Jeff Garzik");
83MODULE_DESCRIPTION("Library module for ATA devices");
84MODULE_LICENSE("GPL");
85MODULE_VERSION(DRV_VERSION);
86
Edward Falk0baab862005-06-02 18:17:13 -040087
88/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
90 * @tf: Taskfile to convert
91 * @fis: Buffer into which data will output
92 * @pmp: Port multiplier port
93 *
94 * Converts a standard ATA taskfile to a Serial ATA
95 * FIS structure (Register - Host to Device).
96 *
97 * LOCKING:
98 * Inherited from caller.
99 */
100
Jeff Garzik057ace52005-10-22 14:27:05 -0400101void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
103 fis[0] = 0x27; /* Register - Host to Device FIS */
104 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
105 bit 7 indicates Command FIS */
106 fis[2] = tf->command;
107 fis[3] = tf->feature;
108
109 fis[4] = tf->lbal;
110 fis[5] = tf->lbam;
111 fis[6] = tf->lbah;
112 fis[7] = tf->device;
113
114 fis[8] = tf->hob_lbal;
115 fis[9] = tf->hob_lbam;
116 fis[10] = tf->hob_lbah;
117 fis[11] = tf->hob_feature;
118
119 fis[12] = tf->nsect;
120 fis[13] = tf->hob_nsect;
121 fis[14] = 0;
122 fis[15] = tf->ctl;
123
124 fis[16] = 0;
125 fis[17] = 0;
126 fis[18] = 0;
127 fis[19] = 0;
128}
129
130/**
131 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
132 * @fis: Buffer from which data will be input
133 * @tf: Taskfile to output
134 *
Mark Lorde12a1be2005-11-12 18:55:45 -0500135 * Converts a serial ATA FIS structure to a standard ATA taskfile.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 *
137 * LOCKING:
138 * Inherited from caller.
139 */
140
Jeff Garzik057ace52005-10-22 14:27:05 -0400141void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
143 tf->command = fis[2]; /* status */
144 tf->feature = fis[3]; /* error */
145
146 tf->lbal = fis[4];
147 tf->lbam = fis[5];
148 tf->lbah = fis[6];
149 tf->device = fis[7];
150
151 tf->hob_lbal = fis[8];
152 tf->hob_lbam = fis[9];
153 tf->hob_lbah = fis[10];
154
155 tf->nsect = fis[12];
156 tf->hob_nsect = fis[13];
157}
158
Albert Lee8cbd6df2005-10-12 15:06:27 +0800159static const u8 ata_rw_cmds[] = {
160 /* pio multi */
161 ATA_CMD_READ_MULTI,
162 ATA_CMD_WRITE_MULTI,
163 ATA_CMD_READ_MULTI_EXT,
164 ATA_CMD_WRITE_MULTI_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100165 0,
166 0,
167 0,
168 ATA_CMD_WRITE_MULTI_FUA_EXT,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800169 /* pio */
170 ATA_CMD_PIO_READ,
171 ATA_CMD_PIO_WRITE,
172 ATA_CMD_PIO_READ_EXT,
173 ATA_CMD_PIO_WRITE_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100174 0,
175 0,
176 0,
177 0,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800178 /* dma */
179 ATA_CMD_READ,
180 ATA_CMD_WRITE,
181 ATA_CMD_READ_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100182 ATA_CMD_WRITE_EXT,
183 0,
184 0,
185 0,
186 ATA_CMD_WRITE_FUA_EXT
Albert Lee8cbd6df2005-10-12 15:06:27 +0800187};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189/**
Albert Lee8cbd6df2005-10-12 15:06:27 +0800190 * ata_rwcmd_protocol - set taskfile r/w commands and protocol
191 * @qc: command to examine and configure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500193 * Examine the device configuration and tf->flags to calculate
Albert Lee8cbd6df2005-10-12 15:06:27 +0800194 * the proper read/write commands and protocol to use.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 *
196 * LOCKING:
197 * caller.
198 */
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100199int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
Albert Lee8cbd6df2005-10-12 15:06:27 +0800201 struct ata_taskfile *tf = &qc->tf;
202 struct ata_device *dev = qc->dev;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100203 u8 cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100205 int index, fua, lba48, write;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500206
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100207 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800208 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
209 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Albert Lee8cbd6df2005-10-12 15:06:27 +0800211 if (dev->flags & ATA_DFLAG_PIO) {
212 tf->protocol = ATA_PROT_PIO;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100213 index = dev->multi_count ? 0 : 8;
Alan Cox8d238e02006-01-17 20:50:31 +0000214 } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
215 /* Unable to use DMA due to host limitation */
216 tf->protocol = ATA_PROT_PIO;
Albert Leeaef9d532006-02-08 16:37:43 +0800217 index = dev->multi_count ? 0 : 8;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800218 } else {
219 tf->protocol = ATA_PROT_DMA;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100220 index = 16;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800221 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100223 cmd = ata_rw_cmds[index + fua + lba48 + write];
224 if (cmd) {
225 tf->command = cmd;
226 return 0;
227 }
228 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229}
230
Tejun Heocb95d562006-03-06 04:31:56 +0900231/**
232 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
233 * @pio_mask: pio_mask
234 * @mwdma_mask: mwdma_mask
235 * @udma_mask: udma_mask
236 *
237 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
238 * unsigned int xfer_mask.
239 *
240 * LOCKING:
241 * None.
242 *
243 * RETURNS:
244 * Packed xfer_mask.
245 */
246static unsigned int ata_pack_xfermask(unsigned int pio_mask,
247 unsigned int mwdma_mask,
248 unsigned int udma_mask)
249{
250 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
251 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
252 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
253}
254
Tejun Heoc0489e42006-03-24 14:07:49 +0900255/**
256 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
257 * @xfer_mask: xfer_mask to unpack
258 * @pio_mask: resulting pio_mask
259 * @mwdma_mask: resulting mwdma_mask
260 * @udma_mask: resulting udma_mask
261 *
262 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
263 * Any NULL distination masks will be ignored.
264 */
265static void ata_unpack_xfermask(unsigned int xfer_mask,
266 unsigned int *pio_mask,
267 unsigned int *mwdma_mask,
268 unsigned int *udma_mask)
269{
270 if (pio_mask)
271 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
272 if (mwdma_mask)
273 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
274 if (udma_mask)
275 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
276}
277
Tejun Heocb95d562006-03-06 04:31:56 +0900278static const struct ata_xfer_ent {
279 unsigned int shift, bits;
280 u8 base;
281} ata_xfer_tbl[] = {
282 { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
283 { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
284 { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
285 { -1, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286};
287
288/**
Tejun Heocb95d562006-03-06 04:31:56 +0900289 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
290 * @xfer_mask: xfer_mask of interest
291 *
292 * Return matching XFER_* value for @xfer_mask. Only the highest
293 * bit of @xfer_mask is considered.
294 *
295 * LOCKING:
296 * None.
297 *
298 * RETURNS:
299 * Matching XFER_* value, 0 if no match found.
300 */
301static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
302{
303 int highbit = fls(xfer_mask) - 1;
304 const struct ata_xfer_ent *ent;
305
306 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
307 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
308 return ent->base + highbit - ent->shift;
309 return 0;
310}
311
312/**
313 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
314 * @xfer_mode: XFER_* of interest
315 *
316 * Return matching xfer_mask for @xfer_mode.
317 *
318 * LOCKING:
319 * None.
320 *
321 * RETURNS:
322 * Matching xfer_mask, 0 if no match found.
323 */
324static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
325{
326 const struct ata_xfer_ent *ent;
327
328 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
329 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
330 return 1 << (ent->shift + xfer_mode - ent->base);
331 return 0;
332}
333
334/**
335 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
336 * @xfer_mode: XFER_* of interest
337 *
338 * Return matching xfer_shift for @xfer_mode.
339 *
340 * LOCKING:
341 * None.
342 *
343 * RETURNS:
344 * Matching xfer_shift, -1 if no match found.
345 */
346static int ata_xfer_mode2shift(unsigned int xfer_mode)
347{
348 const struct ata_xfer_ent *ent;
349
350 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
351 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
352 return ent->shift;
353 return -1;
354}
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356/**
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900357 * ata_mode_string - convert xfer_mask to string
358 * @xfer_mask: mask of bits supported; only highest bit counts.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 *
360 * Determine string which represents the highest speed
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900361 * (highest bit in @modemask).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 *
363 * LOCKING:
364 * None.
365 *
366 * RETURNS:
367 * Constant C string representing highest speed listed in
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900368 * @mode_mask, or the constant C string "<n/a>".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 */
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900370static const char *ata_mode_string(unsigned int xfer_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
Tejun Heo75f554b2006-03-06 04:31:57 +0900372 static const char * const xfer_mode_str[] = {
373 "PIO0",
374 "PIO1",
375 "PIO2",
376 "PIO3",
377 "PIO4",
378 "MWDMA0",
379 "MWDMA1",
380 "MWDMA2",
381 "UDMA/16",
382 "UDMA/25",
383 "UDMA/33",
384 "UDMA/44",
385 "UDMA/66",
386 "UDMA/100",
387 "UDMA/133",
388 "UDMA7",
389 };
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900390 int highbit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900392 highbit = fls(xfer_mask) - 1;
393 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
394 return xfer_mode_str[highbit];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 return "<n/a>";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396}
397
Tejun Heo0b8efb02006-03-24 15:25:31 +0900398static void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
399{
400 if (ata_dev_present(dev)) {
401 printk(KERN_WARNING "ata%u: dev %u disabled\n",
402 ap->id, dev->devno);
403 dev->class++;
404 }
405}
406
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407/**
408 * ata_pio_devchk - PATA device presence detection
409 * @ap: ATA channel to examine
410 * @device: Device to examine (starting at zero)
411 *
412 * This technique was originally described in
413 * Hale Landis's ATADRVR (www.ata-atapi.com), and
414 * later found its way into the ATA/ATAPI spec.
415 *
416 * Write a pattern to the ATA shadow registers,
417 * and if a device is present, it will respond by
418 * correctly storing and echoing back the
419 * ATA shadow register contents.
420 *
421 * LOCKING:
422 * caller.
423 */
424
425static unsigned int ata_pio_devchk(struct ata_port *ap,
426 unsigned int device)
427{
428 struct ata_ioports *ioaddr = &ap->ioaddr;
429 u8 nsect, lbal;
430
431 ap->ops->dev_select(ap, device);
432
433 outb(0x55, ioaddr->nsect_addr);
434 outb(0xaa, ioaddr->lbal_addr);
435
436 outb(0xaa, ioaddr->nsect_addr);
437 outb(0x55, ioaddr->lbal_addr);
438
439 outb(0x55, ioaddr->nsect_addr);
440 outb(0xaa, ioaddr->lbal_addr);
441
442 nsect = inb(ioaddr->nsect_addr);
443 lbal = inb(ioaddr->lbal_addr);
444
445 if ((nsect == 0x55) && (lbal == 0xaa))
446 return 1; /* we found a device */
447
448 return 0; /* nothing found */
449}
450
451/**
452 * ata_mmio_devchk - PATA device presence detection
453 * @ap: ATA channel to examine
454 * @device: Device to examine (starting at zero)
455 *
456 * This technique was originally described in
457 * Hale Landis's ATADRVR (www.ata-atapi.com), and
458 * later found its way into the ATA/ATAPI spec.
459 *
460 * Write a pattern to the ATA shadow registers,
461 * and if a device is present, it will respond by
462 * correctly storing and echoing back the
463 * ATA shadow register contents.
464 *
465 * LOCKING:
466 * caller.
467 */
468
469static unsigned int ata_mmio_devchk(struct ata_port *ap,
470 unsigned int device)
471{
472 struct ata_ioports *ioaddr = &ap->ioaddr;
473 u8 nsect, lbal;
474
475 ap->ops->dev_select(ap, device);
476
477 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
478 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
479
480 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
481 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
482
483 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
484 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
485
486 nsect = readb((void __iomem *) ioaddr->nsect_addr);
487 lbal = readb((void __iomem *) ioaddr->lbal_addr);
488
489 if ((nsect == 0x55) && (lbal == 0xaa))
490 return 1; /* we found a device */
491
492 return 0; /* nothing found */
493}
494
495/**
496 * ata_devchk - PATA device presence detection
497 * @ap: ATA channel to examine
498 * @device: Device to examine (starting at zero)
499 *
500 * Dispatch ATA device presence detection, depending
501 * on whether we are using PIO or MMIO to talk to the
502 * ATA shadow registers.
503 *
504 * LOCKING:
505 * caller.
506 */
507
508static unsigned int ata_devchk(struct ata_port *ap,
509 unsigned int device)
510{
511 if (ap->flags & ATA_FLAG_MMIO)
512 return ata_mmio_devchk(ap, device);
513 return ata_pio_devchk(ap, device);
514}
515
516/**
517 * ata_dev_classify - determine device type based on ATA-spec signature
518 * @tf: ATA taskfile register set for device to be identified
519 *
520 * Determine from taskfile register contents whether a device is
521 * ATA or ATAPI, as per "Signature and persistence" section
522 * of ATA/PI spec (volume 1, sect 5.14).
523 *
524 * LOCKING:
525 * None.
526 *
527 * RETURNS:
528 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
529 * the event of failure.
530 */
531
Jeff Garzik057ace52005-10-22 14:27:05 -0400532unsigned int ata_dev_classify(const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
534 /* Apple's open source Darwin code hints that some devices only
535 * put a proper signature into the LBA mid/high registers,
536 * So, we only check those. It's sufficient for uniqueness.
537 */
538
539 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
540 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
541 DPRINTK("found ATA device by sig\n");
542 return ATA_DEV_ATA;
543 }
544
545 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
546 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
547 DPRINTK("found ATAPI device by sig\n");
548 return ATA_DEV_ATAPI;
549 }
550
551 DPRINTK("unknown device\n");
552 return ATA_DEV_UNKNOWN;
553}
554
555/**
556 * ata_dev_try_classify - Parse returned ATA device signature
557 * @ap: ATA channel to examine
558 * @device: Device to examine (starting at zero)
Tejun Heob4dc7622006-01-24 17:05:22 +0900559 * @r_err: Value of error register on completion
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 *
561 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
562 * an ATA/ATAPI-defined set of values is placed in the ATA
563 * shadow registers, indicating the results of device detection
564 * and diagnostics.
565 *
566 * Select the ATA device, and read the values from the ATA shadow
567 * registers. Then parse according to the Error register value,
568 * and the spec-defined values examined by ata_dev_classify().
569 *
570 * LOCKING:
571 * caller.
Tejun Heob4dc7622006-01-24 17:05:22 +0900572 *
573 * RETURNS:
574 * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 */
576
Tejun Heob4dc7622006-01-24 17:05:22 +0900577static unsigned int
578ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 struct ata_taskfile tf;
581 unsigned int class;
582 u8 err;
583
584 ap->ops->dev_select(ap, device);
585
586 memset(&tf, 0, sizeof(tf));
587
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 ap->ops->tf_read(ap, &tf);
Jeff Garzik0169e282005-10-29 21:25:10 -0400589 err = tf.feature;
Tejun Heob4dc7622006-01-24 17:05:22 +0900590 if (r_err)
591 *r_err = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 /* see if device passed diags */
594 if (err == 1)
595 /* do nothing */ ;
596 else if ((device == 0) && (err == 0x81))
597 /* do nothing */ ;
598 else
Tejun Heob4dc7622006-01-24 17:05:22 +0900599 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Tejun Heob4dc7622006-01-24 17:05:22 +0900601 /* determine if device is ATA or ATAPI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 class = ata_dev_classify(&tf);
Tejun Heob4dc7622006-01-24 17:05:22 +0900603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 if (class == ATA_DEV_UNKNOWN)
Tejun Heob4dc7622006-01-24 17:05:22 +0900605 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
Tejun Heob4dc7622006-01-24 17:05:22 +0900607 return ATA_DEV_NONE;
608 return class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609}
610
611/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900612 * ata_id_string - Convert IDENTIFY DEVICE page into string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 * @id: IDENTIFY DEVICE results we will examine
614 * @s: string into which data is output
615 * @ofs: offset into identify device page
616 * @len: length of string to return. must be an even number.
617 *
618 * The strings in the IDENTIFY DEVICE page are broken up into
619 * 16-bit chunks. Run through the string, and output each
620 * 8-bit chunk linearly, regardless of platform.
621 *
622 * LOCKING:
623 * caller.
624 */
625
Tejun Heo6a62a042006-02-13 10:02:46 +0900626void ata_id_string(const u16 *id, unsigned char *s,
627 unsigned int ofs, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628{
629 unsigned int c;
630
631 while (len > 0) {
632 c = id[ofs] >> 8;
633 *s = c;
634 s++;
635
636 c = id[ofs] & 0xff;
637 *s = c;
638 s++;
639
640 ofs++;
641 len -= 2;
642 }
643}
644
Tejun Heo0e949ff2006-02-12 22:47:04 +0900645/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900646 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
Tejun Heo0e949ff2006-02-12 22:47:04 +0900647 * @id: IDENTIFY DEVICE results we will examine
648 * @s: string into which data is output
649 * @ofs: offset into identify device page
650 * @len: length of string to return. must be an odd number.
651 *
Tejun Heo6a62a042006-02-13 10:02:46 +0900652 * This function is identical to ata_id_string except that it
Tejun Heo0e949ff2006-02-12 22:47:04 +0900653 * trims trailing spaces and terminates the resulting string with
654 * null. @len must be actual maximum length (even number) + 1.
655 *
656 * LOCKING:
657 * caller.
658 */
Tejun Heo6a62a042006-02-13 10:02:46 +0900659void ata_id_c_string(const u16 *id, unsigned char *s,
660 unsigned int ofs, unsigned int len)
Tejun Heo0e949ff2006-02-12 22:47:04 +0900661{
662 unsigned char *p;
663
664 WARN_ON(!(len & 1));
665
Tejun Heo6a62a042006-02-13 10:02:46 +0900666 ata_id_string(id, s, ofs, len - 1);
Tejun Heo0e949ff2006-02-12 22:47:04 +0900667
668 p = s + strnlen(s, len - 1);
669 while (p > s && p[-1] == ' ')
670 p--;
671 *p = '\0';
672}
Edward Falk0baab862005-06-02 18:17:13 -0400673
Tejun Heo29407402006-02-12 22:47:04 +0900674static u64 ata_id_n_sectors(const u16 *id)
675{
676 if (ata_id_has_lba(id)) {
677 if (ata_id_has_lba48(id))
678 return ata_id_u64(id, 100);
679 else
680 return ata_id_u32(id, 60);
681 } else {
682 if (ata_id_current_chs_valid(id))
683 return ata_id_u32(id, 57);
684 else
685 return id[1] * id[3] * id[6];
686 }
687}
Edward Falk0baab862005-06-02 18:17:13 -0400688
689/**
690 * ata_noop_dev_select - Select device 0/1 on ATA bus
691 * @ap: ATA channel to manipulate
692 * @device: ATA device (numbered from zero) to select
693 *
694 * This function performs no actual function.
695 *
696 * May be used as the dev_select() entry in ata_port_operations.
697 *
698 * LOCKING:
699 * caller.
700 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
702{
703}
704
Edward Falk0baab862005-06-02 18:17:13 -0400705
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706/**
707 * ata_std_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 * Use the method defined in the ATA specification to
712 * make either device 0, or device 1, active on the
Edward Falk0baab862005-06-02 18:17:13 -0400713 * ATA channel. Works with both PIO and MMIO.
714 *
715 * May be used as the dev_select() entry in ata_port_operations.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 *
717 * LOCKING:
718 * caller.
719 */
720
721void ata_std_dev_select (struct ata_port *ap, unsigned int device)
722{
723 u8 tmp;
724
725 if (device == 0)
726 tmp = ATA_DEVICE_OBS;
727 else
728 tmp = ATA_DEVICE_OBS | ATA_DEV1;
729
730 if (ap->flags & ATA_FLAG_MMIO) {
731 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
732 } else {
733 outb(tmp, ap->ioaddr.device_addr);
734 }
735 ata_pause(ap); /* needed; also flushes, for mmio */
736}
737
738/**
739 * ata_dev_select - Select device 0/1 on ATA bus
740 * @ap: ATA channel to manipulate
741 * @device: ATA device (numbered from zero) to select
742 * @wait: non-zero to wait for Status register BSY bit to clear
743 * @can_sleep: non-zero if context allows sleeping
744 *
745 * Use the method defined in the ATA specification to
746 * make either device 0, or device 1, active on the
747 * ATA channel.
748 *
749 * This is a high-level version of ata_std_dev_select(),
750 * which additionally provides the services of inserting
751 * the proper pauses and status polling, where needed.
752 *
753 * LOCKING:
754 * caller.
755 */
756
757void ata_dev_select(struct ata_port *ap, unsigned int device,
758 unsigned int wait, unsigned int can_sleep)
759{
760 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
761 ap->id, device, wait);
762
763 if (wait)
764 ata_wait_idle(ap);
765
766 ap->ops->dev_select(ap, device);
767
768 if (wait) {
769 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
770 msleep(150);
771 ata_wait_idle(ap);
772 }
773}
774
775/**
776 * ata_dump_id - IDENTIFY DEVICE info debugging output
Tejun Heo0bd33002006-02-12 22:47:05 +0900777 * @id: IDENTIFY DEVICE page to dump
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 *
Tejun Heo0bd33002006-02-12 22:47:05 +0900779 * Dump selected 16-bit words from the given IDENTIFY DEVICE
780 * page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 *
782 * LOCKING:
783 * caller.
784 */
785
Tejun Heo0bd33002006-02-12 22:47:05 +0900786static inline void ata_dump_id(const u16 *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787{
788 DPRINTK("49==0x%04x "
789 "53==0x%04x "
790 "63==0x%04x "
791 "64==0x%04x "
792 "75==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900793 id[49],
794 id[53],
795 id[63],
796 id[64],
797 id[75]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 DPRINTK("80==0x%04x "
799 "81==0x%04x "
800 "82==0x%04x "
801 "83==0x%04x "
802 "84==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900803 id[80],
804 id[81],
805 id[82],
806 id[83],
807 id[84]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 DPRINTK("88==0x%04x "
809 "93==0x%04x\n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900810 id[88],
811 id[93]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812}
813
Tejun Heocb95d562006-03-06 04:31:56 +0900814/**
815 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
816 * @id: IDENTIFY data to compute xfer mask from
Alan Cox11e29e22005-10-21 18:46:32 -0400817 *
Tejun Heocb95d562006-03-06 04:31:56 +0900818 * Compute the xfermask for this device. This is not as trivial
819 * as it seems if we must consider early devices correctly.
820 *
821 * FIXME: pre IDE drive timing (do we care ?).
822 *
823 * LOCKING:
824 * None.
825 *
826 * RETURNS:
827 * Computed xfermask
Alan Cox11e29e22005-10-21 18:46:32 -0400828 */
Tejun Heocb95d562006-03-06 04:31:56 +0900829static unsigned int ata_id_xfermask(const u16 *id)
Alan Cox11e29e22005-10-21 18:46:32 -0400830{
Tejun Heocb95d562006-03-06 04:31:56 +0900831 unsigned int pio_mask, mwdma_mask, udma_mask;
Alan Cox11e29e22005-10-21 18:46:32 -0400832
Alan Coxffa29452006-01-09 17:14:40 +0000833 /* Usual case. Word 53 indicates word 64 is valid */
Tejun Heocb95d562006-03-06 04:31:56 +0900834 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
835 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
836 pio_mask <<= 3;
837 pio_mask |= 0x7;
838 } else {
839 /* If word 64 isn't valid then Word 51 high byte holds
840 * the PIO timing number for the maximum. Turn it into
841 * a mask.
842 */
843 pio_mask = (2 << (id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
844
845 /* But wait.. there's more. Design your standards by
846 * committee and you too can get a free iordy field to
847 * process. However its the speeds not the modes that
848 * are supported... Note drivers using the timing API
849 * will get this right anyway
850 */
Alan Cox11e29e22005-10-21 18:46:32 -0400851 }
852
Tejun Heocb95d562006-03-06 04:31:56 +0900853 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
Tejun Heofb21f0d2006-03-12 12:34:35 +0900854
855 udma_mask = 0;
856 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
857 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
Alan Cox11e29e22005-10-21 18:46:32 -0400858
Tejun Heocb95d562006-03-06 04:31:56 +0900859 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
Tejun Heoc18d06f2006-02-02 00:56:10 +0900860}
861
862/**
Tejun Heo86e45b62006-03-05 15:29:09 +0900863 * ata_port_queue_task - Queue port_task
864 * @ap: The ata_port to queue port_task for
Tejun Heoc18d06f2006-02-02 00:56:10 +0900865 *
Tejun Heo86e45b62006-03-05 15:29:09 +0900866 * Schedule @fn(@data) for execution after @delay jiffies using
867 * port_task. There is one port_task per port and it's the
868 * user(low level driver)'s responsibility to make sure that only
869 * one task is active at any given time.
870 *
871 * libata core layer takes care of synchronization between
872 * port_task and EH. ata_port_queue_task() may be ignored for EH
873 * synchronization.
874 *
875 * LOCKING:
876 * Inherited from caller.
877 */
878void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *), void *data,
879 unsigned long delay)
880{
881 int rc;
882
Tejun Heo2e755f62006-03-05 15:29:09 +0900883 if (ap->flags & ATA_FLAG_FLUSH_PORT_TASK)
Tejun Heo86e45b62006-03-05 15:29:09 +0900884 return;
885
886 PREPARE_WORK(&ap->port_task, fn, data);
887
888 if (!delay)
889 rc = queue_work(ata_wq, &ap->port_task);
890 else
891 rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
892
893 /* rc == 0 means that another user is using port task */
894 WARN_ON(rc == 0);
895}
896
897/**
898 * ata_port_flush_task - Flush port_task
899 * @ap: The ata_port to flush port_task for
900 *
901 * After this function completes, port_task is guranteed not to
902 * be running or scheduled.
Tejun Heoc18d06f2006-02-02 00:56:10 +0900903 *
904 * LOCKING:
905 * Kernel thread context (may sleep)
906 */
Tejun Heo86e45b62006-03-05 15:29:09 +0900907void ata_port_flush_task(struct ata_port *ap)
Tejun Heoc18d06f2006-02-02 00:56:10 +0900908{
Tejun Heoc18d06f2006-02-02 00:56:10 +0900909 unsigned long flags;
910
911 DPRINTK("ENTER\n");
912
913 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900914 ap->flags |= ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heoc18d06f2006-02-02 00:56:10 +0900915 spin_unlock_irqrestore(&ap->host_set->lock, flags);
916
917 DPRINTK("flush #1\n");
918 flush_workqueue(ata_wq);
919
920 /*
921 * At this point, if a task is running, it's guaranteed to see
922 * the FLUSH flag; thus, it will never queue pio tasks again.
923 * Cancel and flush.
924 */
Tejun Heo86e45b62006-03-05 15:29:09 +0900925 if (!cancel_delayed_work(&ap->port_task)) {
Tejun Heoc18d06f2006-02-02 00:56:10 +0900926 DPRINTK("flush #2\n");
927 flush_workqueue(ata_wq);
928 }
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 Heoc18d06f2006-02-02 00:56:10 +0900932 spin_unlock_irqrestore(&ap->host_set->lock, flags);
933
934 DPRINTK("EXIT\n");
Tejun Heo95064372006-01-23 13:09:37 +0900935}
936
Tejun Heo77853bf2006-01-23 13:09:36 +0900937void ata_qc_complete_internal(struct ata_queued_cmd *qc)
Jeff Garzik64f043d2005-11-17 10:50:01 -0500938{
Tejun Heo77853bf2006-01-23 13:09:36 +0900939 struct completion *waiting = qc->private_data;
Jeff Garzik64f043d2005-11-17 10:50:01 -0500940
Tejun Heo77853bf2006-01-23 13:09:36 +0900941 qc->ap->ops->tf_read(qc->ap, &qc->tf);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900942 complete(waiting);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900943}
Jeff Garzik64f043d2005-11-17 10:50:01 -0500944
Tejun Heoa2a7a662005-12-13 14:48:31 +0900945/**
946 * ata_exec_internal - execute libata internal command
947 * @ap: Port to which the command is sent
948 * @dev: Device to which the command is sent
949 * @tf: Taskfile registers for the command and the result
950 * @dma_dir: Data tranfer direction of the command
951 * @buf: Data buffer of the command
952 * @buflen: Length of data buffer
953 *
954 * Executes libata internal command with timeout. @tf contains
955 * command on entry and result on return. Timeout and error
956 * conditions are reported via return value. No recovery action
957 * is taken after a command times out. It's caller's duty to
958 * clean up after timeout.
959 *
960 * LOCKING:
961 * None. Should be called with kernel context, might sleep.
962 */
963
964static unsigned
965ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
966 struct ata_taskfile *tf,
967 int dma_dir, void *buf, unsigned int buflen)
968{
969 u8 command = tf->command;
970 struct ata_queued_cmd *qc;
971 DECLARE_COMPLETION(wait);
972 unsigned long flags;
Tejun Heo77853bf2006-01-23 13:09:36 +0900973 unsigned int err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900974
975 spin_lock_irqsave(&ap->host_set->lock, flags);
976
977 qc = ata_qc_new_init(ap, dev);
978 BUG_ON(qc == NULL);
979
980 qc->tf = *tf;
981 qc->dma_dir = dma_dir;
982 if (dma_dir != DMA_NONE) {
983 ata_sg_init_one(qc, buf, buflen);
984 qc->nsect = buflen / ATA_SECT_SIZE;
Jeff Garzik64f043d2005-11-17 10:50:01 -0500985 }
986
Tejun Heo77853bf2006-01-23 13:09:36 +0900987 qc->private_data = &wait;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900988 qc->complete_fn = ata_qc_complete_internal;
989
Tejun Heo9a3d9eb2006-01-23 13:09:36 +0900990 qc->err_mask = ata_qc_issue(qc);
991 if (qc->err_mask)
Tejun Heo8e436af2006-01-23 13:09:36 +0900992 ata_qc_complete(qc);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900993
994 spin_unlock_irqrestore(&ap->host_set->lock, flags);
995
996 if (!wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL)) {
Albert Lee41ade502006-03-14 11:19:04 +0800997 ata_port_flush_task(ap);
998
Tejun Heoa2a7a662005-12-13 14:48:31 +0900999 spin_lock_irqsave(&ap->host_set->lock, flags);
1000
1001 /* We're racing with irq here. If we lose, the
1002 * following test prevents us from completing the qc
1003 * again. If completion irq occurs after here but
1004 * before the caller cleans up, it will result in a
1005 * spurious interrupt. We can live with that.
1006 */
Tejun Heo77853bf2006-01-23 13:09:36 +09001007 if (qc->flags & ATA_QCFLAG_ACTIVE) {
Tejun Heo11a56d22006-01-23 13:09:36 +09001008 qc->err_mask = AC_ERR_TIMEOUT;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001009 ata_qc_complete(qc);
1010 printk(KERN_WARNING "ata%u: qc timeout (cmd 0x%x)\n",
1011 ap->id, command);
1012 }
1013
1014 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1015 }
1016
Tejun Heo77853bf2006-01-23 13:09:36 +09001017 *tf = qc->tf;
1018 err_mask = qc->err_mask;
1019
1020 ata_qc_free(qc);
1021
Tejun Heo1f7dd3e2006-03-24 15:25:30 +09001022 /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1023 * Until those drivers are fixed, we detect the condition
1024 * here, fail the command with AC_ERR_SYSTEM and reenable the
1025 * port.
1026 *
1027 * Note that this doesn't change any behavior as internal
1028 * command failure results in disabling the device in the
1029 * higher layer for LLDDs without new reset/EH callbacks.
1030 *
1031 * Kill the following code as soon as those drivers are fixed.
1032 */
1033 if (ap->flags & ATA_FLAG_PORT_DISABLED) {
1034 err_mask |= AC_ERR_SYSTEM;
1035 ata_port_probe(ap);
1036 }
1037
Tejun Heo77853bf2006-01-23 13:09:36 +09001038 return err_mask;
Jeff Garzik64f043d2005-11-17 10:50:01 -05001039}
1040
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041/**
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001042 * ata_pio_need_iordy - check if iordy needed
1043 * @adev: ATA device
1044 *
1045 * Check if the current speed of the device requires IORDY. Used
1046 * by various controllers for chip configuration.
1047 */
1048
1049unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1050{
1051 int pio;
1052 int speed = adev->pio_mode - XFER_PIO_0;
1053
1054 if (speed < 2)
1055 return 0;
1056 if (speed > 2)
1057 return 1;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001058
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001059 /* If we have no drive specific rule, then PIO 2 is non IORDY */
1060
1061 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1062 pio = adev->id[ATA_ID_EIDE_PIO];
1063 /* Is the speed faster than the drive allows non IORDY ? */
1064 if (pio) {
1065 /* This is cycle times not frequency - watch the logic! */
1066 if (pio > 240) /* PIO2 is 240nS per cycle */
1067 return 1;
1068 return 0;
1069 }
1070 }
1071 return 0;
1072}
1073
1074/**
Tejun Heo49016ac2006-02-21 02:12:11 +09001075 * ata_dev_read_id - Read ID data from the specified device
1076 * @ap: port on which target device resides
1077 * @dev: target device
1078 * @p_class: pointer to class of the target device (may be changed)
1079 * @post_reset: is this read ID post-reset?
Tejun Heod9572b12006-03-01 16:09:35 +09001080 * @p_id: read IDENTIFY page (newly allocated)
Tejun Heo49016ac2006-02-21 02:12:11 +09001081 *
1082 * Read ID data from the specified device. ATA_CMD_ID_ATA is
1083 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
Tejun Heoaec5c3c2006-03-25 01:33:34 +09001084 * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS
1085 * for pre-ATA4 drives.
Tejun Heo49016ac2006-02-21 02:12:11 +09001086 *
1087 * LOCKING:
1088 * Kernel thread context (may sleep)
1089 *
1090 * RETURNS:
1091 * 0 on success, -errno otherwise.
1092 */
1093static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
Tejun Heod9572b12006-03-01 16:09:35 +09001094 unsigned int *p_class, int post_reset, u16 **p_id)
Tejun Heo49016ac2006-02-21 02:12:11 +09001095{
1096 unsigned int class = *p_class;
Tejun Heo49016ac2006-02-21 02:12:11 +09001097 struct ata_taskfile tf;
1098 unsigned int err_mask = 0;
Tejun Heod9572b12006-03-01 16:09:35 +09001099 u16 *id;
Tejun Heo49016ac2006-02-21 02:12:11 +09001100 const char *reason;
1101 int rc;
1102
1103 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1104
Tejun Heo49016ac2006-02-21 02:12:11 +09001105 ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1106
Tejun Heod9572b12006-03-01 16:09:35 +09001107 id = kmalloc(sizeof(id[0]) * ATA_ID_WORDS, GFP_KERNEL);
1108 if (id == NULL) {
1109 rc = -ENOMEM;
1110 reason = "out of memory";
1111 goto err_out;
1112 }
1113
Tejun Heo49016ac2006-02-21 02:12:11 +09001114 retry:
1115 ata_tf_init(ap, &tf, dev->devno);
1116
1117 switch (class) {
1118 case ATA_DEV_ATA:
1119 tf.command = ATA_CMD_ID_ATA;
1120 break;
1121 case ATA_DEV_ATAPI:
1122 tf.command = ATA_CMD_ID_ATAPI;
1123 break;
1124 default:
1125 rc = -ENODEV;
1126 reason = "unsupported class";
1127 goto err_out;
1128 }
1129
1130 tf.protocol = ATA_PROT_PIO;
1131
1132 err_mask = ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE,
1133 id, sizeof(id[0]) * ATA_ID_WORDS);
Tejun Heo49016ac2006-02-21 02:12:11 +09001134 if (err_mask) {
1135 rc = -EIO;
1136 reason = "I/O error";
Tejun Heo49016ac2006-02-21 02:12:11 +09001137 goto err_out;
1138 }
1139
1140 swap_buf_le16(id, ATA_ID_WORDS);
1141
Tejun Heo49016ac2006-02-21 02:12:11 +09001142 /* sanity check */
1143 if ((class == ATA_DEV_ATA) != ata_id_is_ata(id)) {
1144 rc = -EINVAL;
1145 reason = "device reports illegal type";
1146 goto err_out;
1147 }
1148
1149 if (post_reset && class == ATA_DEV_ATA) {
1150 /*
1151 * The exact sequence expected by certain pre-ATA4 drives is:
1152 * SRST RESET
1153 * IDENTIFY
1154 * INITIALIZE DEVICE PARAMETERS
1155 * anything else..
1156 * Some drives were very specific about that exact sequence.
1157 */
1158 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
1159 err_mask = ata_dev_init_params(ap, dev);
1160 if (err_mask) {
1161 rc = -EIO;
1162 reason = "INIT_DEV_PARAMS failed";
1163 goto err_out;
1164 }
1165
1166 /* current CHS translation info (id[53-58]) might be
1167 * changed. reread the identify device info.
1168 */
1169 post_reset = 0;
1170 goto retry;
1171 }
1172 }
1173
1174 *p_class = class;
Tejun Heod9572b12006-03-01 16:09:35 +09001175 *p_id = id;
Tejun Heo49016ac2006-02-21 02:12:11 +09001176 return 0;
1177
1178 err_out:
1179 printk(KERN_WARNING "ata%u: dev %u failed to IDENTIFY (%s)\n",
1180 ap->id, dev->devno, reason);
Tejun Heod9572b12006-03-01 16:09:35 +09001181 kfree(id);
Tejun Heo49016ac2006-02-21 02:12:11 +09001182 return rc;
1183}
1184
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001185static inline u8 ata_dev_knobble(const struct ata_port *ap,
1186 struct ata_device *dev)
1187{
1188 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
1189}
1190
Tejun Heo49016ac2006-02-21 02:12:11 +09001191/**
Tejun Heoffeae412006-03-01 16:09:35 +09001192 * ata_dev_configure - Configure the specified ATA/ATAPI device
1193 * @ap: Port on which target device resides
1194 * @dev: Target device to configure
Tejun Heo4c2d7212006-03-05 17:55:58 +09001195 * @print_info: Enable device info printout
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 *
Tejun Heoffeae412006-03-01 16:09:35 +09001197 * Configure @dev according to @dev->id. Generic and low-level
1198 * driver specific fixups are also applied.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 *
1200 * LOCKING:
Tejun Heoffeae412006-03-01 16:09:35 +09001201 * Kernel thread context (may sleep)
1202 *
1203 * RETURNS:
1204 * 0 on success, -errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001206static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
1207 int print_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208{
Tejun Heo1148c3a2006-03-13 19:48:04 +09001209 const u16 *id = dev->id;
Tejun Heoff8854b2006-03-06 04:31:56 +09001210 unsigned int xfer_mask;
Tejun Heo6e7846e2006-02-12 23:32:58 +09001211 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
1213 if (!ata_dev_present(dev)) {
1214 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
Tejun Heoffeae412006-03-01 16:09:35 +09001215 ap->id, dev->devno);
1216 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 }
1218
Tejun Heoffeae412006-03-01 16:09:35 +09001219 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
Tejun Heoc39f5eb2006-03-13 19:51:19 +09001221 /* print device capabilities */
1222 if (print_info)
1223 printk(KERN_DEBUG "ata%u: dev %u cfg 49:%04x 82:%04x 83:%04x "
1224 "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1225 ap->id, dev->devno, id[49], id[82], id[83],
1226 id[84], id[85], id[86], id[87], id[88]);
1227
Tejun Heo208a9932006-03-05 17:55:58 +09001228 /* initialize to-be-configured parameters */
1229 dev->flags = 0;
1230 dev->max_sectors = 0;
1231 dev->cdb_len = 0;
1232 dev->n_sectors = 0;
1233 dev->cylinders = 0;
1234 dev->heads = 0;
1235 dev->sectors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236
1237 /*
1238 * common ATA, ATAPI feature tests
1239 */
1240
Tejun Heoff8854b2006-03-06 04:31:56 +09001241 /* find max transfer mode; for printk only */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001242 xfer_mask = ata_id_xfermask(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243
Tejun Heo1148c3a2006-03-13 19:48:04 +09001244 ata_dump_id(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
1246 /* ATA-specific feature tests */
1247 if (dev->class == ATA_DEV_ATA) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001248 dev->n_sectors = ata_id_n_sectors(id);
Tejun Heo29407402006-02-12 22:47:04 +09001249
Tejun Heo1148c3a2006-03-13 19:48:04 +09001250 if (ata_id_has_lba(id)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001251 const char *lba_desc;
Albert Lee8bf62ec2005-05-12 15:29:42 -04001252
Tejun Heo4c2d7212006-03-05 17:55:58 +09001253 lba_desc = "LBA";
1254 dev->flags |= ATA_DFLAG_LBA;
Tejun Heo1148c3a2006-03-13 19:48:04 +09001255 if (ata_id_has_lba48(id)) {
Albert Lee8bf62ec2005-05-12 15:29:42 -04001256 dev->flags |= ATA_DFLAG_LBA48;
Tejun Heo4c2d7212006-03-05 17:55:58 +09001257 lba_desc = "LBA48";
1258 }
Albert Lee8bf62ec2005-05-12 15:29:42 -04001259
1260 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001261 if (print_info)
1262 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1263 "max %s, %Lu sectors: %s\n",
1264 ap->id, dev->devno,
Tejun Heo1148c3a2006-03-13 19:48:04 +09001265 ata_id_major_version(id),
Tejun Heoff8854b2006-03-06 04:31:56 +09001266 ata_mode_string(xfer_mask),
Tejun Heo4c2d7212006-03-05 17:55:58 +09001267 (unsigned long long)dev->n_sectors,
1268 lba_desc);
Tejun Heoffeae412006-03-01 16:09:35 +09001269 } else {
Albert Lee8bf62ec2005-05-12 15:29:42 -04001270 /* CHS */
1271
1272 /* Default translation */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001273 dev->cylinders = id[1];
1274 dev->heads = id[3];
1275 dev->sectors = id[6];
Albert Lee8bf62ec2005-05-12 15:29:42 -04001276
Tejun Heo1148c3a2006-03-13 19:48:04 +09001277 if (ata_id_current_chs_valid(id)) {
Albert Lee8bf62ec2005-05-12 15:29:42 -04001278 /* Current CHS translation is valid. */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001279 dev->cylinders = id[54];
1280 dev->heads = id[55];
1281 dev->sectors = id[56];
Albert Lee8bf62ec2005-05-12 15:29:42 -04001282 }
1283
1284 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001285 if (print_info)
1286 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1287 "max %s, %Lu sectors: CHS %u/%u/%u\n",
1288 ap->id, dev->devno,
Tejun Heo1148c3a2006-03-13 19:48:04 +09001289 ata_id_major_version(id),
Tejun Heoff8854b2006-03-06 04:31:56 +09001290 ata_mode_string(xfer_mask),
Tejun Heo4c2d7212006-03-05 17:55:58 +09001291 (unsigned long long)dev->n_sectors,
1292 dev->cylinders, dev->heads, dev->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 }
1294
Albert Lee07f6f7d2005-11-01 19:33:20 +08001295 if (dev->id[59] & 0x100) {
1296 dev->multi_count = dev->id[59] & 0xff;
1297 DPRINTK("ata%u: dev %u multi count %u\n",
Albert Lee999bb6f2006-03-25 18:07:48 +08001298 ap->id, dev->devno, dev->multi_count);
Albert Lee07f6f7d2005-11-01 19:33:20 +08001299 }
1300
Albert Lee13ee4622006-03-25 17:39:34 +08001301 dev->cdb_len = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 }
1303
1304 /* ATAPI-specific feature tests */
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05001305 else if (dev->class == ATA_DEV_ATAPI) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001306 rc = atapi_cdb_len(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1308 printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
Tejun Heoffeae412006-03-01 16:09:35 +09001309 rc = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 goto err_out_nosup;
1311 }
Tejun Heo6e7846e2006-02-12 23:32:58 +09001312 dev->cdb_len = (unsigned int) rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313
Albert Lee312f7da2005-09-27 17:38:03 +08001314 if (ata_id_cdb_intr(dev->id))
1315 dev->flags |= ATA_DFLAG_CDB_INTR;
1316
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001318 if (print_info)
1319 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
Tejun Heoff8854b2006-03-06 04:31:56 +09001320 ap->id, dev->devno, ata_mode_string(xfer_mask));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 }
1322
Tejun Heo6e7846e2006-02-12 23:32:58 +09001323 ap->host->max_cmd_len = 0;
1324 for (i = 0; i < ATA_MAX_DEVICES; i++)
1325 ap->host->max_cmd_len = max_t(unsigned int,
1326 ap->host->max_cmd_len,
1327 ap->device[i].cdb_len);
1328
Brad Campbell6f2f3812005-05-12 15:07:47 -04001329 /* limit bridge transfers to udma5, 200 sectors */
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001330 if (ata_dev_knobble(ap, dev)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001331 if (print_info)
1332 printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
1333 ap->id, dev->devno);
Tejun Heo5a529132006-03-24 14:07:50 +09001334 dev->udma_mask &= ATA_UDMA5;
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001335 dev->max_sectors = ATA_MAX_SECTORS;
Brad Campbell6f2f3812005-05-12 15:07:47 -04001336 }
1337
1338 if (ap->ops->dev_config)
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001339 ap->ops->dev_config(ap, dev);
1340
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
Tejun Heoffeae412006-03-01 16:09:35 +09001342 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
1344err_out_nosup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 DPRINTK("EXIT, err\n");
Tejun Heoffeae412006-03-01 16:09:35 +09001346 return rc;
Brad Campbell6f2f3812005-05-12 15:07:47 -04001347}
1348
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349/**
1350 * ata_bus_probe - Reset and probe ATA bus
1351 * @ap: Bus to probe
1352 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001353 * Master ATA bus probing function. Initiates a hardware-dependent
1354 * bus reset, then attempts to identify any devices found on
1355 * the bus.
1356 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001358 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 *
1360 * RETURNS:
1361 * Zero on success, non-zero on error.
1362 */
1363
1364static int ata_bus_probe(struct ata_port *ap)
1365{
Tejun Heo28ca5c52006-03-01 16:09:36 +09001366 unsigned int classes[ATA_MAX_DEVICES];
1367 unsigned int i, rc, found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368
Tejun Heo28ca5c52006-03-01 16:09:36 +09001369 ata_port_probe(ap);
1370
Tejun Heo20444702006-03-13 01:57:01 +09001371 /* reset and determine device classes */
1372 for (i = 0; i < ATA_MAX_DEVICES; i++)
1373 classes[i] = ATA_DEV_UNKNOWN;
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001374
Tejun Heo20444702006-03-13 01:57:01 +09001375 if (ap->ops->probe_reset) {
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001376 rc = ap->ops->probe_reset(ap, classes);
Tejun Heo28ca5c52006-03-01 16:09:36 +09001377 if (rc) {
1378 printk("ata%u: reset failed (errno=%d)\n", ap->id, rc);
1379 return rc;
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001380 }
Tejun Heo28ca5c52006-03-01 16:09:36 +09001381 } else {
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001382 ap->ops->phy_reset(ap);
1383
Tejun Heo20444702006-03-13 01:57:01 +09001384 if (!(ap->flags & ATA_FLAG_PORT_DISABLED))
1385 for (i = 0; i < ATA_MAX_DEVICES; i++)
Tejun Heo28ca5c52006-03-01 16:09:36 +09001386 classes[i] = ap->device[i].class;
Tejun Heo20444702006-03-13 01:57:01 +09001387
Tejun Heo28ca5c52006-03-01 16:09:36 +09001388 ata_port_probe(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 }
1390
Tejun Heo20444702006-03-13 01:57:01 +09001391 for (i = 0; i < ATA_MAX_DEVICES; i++)
1392 if (classes[i] == ATA_DEV_UNKNOWN)
1393 classes[i] = ATA_DEV_NONE;
1394
Tejun Heo28ca5c52006-03-01 16:09:36 +09001395 /* read IDENTIFY page and configure devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoffeae412006-03-01 16:09:35 +09001397 struct ata_device *dev = &ap->device[i];
1398
Tejun Heo28ca5c52006-03-01 16:09:36 +09001399 dev->class = classes[i];
1400
Tejun Heoffeae412006-03-01 16:09:35 +09001401 if (!ata_dev_present(dev))
1402 continue;
1403
1404 WARN_ON(dev->id != NULL);
1405 if (ata_dev_read_id(ap, dev, &dev->class, 1, &dev->id)) {
1406 dev->class = ATA_DEV_NONE;
1407 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 }
Tejun Heoffeae412006-03-01 16:09:35 +09001409
Tejun Heo4c2d7212006-03-05 17:55:58 +09001410 if (ata_dev_configure(ap, dev, 1)) {
Tejun Heofcef9782006-03-24 15:25:31 +09001411 ata_dev_disable(ap, dev);
Tejun Heoffeae412006-03-01 16:09:35 +09001412 continue;
1413 }
1414
Tejun Heoffeae412006-03-01 16:09:35 +09001415 found = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 }
1417
Tejun Heo28ca5c52006-03-01 16:09:36 +09001418 if (!found)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 goto err_out_disable;
1420
1421 ata_set_mode(ap);
1422 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1423 goto err_out_disable;
1424
1425 return 0;
1426
1427err_out_disable:
1428 ap->ops->port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 return -1;
1430}
1431
1432/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04001433 * ata_port_probe - Mark port as enabled
1434 * @ap: Port for which we indicate enablement
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001436 * Modify @ap data structure such that the system
1437 * thinks that the entire port is enabled.
1438 *
1439 * LOCKING: host_set lock, or some other form of
1440 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 */
1442
1443void ata_port_probe(struct ata_port *ap)
1444{
1445 ap->flags &= ~ATA_FLAG_PORT_DISABLED;
1446}
1447
1448/**
Tejun Heo3be680b2005-12-19 22:35:02 +09001449 * sata_print_link_status - Print SATA link status
1450 * @ap: SATA port to printk link status about
1451 *
1452 * This function prints link speed and status of a SATA link.
1453 *
1454 * LOCKING:
1455 * None.
1456 */
1457static void sata_print_link_status(struct ata_port *ap)
1458{
1459 u32 sstatus, tmp;
1460 const char *speed;
1461
1462 if (!ap->ops->scr_read)
1463 return;
1464
1465 sstatus = scr_read(ap, SCR_STATUS);
1466
1467 if (sata_dev_present(ap)) {
1468 tmp = (sstatus >> 4) & 0xf;
1469 if (tmp & (1 << 0))
1470 speed = "1.5";
1471 else if (tmp & (1 << 1))
1472 speed = "3.0";
1473 else
1474 speed = "<unknown>";
1475 printk(KERN_INFO "ata%u: SATA link up %s Gbps (SStatus %X)\n",
1476 ap->id, speed, sstatus);
1477 } else {
1478 printk(KERN_INFO "ata%u: SATA link down (SStatus %X)\n",
1479 ap->id, sstatus);
1480 }
1481}
1482
1483/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001484 * __sata_phy_reset - Wake/reset a low-level SATA PHY
1485 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001487 * This function issues commands to standard SATA Sxxx
1488 * PHY registers, to wake up the phy (and device), and
1489 * clear any reset condition.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 *
1491 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001492 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 *
1494 */
1495void __sata_phy_reset(struct ata_port *ap)
1496{
1497 u32 sstatus;
1498 unsigned long timeout = jiffies + (HZ * 5);
1499
1500 if (ap->flags & ATA_FLAG_SATA_RESET) {
Brett Russcdcca892005-03-28 15:10:27 -05001501 /* issue phy wake/reset */
1502 scr_write_flush(ap, SCR_CONTROL, 0x301);
Tejun Heo62ba2842005-06-26 23:27:19 +09001503 /* Couldn't find anything in SATA I/II specs, but
1504 * AHCI-1.1 10.4.2 says at least 1 ms. */
1505 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 }
Brett Russcdcca892005-03-28 15:10:27 -05001507 scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508
1509 /* wait for phy to become ready, if necessary */
1510 do {
1511 msleep(200);
1512 sstatus = scr_read(ap, SCR_STATUS);
1513 if ((sstatus & 0xf) != 1)
1514 break;
1515 } while (time_before(jiffies, timeout));
1516
Tejun Heo3be680b2005-12-19 22:35:02 +09001517 /* print link status */
1518 sata_print_link_status(ap);
Jeff Garzik656563e2005-11-20 03:36:45 -05001519
Tejun Heo3be680b2005-12-19 22:35:02 +09001520 /* TODO: phy layer with polling, timeouts, etc. */
1521 if (sata_dev_present(ap))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 ata_port_probe(ap);
Tejun Heo3be680b2005-12-19 22:35:02 +09001523 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 ata_port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
1526 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1527 return;
1528
1529 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1530 ata_port_disable(ap);
1531 return;
1532 }
1533
1534 ap->cbl = ATA_CBL_SATA;
1535}
1536
1537/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001538 * sata_phy_reset - Reset SATA bus.
1539 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001541 * This function resets the SATA bus, and then probes
1542 * the bus for devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 *
1544 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001545 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 *
1547 */
1548void sata_phy_reset(struct ata_port *ap)
1549{
1550 __sata_phy_reset(ap);
1551 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1552 return;
1553 ata_bus_reset(ap);
1554}
1555
1556/**
Alan Coxebdfca62006-03-23 15:38:34 +00001557 * ata_dev_pair - return other device on cable
1558 * @ap: port
1559 * @adev: device
1560 *
1561 * Obtain the other device on the same cable, or if none is
1562 * present NULL is returned
1563 */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001564
Alan Coxebdfca62006-03-23 15:38:34 +00001565struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
1566{
1567 struct ata_device *pair = &ap->device[1 - adev->devno];
1568 if (!ata_dev_present(pair))
1569 return NULL;
1570 return pair;
1571}
1572
1573/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001574 * ata_port_disable - Disable port.
1575 * @ap: Port to be disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001577 * Modify @ap data structure such that the system
1578 * thinks that the entire port is disabled, and should
1579 * never attempt to probe or communicate with devices
1580 * on this port.
1581 *
1582 * LOCKING: host_set lock, or some other form of
1583 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 */
1585
1586void ata_port_disable(struct ata_port *ap)
1587{
1588 ap->device[0].class = ATA_DEV_NONE;
1589 ap->device[1].class = ATA_DEV_NONE;
1590 ap->flags |= ATA_FLAG_PORT_DISABLED;
1591}
1592
Alan Cox452503f2005-10-21 19:01:32 -04001593/*
1594 * This mode timing computation functionality is ported over from
1595 * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
1596 */
1597/*
1598 * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
1599 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
1600 * for PIO 5, which is a nonstandard extension and UDMA6, which
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001601 * is currently supported only by Maxtor drives.
Alan Cox452503f2005-10-21 19:01:32 -04001602 */
1603
1604static const struct ata_timing ata_timing[] = {
1605
1606 { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 },
1607 { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 },
1608 { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 },
1609 { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 },
1610
1611 { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 },
1612 { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 },
1613 { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 },
1614
1615/* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001616
Alan Cox452503f2005-10-21 19:01:32 -04001617 { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 },
1618 { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 },
1619 { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 },
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001620
Alan Cox452503f2005-10-21 19:01:32 -04001621 { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 },
1622 { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 },
1623 { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 },
1624
1625/* { XFER_PIO_5, 20, 50, 30, 100, 50, 30, 100, 0 }, */
1626 { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 },
1627 { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 },
1628
1629 { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 },
1630 { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 },
1631 { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 },
1632
1633/* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */
1634
1635 { 0xFF }
1636};
1637
1638#define ENOUGH(v,unit) (((v)-1)/(unit)+1)
1639#define EZ(v,unit) ((v)?ENOUGH(v,unit):0)
1640
1641static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
1642{
1643 q->setup = EZ(t->setup * 1000, T);
1644 q->act8b = EZ(t->act8b * 1000, T);
1645 q->rec8b = EZ(t->rec8b * 1000, T);
1646 q->cyc8b = EZ(t->cyc8b * 1000, T);
1647 q->active = EZ(t->active * 1000, T);
1648 q->recover = EZ(t->recover * 1000, T);
1649 q->cycle = EZ(t->cycle * 1000, T);
1650 q->udma = EZ(t->udma * 1000, UT);
1651}
1652
1653void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
1654 struct ata_timing *m, unsigned int what)
1655{
1656 if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup);
1657 if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b);
1658 if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b);
1659 if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b);
1660 if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active);
1661 if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
1662 if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle);
1663 if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma);
1664}
1665
1666static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
1667{
1668 const struct ata_timing *t;
1669
1670 for (t = ata_timing; t->mode != speed; t++)
Alan Cox91190752005-10-26 12:17:46 -04001671 if (t->mode == 0xFF)
Alan Cox452503f2005-10-21 19:01:32 -04001672 return NULL;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001673 return t;
Alan Cox452503f2005-10-21 19:01:32 -04001674}
1675
1676int ata_timing_compute(struct ata_device *adev, unsigned short speed,
1677 struct ata_timing *t, int T, int UT)
1678{
1679 const struct ata_timing *s;
1680 struct ata_timing p;
1681
1682 /*
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001683 * Find the mode.
Albert Lee75b1f2f2005-11-16 17:06:18 +08001684 */
Alan Cox452503f2005-10-21 19:01:32 -04001685
1686 if (!(s = ata_timing_find_mode(speed)))
1687 return -EINVAL;
1688
Albert Lee75b1f2f2005-11-16 17:06:18 +08001689 memcpy(t, s, sizeof(*s));
1690
Alan Cox452503f2005-10-21 19:01:32 -04001691 /*
1692 * If the drive is an EIDE drive, it can tell us it needs extended
1693 * PIO/MW_DMA cycle timing.
1694 */
1695
1696 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
1697 memset(&p, 0, sizeof(p));
1698 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
1699 if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
1700 else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
1701 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
1702 p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
1703 }
1704 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
1705 }
1706
1707 /*
1708 * Convert the timing to bus clock counts.
1709 */
1710
Albert Lee75b1f2f2005-11-16 17:06:18 +08001711 ata_timing_quantize(t, t, T, UT);
Alan Cox452503f2005-10-21 19:01:32 -04001712
1713 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001714 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
1715 * S.M.A.R.T * and some other commands. We have to ensure that the
1716 * DMA cycle timing is slower/equal than the fastest PIO timing.
Alan Cox452503f2005-10-21 19:01:32 -04001717 */
1718
1719 if (speed > XFER_PIO_4) {
1720 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
1721 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
1722 }
1723
1724 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001725 * Lengthen active & recovery time so that cycle time is correct.
Alan Cox452503f2005-10-21 19:01:32 -04001726 */
1727
1728 if (t->act8b + t->rec8b < t->cyc8b) {
1729 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
1730 t->rec8b = t->cyc8b - t->act8b;
1731 }
1732
1733 if (t->active + t->recover < t->cycle) {
1734 t->active += (t->cycle - (t->active + t->recover)) / 2;
1735 t->recover = t->cycle - t->active;
1736 }
1737
1738 return 0;
1739}
1740
Tejun Heo83206a22006-03-24 15:25:31 +09001741static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742{
Tejun Heo83206a22006-03-24 15:25:31 +09001743 unsigned int err_mask;
1744 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
1746 if (dev->xfer_shift == ATA_SHIFT_PIO)
1747 dev->flags |= ATA_DFLAG_PIO;
1748
Tejun Heo83206a22006-03-24 15:25:31 +09001749 err_mask = ata_dev_set_xfermode(ap, dev);
1750 if (err_mask) {
1751 printk(KERN_ERR
1752 "ata%u: failed to set xfermode (err_mask=0x%x)\n",
1753 ap->id, err_mask);
1754 return -EIO;
1755 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756
Tejun Heo83206a22006-03-24 15:25:31 +09001757 rc = ata_dev_revalidate(ap, dev, 0);
1758 if (rc) {
1759 printk(KERN_ERR
1760 "ata%u: failed to revalidate after set xfermode\n",
1761 ap->id);
1762 return rc;
Tejun Heo48a8a142006-03-05 17:55:58 +09001763 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
Tejun Heo23e71c32006-03-06 04:31:57 +09001765 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
1766 dev->xfer_shift, (int)dev->xfer_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
1768 printk(KERN_INFO "ata%u: dev %u configured for %s\n",
Tejun Heo23e71c32006-03-06 04:31:57 +09001769 ap->id, dev->devno,
1770 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
Tejun Heo83206a22006-03-24 15:25:31 +09001771 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772}
1773
1774static int ata_host_set_pio(struct ata_port *ap)
1775{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 int i;
1777
1778 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1779 struct ata_device *dev = &ap->device[i];
Tejun Heoa6d5a512006-03-06 04:31:57 +09001780
1781 if (!ata_dev_present(dev))
1782 continue;
1783
1784 if (!dev->pio_mode) {
Alan Cox88f93a32006-03-21 16:04:12 +00001785 printk(KERN_WARNING "ata%u: no PIO support for device %d.\n", ap->id, i);
Tejun Heoa6d5a512006-03-06 04:31:57 +09001786 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 }
Tejun Heoa6d5a512006-03-06 04:31:57 +09001788
1789 dev->xfer_mode = dev->pio_mode;
1790 dev->xfer_shift = ATA_SHIFT_PIO;
1791 if (ap->ops->set_piomode)
1792 ap->ops->set_piomode(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 }
1794
1795 return 0;
1796}
1797
Tejun Heoa6d5a512006-03-06 04:31:57 +09001798static void ata_host_set_dma(struct ata_port *ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799{
1800 int i;
1801
1802 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1803 struct ata_device *dev = &ap->device[i];
Tejun Heoa6d5a512006-03-06 04:31:57 +09001804
1805 if (!ata_dev_present(dev) || !dev->dma_mode)
1806 continue;
1807
1808 dev->xfer_mode = dev->dma_mode;
1809 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
1810 if (ap->ops->set_dmamode)
1811 ap->ops->set_dmamode(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 }
1813}
1814
1815/**
1816 * ata_set_mode - Program timings and issue SET FEATURES - XFER
1817 * @ap: port on which timings will be programmed
1818 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001819 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.).
1820 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001822 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 */
1824static void ata_set_mode(struct ata_port *ap)
1825{
Tejun Heoa6d5a512006-03-06 04:31:57 +09001826 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827
Tejun Heoa6d5a512006-03-06 04:31:57 +09001828 /* step 1: calculate xfer_mask */
1829 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1830 struct ata_device *dev = &ap->device[i];
Tejun Heoacf356b2006-03-24 14:07:50 +09001831 unsigned int pio_mask, dma_mask;
Tejun Heoa6d5a512006-03-06 04:31:57 +09001832
1833 if (!ata_dev_present(dev))
1834 continue;
1835
Tejun Heoacf356b2006-03-24 14:07:50 +09001836 ata_dev_xfermask(ap, dev);
Tejun Heoa6d5a512006-03-06 04:31:57 +09001837
Tejun Heoacf356b2006-03-24 14:07:50 +09001838 /* TODO: let LLDD filter dev->*_mask here */
1839
1840 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
1841 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
1842 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
1843 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
Tejun Heoa6d5a512006-03-06 04:31:57 +09001844 }
1845
1846 /* step 2: always set host PIO timings */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 rc = ata_host_set_pio(ap);
1848 if (rc)
1849 goto err_out;
1850
Tejun Heoa6d5a512006-03-06 04:31:57 +09001851 /* step 3: set host DMA timings */
1852 ata_host_set_dma(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853
1854 /* step 4: update devices' xfer mode */
Tejun Heo83206a22006-03-24 15:25:31 +09001855 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1856 struct ata_device *dev = &ap->device[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857
Tejun Heo83206a22006-03-24 15:25:31 +09001858 if (!ata_dev_present(dev))
1859 continue;
1860
1861 if (ata_dev_set_mode(ap, dev))
1862 goto err_out;
1863 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
1865 if (ap->ops->post_set_mode)
1866 ap->ops->post_set_mode(ap);
1867
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 return;
1869
1870err_out:
1871 ata_port_disable(ap);
1872}
1873
1874/**
Jeff Garzik1fdffbc2006-02-09 05:15:27 -05001875 * ata_tf_to_host - issue ATA taskfile to host controller
1876 * @ap: port to which command is being issued
1877 * @tf: ATA taskfile register set
1878 *
1879 * Issues ATA taskfile register set to ATA host controller,
1880 * with proper synchronization with interrupt handler and
1881 * other threads.
1882 *
1883 * LOCKING:
1884 * spin_lock_irqsave(host_set lock)
1885 */
1886
1887static inline void ata_tf_to_host(struct ata_port *ap,
1888 const struct ata_taskfile *tf)
1889{
1890 ap->ops->tf_load(ap, tf);
1891 ap->ops->exec_command(ap, tf);
1892}
1893
1894/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 * ata_busy_sleep - sleep until BSY clears, or timeout
1896 * @ap: port containing status register to be polled
1897 * @tmout_pat: impatience timeout
1898 * @tmout: overall timeout
1899 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001900 * Sleep until ATA Status register bit BSY clears,
1901 * or a timeout occurs.
1902 *
1903 * LOCKING: None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 */
1905
Tejun Heo6f8b9952006-01-24 17:05:21 +09001906unsigned int ata_busy_sleep (struct ata_port *ap,
1907 unsigned long tmout_pat, unsigned long tmout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908{
1909 unsigned long timer_start, timeout;
1910 u8 status;
1911
1912 status = ata_busy_wait(ap, ATA_BUSY, 300);
1913 timer_start = jiffies;
1914 timeout = timer_start + tmout_pat;
1915 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1916 msleep(50);
1917 status = ata_busy_wait(ap, ATA_BUSY, 3);
1918 }
1919
1920 if (status & ATA_BUSY)
1921 printk(KERN_WARNING "ata%u is slow to respond, "
1922 "please be patient\n", ap->id);
1923
1924 timeout = timer_start + tmout;
1925 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1926 msleep(50);
1927 status = ata_chk_status(ap);
1928 }
1929
1930 if (status & ATA_BUSY) {
1931 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
1932 ap->id, tmout / HZ);
1933 return 1;
1934 }
1935
1936 return 0;
1937}
1938
1939static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
1940{
1941 struct ata_ioports *ioaddr = &ap->ioaddr;
1942 unsigned int dev0 = devmask & (1 << 0);
1943 unsigned int dev1 = devmask & (1 << 1);
1944 unsigned long timeout;
1945
1946 /* if device 0 was found in ata_devchk, wait for its
1947 * BSY bit to clear
1948 */
1949 if (dev0)
1950 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1951
1952 /* if device 1 was found in ata_devchk, wait for
1953 * register access, then wait for BSY to clear
1954 */
1955 timeout = jiffies + ATA_TMOUT_BOOT;
1956 while (dev1) {
1957 u8 nsect, lbal;
1958
1959 ap->ops->dev_select(ap, 1);
1960 if (ap->flags & ATA_FLAG_MMIO) {
1961 nsect = readb((void __iomem *) ioaddr->nsect_addr);
1962 lbal = readb((void __iomem *) ioaddr->lbal_addr);
1963 } else {
1964 nsect = inb(ioaddr->nsect_addr);
1965 lbal = inb(ioaddr->lbal_addr);
1966 }
1967 if ((nsect == 1) && (lbal == 1))
1968 break;
1969 if (time_after(jiffies, timeout)) {
1970 dev1 = 0;
1971 break;
1972 }
1973 msleep(50); /* give drive a breather */
1974 }
1975 if (dev1)
1976 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1977
1978 /* is all this really necessary? */
1979 ap->ops->dev_select(ap, 0);
1980 if (dev1)
1981 ap->ops->dev_select(ap, 1);
1982 if (dev0)
1983 ap->ops->dev_select(ap, 0);
1984}
1985
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986static unsigned int ata_bus_softreset(struct ata_port *ap,
1987 unsigned int devmask)
1988{
1989 struct ata_ioports *ioaddr = &ap->ioaddr;
1990
1991 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
1992
1993 /* software reset. causes dev0 to be selected */
1994 if (ap->flags & ATA_FLAG_MMIO) {
1995 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1996 udelay(20); /* FIXME: flush */
1997 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
1998 udelay(20); /* FIXME: flush */
1999 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2000 } else {
2001 outb(ap->ctl, ioaddr->ctl_addr);
2002 udelay(10);
2003 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2004 udelay(10);
2005 outb(ap->ctl, ioaddr->ctl_addr);
2006 }
2007
2008 /* spec mandates ">= 2ms" before checking status.
2009 * We wait 150ms, because that was the magic delay used for
2010 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
2011 * between when the ATA command register is written, and then
2012 * status is checked. Because waiting for "a while" before
2013 * checking status is fine, post SRST, we perform this magic
2014 * delay here as well.
Alan Cox09c7ad72006-03-22 15:52:40 +00002015 *
2016 * Old drivers/ide uses the 2mS rule and then waits for ready
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 */
2018 msleep(150);
2019
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002020
2021 /* Before we perform post reset processing we want to see if
Alan Cox09c7ad72006-03-22 15:52:40 +00002022 the bus shows 0xFF because the odd clown forgets the D7 pulldown
2023 resistor */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002024
Alan Cox09c7ad72006-03-22 15:52:40 +00002025 if (ata_check_status(ap) == 0xFF)
2026 return 1; /* Positive is failure for some reason */
2027
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 ata_bus_post_reset(ap, devmask);
2029
2030 return 0;
2031}
2032
2033/**
2034 * ata_bus_reset - reset host port and associated ATA channel
2035 * @ap: port to reset
2036 *
2037 * This is typically the first time we actually start issuing
2038 * commands to the ATA channel. We wait for BSY to clear, then
2039 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
2040 * result. Determine what devices, if any, are on the channel
2041 * by looking at the device 0/1 error register. Look at the signature
2042 * stored in each device's taskfile registers, to determine if
2043 * the device is ATA or ATAPI.
2044 *
2045 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002046 * PCI/etc. bus probe sem.
2047 * Obtains host_set lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 *
2049 * SIDE EFFECTS:
2050 * Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
2051 */
2052
2053void ata_bus_reset(struct ata_port *ap)
2054{
2055 struct ata_ioports *ioaddr = &ap->ioaddr;
2056 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2057 u8 err;
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002058 unsigned int dev0, dev1 = 0, devmask = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059
2060 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
2061
2062 /* determine if device 0/1 are present */
2063 if (ap->flags & ATA_FLAG_SATA_RESET)
2064 dev0 = 1;
2065 else {
2066 dev0 = ata_devchk(ap, 0);
2067 if (slave_possible)
2068 dev1 = ata_devchk(ap, 1);
2069 }
2070
2071 if (dev0)
2072 devmask |= (1 << 0);
2073 if (dev1)
2074 devmask |= (1 << 1);
2075
2076 /* select device 0 again */
2077 ap->ops->dev_select(ap, 0);
2078
2079 /* issue bus reset */
2080 if (ap->flags & ATA_FLAG_SRST)
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002081 if (ata_bus_softreset(ap, devmask))
2082 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083
2084 /*
2085 * determine by signature whether we have ATA or ATAPI devices
2086 */
Tejun Heob4dc7622006-01-24 17:05:22 +09002087 ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 if ((slave_possible) && (err != 0x81))
Tejun Heob4dc7622006-01-24 17:05:22 +09002089 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091 /* re-enable interrupts */
2092 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2093 ata_irq_on(ap);
2094
2095 /* is double-select really necessary? */
2096 if (ap->device[1].class != ATA_DEV_NONE)
2097 ap->ops->dev_select(ap, 1);
2098 if (ap->device[0].class != ATA_DEV_NONE)
2099 ap->ops->dev_select(ap, 0);
2100
2101 /* if no devices were detected, disable this port */
2102 if ((ap->device[0].class == ATA_DEV_NONE) &&
2103 (ap->device[1].class == ATA_DEV_NONE))
2104 goto err_out;
2105
2106 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2107 /* set up device control for ATA_FLAG_SATA_RESET */
2108 if (ap->flags & ATA_FLAG_MMIO)
2109 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2110 else
2111 outb(ap->ctl, ioaddr->ctl_addr);
2112 }
2113
2114 DPRINTK("EXIT\n");
2115 return;
2116
2117err_out:
2118 printk(KERN_ERR "ata%u: disabling port\n", ap->id);
2119 ap->ops->port_disable(ap);
2120
2121 DPRINTK("EXIT\n");
2122}
2123
Tejun Heo7a7921e2006-02-02 18:20:00 +09002124static int sata_phy_resume(struct ata_port *ap)
2125{
2126 unsigned long timeout = jiffies + (HZ * 5);
2127 u32 sstatus;
2128
2129 scr_write_flush(ap, SCR_CONTROL, 0x300);
2130
2131 /* Wait for phy to become ready, if necessary. */
2132 do {
2133 msleep(200);
2134 sstatus = scr_read(ap, SCR_STATUS);
2135 if ((sstatus & 0xf) != 1)
2136 return 0;
2137 } while (time_before(jiffies, timeout));
2138
2139 return -1;
2140}
2141
Tejun Heoc2bd5802006-01-24 17:05:22 +09002142/**
Tejun Heo8a19ac82006-02-02 18:20:00 +09002143 * ata_std_probeinit - initialize probing
2144 * @ap: port to be probed
2145 *
2146 * @ap is about to be probed. Initialize it. This function is
2147 * to be used as standard callback for ata_drive_probe_reset().
Tejun Heo3a397462006-02-10 23:58:48 +09002148 *
2149 * NOTE!!! Do not use this function as probeinit if a low level
2150 * driver implements only hardreset. Just pass NULL as probeinit
2151 * in that case. Using this function is probably okay but doing
2152 * so makes reset sequence different from the original
2153 * ->phy_reset implementation and Jeff nervous. :-P
Tejun Heo8a19ac82006-02-02 18:20:00 +09002154 */
2155extern void ata_std_probeinit(struct ata_port *ap)
2156{
Tejun Heo3a397462006-02-10 23:58:48 +09002157 if (ap->flags & ATA_FLAG_SATA && ap->ops->scr_read) {
Tejun Heo8a19ac82006-02-02 18:20:00 +09002158 sata_phy_resume(ap);
Tejun Heo3a397462006-02-10 23:58:48 +09002159 if (sata_dev_present(ap))
2160 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2161 }
Tejun Heo8a19ac82006-02-02 18:20:00 +09002162}
2163
2164/**
Tejun Heoc2bd5802006-01-24 17:05:22 +09002165 * ata_std_softreset - reset host port via ATA SRST
2166 * @ap: port to reset
2167 * @verbose: fail verbosely
2168 * @classes: resulting classes of attached devices
2169 *
2170 * Reset host port using ATA SRST. This function is to be used
2171 * as standard callback for ata_drive_*_reset() functions.
2172 *
2173 * LOCKING:
2174 * Kernel thread context (may sleep)
2175 *
2176 * RETURNS:
2177 * 0 on success, -errno otherwise.
2178 */
2179int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
2180{
2181 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2182 unsigned int devmask = 0, err_mask;
2183 u8 err;
2184
2185 DPRINTK("ENTER\n");
2186
Tejun Heo3a397462006-02-10 23:58:48 +09002187 if (ap->ops->scr_read && !sata_dev_present(ap)) {
2188 classes[0] = ATA_DEV_NONE;
2189 goto out;
2190 }
2191
Tejun Heoc2bd5802006-01-24 17:05:22 +09002192 /* determine if device 0/1 are present */
2193 if (ata_devchk(ap, 0))
2194 devmask |= (1 << 0);
2195 if (slave_possible && ata_devchk(ap, 1))
2196 devmask |= (1 << 1);
2197
Tejun Heoc2bd5802006-01-24 17:05:22 +09002198 /* select device 0 again */
2199 ap->ops->dev_select(ap, 0);
2200
2201 /* issue bus reset */
2202 DPRINTK("about to softreset, devmask=%x\n", devmask);
2203 err_mask = ata_bus_softreset(ap, devmask);
2204 if (err_mask) {
2205 if (verbose)
2206 printk(KERN_ERR "ata%u: SRST failed (err_mask=0x%x)\n",
2207 ap->id, err_mask);
2208 else
2209 DPRINTK("EXIT, softreset failed (err_mask=0x%x)\n",
2210 err_mask);
2211 return -EIO;
2212 }
2213
2214 /* determine by signature whether we have ATA or ATAPI devices */
2215 classes[0] = ata_dev_try_classify(ap, 0, &err);
2216 if (slave_possible && err != 0x81)
2217 classes[1] = ata_dev_try_classify(ap, 1, &err);
2218
Tejun Heo3a397462006-02-10 23:58:48 +09002219 out:
Tejun Heoc2bd5802006-01-24 17:05:22 +09002220 DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
2221 return 0;
2222}
2223
2224/**
2225 * sata_std_hardreset - reset host port via SATA phy reset
2226 * @ap: port to reset
2227 * @verbose: fail verbosely
2228 * @class: resulting class of attached device
2229 *
2230 * SATA phy-reset host port using DET bits of SControl register.
2231 * This function is to be used as standard callback for
2232 * ata_drive_*_reset().
2233 *
2234 * LOCKING:
2235 * Kernel thread context (may sleep)
2236 *
2237 * RETURNS:
2238 * 0 on success, -errno otherwise.
2239 */
2240int sata_std_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
2241{
Tejun Heoc2bd5802006-01-24 17:05:22 +09002242 DPRINTK("ENTER\n");
2243
2244 /* Issue phy wake/reset */
2245 scr_write_flush(ap, SCR_CONTROL, 0x301);
2246
2247 /*
2248 * Couldn't find anything in SATA I/II specs, but AHCI-1.1
2249 * 10.4.2 says at least 1 ms.
2250 */
2251 msleep(1);
2252
Tejun Heo7a7921e2006-02-02 18:20:00 +09002253 /* Bring phy back */
2254 sata_phy_resume(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002255
Tejun Heoc2bd5802006-01-24 17:05:22 +09002256 /* TODO: phy layer with polling, timeouts, etc. */
2257 if (!sata_dev_present(ap)) {
2258 *class = ATA_DEV_NONE;
2259 DPRINTK("EXIT, link offline\n");
2260 return 0;
2261 }
2262
2263 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
2264 if (verbose)
2265 printk(KERN_ERR "ata%u: COMRESET failed "
2266 "(device not ready)\n", ap->id);
2267 else
2268 DPRINTK("EXIT, device not ready\n");
2269 return -EIO;
2270 }
2271
Tejun Heo3a397462006-02-10 23:58:48 +09002272 ap->ops->dev_select(ap, 0); /* probably unnecessary */
2273
Tejun Heoc2bd5802006-01-24 17:05:22 +09002274 *class = ata_dev_try_classify(ap, 0, NULL);
2275
2276 DPRINTK("EXIT, class=%u\n", *class);
2277 return 0;
2278}
2279
2280/**
2281 * ata_std_postreset - standard postreset callback
2282 * @ap: the target ata_port
2283 * @classes: classes of attached devices
2284 *
2285 * This function is invoked after a successful reset. Note that
2286 * the device might have been reset more than once using
2287 * different reset methods before postreset is invoked.
Tejun Heoc2bd5802006-01-24 17:05:22 +09002288 *
2289 * This function is to be used as standard callback for
2290 * ata_drive_*_reset().
2291 *
2292 * LOCKING:
2293 * Kernel thread context (may sleep)
2294 */
2295void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
2296{
2297 DPRINTK("ENTER\n");
2298
Tejun Heo56497bd2006-02-15 15:01:42 +09002299 /* set cable type if it isn't already set */
Tejun Heoc2bd5802006-01-24 17:05:22 +09002300 if (ap->cbl == ATA_CBL_NONE && ap->flags & ATA_FLAG_SATA)
2301 ap->cbl = ATA_CBL_SATA;
2302
2303 /* print link status */
2304 if (ap->cbl == ATA_CBL_SATA)
2305 sata_print_link_status(ap);
2306
Tejun Heo3a397462006-02-10 23:58:48 +09002307 /* re-enable interrupts */
2308 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2309 ata_irq_on(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002310
2311 /* is double-select really necessary? */
2312 if (classes[0] != ATA_DEV_NONE)
2313 ap->ops->dev_select(ap, 1);
2314 if (classes[1] != ATA_DEV_NONE)
2315 ap->ops->dev_select(ap, 0);
2316
Tejun Heo3a397462006-02-10 23:58:48 +09002317 /* bail out if no device is present */
2318 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2319 DPRINTK("EXIT, no device\n");
2320 return;
2321 }
2322
2323 /* set up device control */
2324 if (ap->ioaddr.ctl_addr) {
2325 if (ap->flags & ATA_FLAG_MMIO)
2326 writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
2327 else
2328 outb(ap->ctl, ap->ioaddr.ctl_addr);
2329 }
Tejun Heoc2bd5802006-01-24 17:05:22 +09002330
2331 DPRINTK("EXIT\n");
2332}
2333
2334/**
2335 * ata_std_probe_reset - standard probe reset method
2336 * @ap: prot to perform probe-reset
2337 * @classes: resulting classes of attached devices
2338 *
2339 * The stock off-the-shelf ->probe_reset method.
2340 *
2341 * LOCKING:
2342 * Kernel thread context (may sleep)
2343 *
2344 * RETURNS:
2345 * 0 on success, -errno otherwise.
2346 */
2347int ata_std_probe_reset(struct ata_port *ap, unsigned int *classes)
2348{
2349 ata_reset_fn_t hardreset;
2350
2351 hardreset = NULL;
Tejun Heob911fc32006-02-02 18:20:00 +09002352 if (ap->flags & ATA_FLAG_SATA && ap->ops->scr_read)
Tejun Heoc2bd5802006-01-24 17:05:22 +09002353 hardreset = sata_std_hardreset;
2354
Tejun Heo8a19ac82006-02-02 18:20:00 +09002355 return ata_drive_probe_reset(ap, ata_std_probeinit,
Tejun Heo7944ea92006-02-02 18:20:00 +09002356 ata_std_softreset, hardreset,
Tejun Heoc2bd5802006-01-24 17:05:22 +09002357 ata_std_postreset, classes);
2358}
2359
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002360static int do_probe_reset(struct ata_port *ap, ata_reset_fn_t reset,
2361 ata_postreset_fn_t postreset,
2362 unsigned int *classes)
2363{
2364 int i, rc;
2365
2366 for (i = 0; i < ATA_MAX_DEVICES; i++)
2367 classes[i] = ATA_DEV_UNKNOWN;
2368
2369 rc = reset(ap, 0, classes);
2370 if (rc)
2371 return rc;
2372
2373 /* If any class isn't ATA_DEV_UNKNOWN, consider classification
2374 * is complete and convert all ATA_DEV_UNKNOWN to
2375 * ATA_DEV_NONE.
2376 */
2377 for (i = 0; i < ATA_MAX_DEVICES; i++)
2378 if (classes[i] != ATA_DEV_UNKNOWN)
2379 break;
2380
2381 if (i < ATA_MAX_DEVICES)
2382 for (i = 0; i < ATA_MAX_DEVICES; i++)
2383 if (classes[i] == ATA_DEV_UNKNOWN)
2384 classes[i] = ATA_DEV_NONE;
2385
2386 if (postreset)
2387 postreset(ap, classes);
2388
2389 return classes[0] != ATA_DEV_UNKNOWN ? 0 : -ENODEV;
2390}
2391
2392/**
2393 * ata_drive_probe_reset - Perform probe reset with given methods
2394 * @ap: port to reset
Tejun Heo7944ea92006-02-02 18:20:00 +09002395 * @probeinit: probeinit method (can be NULL)
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002396 * @softreset: softreset method (can be NULL)
2397 * @hardreset: hardreset method (can be NULL)
2398 * @postreset: postreset method (can be NULL)
2399 * @classes: resulting classes of attached devices
2400 *
2401 * Reset the specified port and classify attached devices using
2402 * given methods. This function prefers softreset but tries all
2403 * possible reset sequences to reset and classify devices. This
2404 * function is intended to be used for constructing ->probe_reset
2405 * callback by low level drivers.
2406 *
2407 * Reset methods should follow the following rules.
2408 *
2409 * - Return 0 on sucess, -errno on failure.
2410 * - If classification is supported, fill classes[] with
2411 * recognized class codes.
2412 * - If classification is not supported, leave classes[] alone.
2413 * - If verbose is non-zero, print error message on failure;
2414 * otherwise, shut up.
2415 *
2416 * LOCKING:
2417 * Kernel thread context (may sleep)
2418 *
2419 * RETURNS:
2420 * 0 on success, -EINVAL if no reset method is avaliable, -ENODEV
2421 * if classification fails, and any error code from reset
2422 * methods.
2423 */
Tejun Heo7944ea92006-02-02 18:20:00 +09002424int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002425 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2426 ata_postreset_fn_t postreset, unsigned int *classes)
2427{
2428 int rc = -EINVAL;
2429
Tejun Heo7944ea92006-02-02 18:20:00 +09002430 if (probeinit)
2431 probeinit(ap);
2432
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002433 if (softreset) {
2434 rc = do_probe_reset(ap, softreset, postreset, classes);
2435 if (rc == 0)
2436 return 0;
2437 }
2438
2439 if (!hardreset)
2440 return rc;
2441
2442 rc = do_probe_reset(ap, hardreset, postreset, classes);
2443 if (rc == 0 || rc != -ENODEV)
2444 return rc;
2445
2446 if (softreset)
2447 rc = do_probe_reset(ap, softreset, postreset, classes);
2448
2449 return rc;
2450}
2451
Tejun Heo623a3122006-03-05 17:55:58 +09002452/**
2453 * ata_dev_same_device - Determine whether new ID matches configured device
2454 * @ap: port on which the device to compare against resides
2455 * @dev: device to compare against
2456 * @new_class: class of the new device
2457 * @new_id: IDENTIFY page of the new device
2458 *
2459 * Compare @new_class and @new_id against @dev and determine
2460 * whether @dev is the device indicated by @new_class and
2461 * @new_id.
2462 *
2463 * LOCKING:
2464 * None.
2465 *
2466 * RETURNS:
2467 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
2468 */
2469static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
2470 unsigned int new_class, const u16 *new_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471{
Tejun Heo623a3122006-03-05 17:55:58 +09002472 const u16 *old_id = dev->id;
2473 unsigned char model[2][41], serial[2][21];
2474 u64 new_n_sectors;
2475
2476 if (dev->class != new_class) {
2477 printk(KERN_INFO
2478 "ata%u: dev %u class mismatch %d != %d\n",
2479 ap->id, dev->devno, dev->class, new_class);
2480 return 0;
2481 }
2482
2483 ata_id_c_string(old_id, model[0], ATA_ID_PROD_OFS, sizeof(model[0]));
2484 ata_id_c_string(new_id, model[1], ATA_ID_PROD_OFS, sizeof(model[1]));
2485 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO_OFS, sizeof(serial[0]));
2486 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO_OFS, sizeof(serial[1]));
2487 new_n_sectors = ata_id_n_sectors(new_id);
2488
2489 if (strcmp(model[0], model[1])) {
2490 printk(KERN_INFO
2491 "ata%u: dev %u model number mismatch '%s' != '%s'\n",
2492 ap->id, dev->devno, model[0], model[1]);
2493 return 0;
2494 }
2495
2496 if (strcmp(serial[0], serial[1])) {
2497 printk(KERN_INFO
2498 "ata%u: dev %u serial number mismatch '%s' != '%s'\n",
2499 ap->id, dev->devno, serial[0], serial[1]);
2500 return 0;
2501 }
2502
2503 if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
2504 printk(KERN_INFO
2505 "ata%u: dev %u n_sectors mismatch %llu != %llu\n",
2506 ap->id, dev->devno, (unsigned long long)dev->n_sectors,
2507 (unsigned long long)new_n_sectors);
2508 return 0;
2509 }
2510
2511 return 1;
2512}
2513
2514/**
2515 * ata_dev_revalidate - Revalidate ATA device
2516 * @ap: port on which the device to revalidate resides
2517 * @dev: device to revalidate
2518 * @post_reset: is this revalidation after reset?
2519 *
2520 * Re-read IDENTIFY page and make sure @dev is still attached to
2521 * the port.
2522 *
2523 * LOCKING:
2524 * Kernel thread context (may sleep)
2525 *
2526 * RETURNS:
2527 * 0 on success, negative errno otherwise
2528 */
2529int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
2530 int post_reset)
2531{
2532 unsigned int class;
2533 u16 *id;
2534 int rc;
2535
2536 if (!ata_dev_present(dev))
2537 return -ENODEV;
2538
2539 class = dev->class;
2540 id = NULL;
2541
2542 /* allocate & read ID data */
2543 rc = ata_dev_read_id(ap, dev, &class, post_reset, &id);
2544 if (rc)
2545 goto fail;
2546
2547 /* is the device still there? */
2548 if (!ata_dev_same_device(ap, dev, class, id)) {
2549 rc = -ENODEV;
2550 goto fail;
2551 }
2552
2553 kfree(dev->id);
2554 dev->id = id;
2555
2556 /* configure device according to the new ID */
2557 return ata_dev_configure(ap, dev, 0);
2558
2559 fail:
2560 printk(KERN_ERR "ata%u: dev %u revalidation failed (errno=%d)\n",
2561 ap->id, dev->devno, rc);
2562 kfree(id);
2563 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564}
2565
Arjan van de Ven98ac62d2005-11-28 10:06:23 +01002566static const char * const ata_dma_blacklist [] = {
Alan Coxf4b15fe2006-03-22 15:54:04 +00002567 "WDC AC11000H", NULL,
2568 "WDC AC22100H", NULL,
2569 "WDC AC32500H", NULL,
2570 "WDC AC33100H", NULL,
2571 "WDC AC31600H", NULL,
2572 "WDC AC32100H", "24.09P07",
2573 "WDC AC23200L", "21.10N21",
2574 "Compaq CRD-8241B", NULL,
2575 "CRD-8400B", NULL,
2576 "CRD-8480B", NULL,
2577 "CRD-8482B", NULL,
2578 "CRD-84", NULL,
2579 "SanDisk SDP3B", NULL,
2580 "SanDisk SDP3B-64", NULL,
2581 "SANYO CD-ROM CRD", NULL,
2582 "HITACHI CDR-8", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002583 "HITACHI CDR-8335", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002584 "HITACHI CDR-8435", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002585 "Toshiba CD-ROM XM-6202B", NULL,
2586 "TOSHIBA CD-ROM XM-1702BC", NULL,
2587 "CD-532E-A", NULL,
2588 "E-IDE CD-ROM CR-840", NULL,
2589 "CD-ROM Drive/F5A", NULL,
2590 "WPI CDD-820", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002591 "SAMSUNG CD-ROM SC-148C", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002592 "SAMSUNG CD-ROM SC", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002593 "SanDisk SDP3B-64", NULL,
2594 "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
2595 "_NEC DV5800A", NULL,
2596 "SAMSUNG CD-ROM SN-124", "N001"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597};
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002598
Alan Coxf4b15fe2006-03-22 15:54:04 +00002599static int ata_strim(char *s, size_t len)
2600{
2601 len = strnlen(s, len);
2602
2603 /* ATAPI specifies that empty space is blank-filled; remove blanks */
2604 while ((len > 0) && (s[len - 1] == ' ')) {
2605 len--;
2606 s[len] = 0;
2607 }
2608 return len;
2609}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610
Jeff Garzik057ace52005-10-22 14:27:05 -04002611static int ata_dma_blacklisted(const struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612{
Alan Coxf4b15fe2006-03-22 15:54:04 +00002613 unsigned char model_num[40];
2614 unsigned char model_rev[16];
2615 unsigned int nlen, rlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616 int i;
2617
Alan Coxf4b15fe2006-03-22 15:54:04 +00002618 ata_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
2619 sizeof(model_num));
2620 ata_id_string(dev->id, model_rev, ATA_ID_FW_REV_OFS,
2621 sizeof(model_rev));
2622 nlen = ata_strim(model_num, sizeof(model_num));
2623 rlen = ata_strim(model_rev, sizeof(model_rev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624
Alan Coxf4b15fe2006-03-22 15:54:04 +00002625 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i += 2) {
2626 if (!strncmp(ata_dma_blacklist[i], model_num, nlen)) {
2627 if (ata_dma_blacklist[i+1] == NULL)
2628 return 1;
2629 if (!strncmp(ata_dma_blacklist[i], model_rev, rlen))
2630 return 1;
2631 }
2632 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633 return 0;
2634}
2635
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636/**
Tejun Heoa6d5a512006-03-06 04:31:57 +09002637 * ata_dev_xfermask - Compute supported xfermask of the given device
2638 * @ap: Port on which the device to compute xfermask for resides
2639 * @dev: Device to compute xfermask for
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 *
Tejun Heoacf356b2006-03-24 14:07:50 +09002641 * Compute supported xfermask of @dev and store it in
2642 * dev->*_mask. This function is responsible for applying all
2643 * known limits including host controller limits, device
2644 * blacklist, etc...
Jeff Garzik0cba6322005-05-30 19:49:12 -04002645 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 * LOCKING:
Tejun Heoa6d5a512006-03-06 04:31:57 +09002647 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648 */
Tejun Heoacf356b2006-03-24 14:07:50 +09002649static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650{
Tejun Heoa6d5a512006-03-06 04:31:57 +09002651 unsigned long xfer_mask;
2652 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653
Tejun Heoa6d5a512006-03-06 04:31:57 +09002654 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
2655 ap->udma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656
Tejun Heoa6d5a512006-03-06 04:31:57 +09002657 /* use port-wide xfermask for now */
2658 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2659 struct ata_device *d = &ap->device[i];
2660 if (!ata_dev_present(d))
2661 continue;
Tejun Heoacf356b2006-03-24 14:07:50 +09002662 xfer_mask &= ata_pack_xfermask(d->pio_mask, d->mwdma_mask,
2663 d->udma_mask);
Tejun Heoa6d5a512006-03-06 04:31:57 +09002664 xfer_mask &= ata_id_xfermask(d->id);
2665 if (ata_dma_blacklisted(d))
2666 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 }
2668
Tejun Heoa6d5a512006-03-06 04:31:57 +09002669 if (ata_dma_blacklisted(dev))
2670 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, "
2671 "disabling DMA\n", ap->id, dev->devno);
2672
Tejun Heoacf356b2006-03-24 14:07:50 +09002673 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
2674 &dev->udma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675}
2676
2677/**
2678 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
2679 * @ap: Port associated with device @dev
2680 * @dev: Device to which command will be sent
2681 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002682 * Issue SET FEATURES - XFER MODE command to device @dev
2683 * on port @ap.
2684 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002686 * PCI/etc. bus probe sem.
Tejun Heo83206a22006-03-24 15:25:31 +09002687 *
2688 * RETURNS:
2689 * 0 on success, AC_ERR_* mask otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690 */
2691
Tejun Heo83206a22006-03-24 15:25:31 +09002692static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
2693 struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694{
Tejun Heoa0123702005-12-13 14:49:31 +09002695 struct ata_taskfile tf;
Tejun Heo83206a22006-03-24 15:25:31 +09002696 unsigned int err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697
2698 /* set up set-features taskfile */
2699 DPRINTK("set features - xfer mode\n");
2700
Tejun Heoa0123702005-12-13 14:49:31 +09002701 ata_tf_init(ap, &tf, dev->devno);
2702 tf.command = ATA_CMD_SET_FEATURES;
2703 tf.feature = SETFEATURES_XFER;
2704 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2705 tf.protocol = ATA_PROT_NODATA;
2706 tf.nsect = dev->xfer_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707
Tejun Heo83206a22006-03-24 15:25:31 +09002708 err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709
Tejun Heo83206a22006-03-24 15:25:31 +09002710 DPRINTK("EXIT, err_mask=%x\n", err_mask);
2711 return err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712}
2713
2714/**
Albert Lee8bf62ec2005-05-12 15:29:42 -04002715 * ata_dev_init_params - Issue INIT DEV PARAMS command
2716 * @ap: Port associated with device @dev
2717 * @dev: Device to which command will be sent
2718 *
2719 * LOCKING:
Tejun Heo6aff8f12006-02-15 18:24:09 +09002720 * Kernel thread context (may sleep)
2721 *
2722 * RETURNS:
2723 * 0 on success, AC_ERR_* mask otherwise.
Albert Lee8bf62ec2005-05-12 15:29:42 -04002724 */
2725
Tejun Heo6aff8f12006-02-15 18:24:09 +09002726static unsigned int ata_dev_init_params(struct ata_port *ap,
2727 struct ata_device *dev)
Albert Lee8bf62ec2005-05-12 15:29:42 -04002728{
Tejun Heoa0123702005-12-13 14:49:31 +09002729 struct ata_taskfile tf;
Tejun Heo6aff8f12006-02-15 18:24:09 +09002730 unsigned int err_mask;
Albert Lee8bf62ec2005-05-12 15:29:42 -04002731 u16 sectors = dev->id[6];
2732 u16 heads = dev->id[3];
2733
2734 /* Number of sectors per track 1-255. Number of heads 1-16 */
2735 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
Tejun Heo6aff8f12006-02-15 18:24:09 +09002736 return 0;
Albert Lee8bf62ec2005-05-12 15:29:42 -04002737
2738 /* set up init dev params taskfile */
2739 DPRINTK("init dev params \n");
2740
Tejun Heoa0123702005-12-13 14:49:31 +09002741 ata_tf_init(ap, &tf, dev->devno);
2742 tf.command = ATA_CMD_INIT_DEV_PARAMS;
2743 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2744 tf.protocol = ATA_PROT_NODATA;
2745 tf.nsect = sectors;
2746 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
Albert Lee8bf62ec2005-05-12 15:29:42 -04002747
Tejun Heo6aff8f12006-02-15 18:24:09 +09002748 err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
Albert Lee8bf62ec2005-05-12 15:29:42 -04002749
Tejun Heo6aff8f12006-02-15 18:24:09 +09002750 DPRINTK("EXIT, err_mask=%x\n", err_mask);
2751 return err_mask;
Albert Lee8bf62ec2005-05-12 15:29:42 -04002752}
2753
2754/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04002755 * ata_sg_clean - Unmap DMA memory associated with command
2756 * @qc: Command containing DMA memory to be released
2757 *
2758 * Unmap all mapped DMA memory associated with this command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 *
2760 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002761 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 */
2763
2764static void ata_sg_clean(struct ata_queued_cmd *qc)
2765{
2766 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002767 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002769 void *pad_buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770
Tejun Heoa4631472006-02-11 19:11:13 +09002771 WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
2772 WARN_ON(sg == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773
2774 if (qc->flags & ATA_QCFLAG_SINGLE)
Jeff Garzikf1318832006-02-20 16:55:56 -05002775 WARN_ON(qc->n_elem > 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05002777 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002779 /* if we padded the buffer out to 32-bit bound, and data
2780 * xfer direction is from-device, we must copy from the
2781 * pad buffer back into the supplied buffer
2782 */
2783 if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
2784 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
2785
2786 if (qc->flags & ATA_QCFLAG_SG) {
Jeff Garzike1410f22005-11-14 14:06:26 -05002787 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06002788 dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002789 /* restore last sg */
2790 sg[qc->orig_n_elem - 1].length += qc->pad_len;
2791 if (pad_buf) {
2792 struct scatterlist *psg = &qc->pad_sgent;
2793 void *addr = kmap_atomic(psg->page, KM_IRQ0);
2794 memcpy(addr + psg->offset, pad_buf, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05002795 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002796 }
2797 } else {
Tejun Heo2e242fa2006-02-20 23:48:38 +09002798 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06002799 dma_unmap_single(ap->dev,
Jeff Garzike1410f22005-11-14 14:06:26 -05002800 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
2801 dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002802 /* restore sg */
2803 sg->length += qc->pad_len;
2804 if (pad_buf)
2805 memcpy(qc->buf_virt + sg->length - qc->pad_len,
2806 pad_buf, qc->pad_len);
2807 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808
2809 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002810 qc->__sg = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811}
2812
2813/**
2814 * ata_fill_sg - Fill PCI IDE PRD table
2815 * @qc: Metadata associated with taskfile to be transferred
2816 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002817 * Fill PCI IDE PRD (scatter-gather) table with segments
2818 * associated with the current disk command.
2819 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820 * LOCKING:
Jeff Garzik780a87f2005-05-30 15:41:05 -04002821 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 *
2823 */
2824static void ata_fill_sg(struct ata_queued_cmd *qc)
2825{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002827 struct scatterlist *sg;
2828 unsigned int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829
Tejun Heoa4631472006-02-11 19:11:13 +09002830 WARN_ON(qc->__sg == NULL);
Jeff Garzikf1318832006-02-20 16:55:56 -05002831 WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832
2833 idx = 0;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002834 ata_for_each_sg(sg, qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 u32 addr, offset;
2836 u32 sg_len, len;
2837
2838 /* determine if physical DMA addr spans 64K boundary.
2839 * Note h/w doesn't support 64-bit, so we unconditionally
2840 * truncate dma_addr_t to u32.
2841 */
2842 addr = (u32) sg_dma_address(sg);
2843 sg_len = sg_dma_len(sg);
2844
2845 while (sg_len) {
2846 offset = addr & 0xffff;
2847 len = sg_len;
2848 if ((offset + sg_len) > 0x10000)
2849 len = 0x10000 - offset;
2850
2851 ap->prd[idx].addr = cpu_to_le32(addr);
2852 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
2853 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
2854
2855 idx++;
2856 sg_len -= len;
2857 addr += len;
2858 }
2859 }
2860
2861 if (idx)
2862 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2863}
2864/**
2865 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
2866 * @qc: Metadata associated with taskfile to check
2867 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002868 * Allow low-level driver to filter ATA PACKET commands, returning
2869 * a status indicating whether or not it is OK to use DMA for the
2870 * supplied PACKET command.
2871 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002873 * spin_lock_irqsave(host_set lock)
2874 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875 * RETURNS: 0 when ATAPI DMA can be used
2876 * nonzero otherwise
2877 */
2878int ata_check_atapi_dma(struct ata_queued_cmd *qc)
2879{
2880 struct ata_port *ap = qc->ap;
2881 int rc = 0; /* Assume ATAPI DMA is OK by default */
2882
2883 if (ap->ops->check_atapi_dma)
2884 rc = ap->ops->check_atapi_dma(qc);
2885
Albert Leec2bbc552006-03-25 17:56:55 +08002886 /* We don't support polling DMA.
2887 * Use PIO if the LLDD handles only interrupts in
2888 * the HSM_ST_LAST state and the ATAPI device
2889 * generates CDB interrupts.
2890 */
2891 if ((ap->flags & ATA_FLAG_PIO_POLLING) &&
2892 (qc->dev->flags & ATA_DFLAG_CDB_INTR))
2893 rc = 1;
2894
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 return rc;
2896}
2897/**
2898 * ata_qc_prep - Prepare taskfile for submission
2899 * @qc: Metadata associated with taskfile to be prepared
2900 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002901 * Prepare ATA taskfile for submission.
2902 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903 * LOCKING:
2904 * spin_lock_irqsave(host_set lock)
2905 */
2906void ata_qc_prep(struct ata_queued_cmd *qc)
2907{
2908 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2909 return;
2910
2911 ata_fill_sg(qc);
2912}
2913
Brian Kinge46834c2006-03-17 17:04:03 -06002914void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
2915
Jeff Garzik0cba6322005-05-30 19:49:12 -04002916/**
2917 * ata_sg_init_one - Associate command with memory buffer
2918 * @qc: Command to be associated
2919 * @buf: Memory buffer
2920 * @buflen: Length of memory buffer, in bytes.
2921 *
2922 * Initialize the data-related elements of queued_cmd @qc
2923 * to point to a single memory buffer, @buf of byte length @buflen.
2924 *
2925 * LOCKING:
2926 * spin_lock_irqsave(host_set lock)
2927 */
2928
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
2930{
2931 struct scatterlist *sg;
2932
2933 qc->flags |= ATA_QCFLAG_SINGLE;
2934
2935 memset(&qc->sgent, 0, sizeof(qc->sgent));
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002936 qc->__sg = &qc->sgent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 qc->n_elem = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002938 qc->orig_n_elem = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 qc->buf_virt = buf;
2940
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002941 sg = qc->__sg;
Jeff Garzikf0612bb2005-10-30 01:58:18 -05002942 sg_init_one(sg, buf, buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002943}
2944
Jeff Garzik0cba6322005-05-30 19:49:12 -04002945/**
2946 * ata_sg_init - Associate command with scatter-gather table.
2947 * @qc: Command to be associated
2948 * @sg: Scatter-gather table.
2949 * @n_elem: Number of elements in s/g table.
2950 *
2951 * Initialize the data-related elements of queued_cmd @qc
2952 * to point to a scatter-gather table @sg, containing @n_elem
2953 * elements.
2954 *
2955 * LOCKING:
2956 * spin_lock_irqsave(host_set lock)
2957 */
2958
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
2960 unsigned int n_elem)
2961{
2962 qc->flags |= ATA_QCFLAG_SG;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002963 qc->__sg = sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 qc->n_elem = n_elem;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002965 qc->orig_n_elem = n_elem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966}
2967
2968/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04002969 * ata_sg_setup_one - DMA-map the memory buffer associated with a command.
2970 * @qc: Command with memory buffer to be mapped.
2971 *
2972 * DMA-map the memory buffer associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002973 *
2974 * LOCKING:
2975 * spin_lock_irqsave(host_set lock)
2976 *
2977 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002978 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979 */
2980
2981static int ata_sg_setup_one(struct ata_queued_cmd *qc)
2982{
2983 struct ata_port *ap = qc->ap;
2984 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002985 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986 dma_addr_t dma_address;
Tejun Heo2e242fa2006-02-20 23:48:38 +09002987 int trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002989 /* we must lengthen transfers to end on a 32-bit boundary */
2990 qc->pad_len = sg->length & 3;
2991 if (qc->pad_len) {
2992 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
2993 struct scatterlist *psg = &qc->pad_sgent;
2994
Tejun Heoa4631472006-02-11 19:11:13 +09002995 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04002996
2997 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
2998
2999 if (qc->tf.flags & ATA_TFLAG_WRITE)
3000 memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
3001 qc->pad_len);
3002
3003 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3004 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3005 /* trim sg */
3006 sg->length -= qc->pad_len;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003007 if (sg->length == 0)
3008 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003009
3010 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
3011 sg->length, qc->pad_len);
3012 }
3013
Tejun Heo2e242fa2006-02-20 23:48:38 +09003014 if (trim_sg) {
3015 qc->n_elem--;
Jeff Garzike1410f22005-11-14 14:06:26 -05003016 goto skip_map;
3017 }
3018
Brian King2f1f6102006-03-23 17:30:15 -06003019 dma_address = dma_map_single(ap->dev, qc->buf_virt,
Albert Lee32529e02005-05-26 03:49:42 -04003020 sg->length, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003021 if (dma_mapping_error(dma_address)) {
3022 /* restore sg */
3023 sg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003025 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026
3027 sg_dma_address(sg) = dma_address;
Albert Lee32529e02005-05-26 03:49:42 -04003028 sg_dma_len(sg) = sg->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029
Tejun Heo2e242fa2006-02-20 23:48:38 +09003030skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
3032 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3033
3034 return 0;
3035}
3036
3037/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003038 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
3039 * @qc: Command with scatter-gather table to be mapped.
3040 *
3041 * DMA-map the scatter-gather table associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042 *
3043 * LOCKING:
3044 * spin_lock_irqsave(host_set lock)
3045 *
3046 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003047 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 *
3049 */
3050
3051static int ata_sg_setup(struct ata_queued_cmd *qc)
3052{
3053 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003054 struct scatterlist *sg = qc->__sg;
3055 struct scatterlist *lsg = &sg[qc->n_elem - 1];
Jeff Garzike1410f22005-11-14 14:06:26 -05003056 int n_elem, pre_n_elem, dir, trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057
3058 VPRINTK("ENTER, ata%u\n", ap->id);
Tejun Heoa4631472006-02-11 19:11:13 +09003059 WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003061 /* we must lengthen transfers to end on a 32-bit boundary */
3062 qc->pad_len = lsg->length & 3;
3063 if (qc->pad_len) {
3064 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3065 struct scatterlist *psg = &qc->pad_sgent;
3066 unsigned int offset;
3067
Tejun Heoa4631472006-02-11 19:11:13 +09003068 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003069
3070 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3071
3072 /*
3073 * psg->page/offset are used to copy to-be-written
3074 * data in this function or read data in ata_sg_clean.
3075 */
3076 offset = lsg->offset + lsg->length - qc->pad_len;
3077 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
3078 psg->offset = offset_in_page(offset);
3079
3080 if (qc->tf.flags & ATA_TFLAG_WRITE) {
3081 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3082 memcpy(pad_buf, addr + psg->offset, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05003083 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003084 }
3085
3086 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3087 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3088 /* trim last sg */
3089 lsg->length -= qc->pad_len;
Jeff Garzike1410f22005-11-14 14:06:26 -05003090 if (lsg->length == 0)
3091 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003092
3093 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
3094 qc->n_elem - 1, lsg->length, qc->pad_len);
3095 }
3096
Jeff Garzike1410f22005-11-14 14:06:26 -05003097 pre_n_elem = qc->n_elem;
3098 if (trim_sg && pre_n_elem)
3099 pre_n_elem--;
3100
3101 if (!pre_n_elem) {
3102 n_elem = 0;
3103 goto skip_map;
3104 }
3105
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106 dir = qc->dma_dir;
Brian King2f1f6102006-03-23 17:30:15 -06003107 n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003108 if (n_elem < 1) {
3109 /* restore last sg */
3110 lsg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003112 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113
3114 DPRINTK("%d sg elements mapped\n", n_elem);
3115
Jeff Garzike1410f22005-11-14 14:06:26 -05003116skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 qc->n_elem = n_elem;
3118
3119 return 0;
3120}
3121
3122/**
Tejun Heo40e8c822005-08-22 17:12:45 +09003123 * ata_poll_qc_complete - turn irq back on and finish qc
3124 * @qc: Command to complete
Randy Dunlap8e8b77d2005-11-01 21:29:27 -08003125 * @err_mask: ATA status register content
Tejun Heo40e8c822005-08-22 17:12:45 +09003126 *
3127 * LOCKING:
3128 * None. (grabs host lock)
3129 */
3130
Albert Leea22e2eb2005-12-05 15:38:02 +08003131void ata_poll_qc_complete(struct ata_queued_cmd *qc)
Tejun Heo40e8c822005-08-22 17:12:45 +09003132{
3133 struct ata_port *ap = qc->ap;
Jeff Garzikb8f61532005-08-25 22:01:20 -04003134 unsigned long flags;
Tejun Heo40e8c822005-08-22 17:12:45 +09003135
Jeff Garzikb8f61532005-08-25 22:01:20 -04003136 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo40e8c822005-08-22 17:12:45 +09003137 ata_irq_on(ap);
Albert Leea22e2eb2005-12-05 15:38:02 +08003138 ata_qc_complete(qc);
Jeff Garzikb8f61532005-08-25 22:01:20 -04003139 spin_unlock_irqrestore(&ap->host_set->lock, flags);
Tejun Heo40e8c822005-08-22 17:12:45 +09003140}
3141
3142/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003143 * swap_buf_le16 - swap halves of 16-bit words in place
Edward Falk0baab862005-06-02 18:17:13 -04003144 * @buf: Buffer to swap
3145 * @buf_words: Number of 16-bit words in buffer.
3146 *
3147 * Swap halves of 16-bit words if needed to convert from
3148 * little-endian byte order to native cpu byte order, or
3149 * vice-versa.
3150 *
3151 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003152 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04003153 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154void swap_buf_le16(u16 *buf, unsigned int buf_words)
3155{
3156#ifdef __BIG_ENDIAN
3157 unsigned int i;
3158
3159 for (i = 0; i < buf_words; i++)
3160 buf[i] = le16_to_cpu(buf[i]);
3161#endif /* __BIG_ENDIAN */
3162}
3163
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003164/**
3165 * ata_mmio_data_xfer - Transfer data by MMIO
3166 * @ap: port to read/write
3167 * @buf: data buffer
3168 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003169 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003170 *
3171 * Transfer data from/to the device data register by MMIO.
3172 *
3173 * LOCKING:
3174 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003175 */
3176
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
3178 unsigned int buflen, int write_data)
3179{
3180 unsigned int i;
3181 unsigned int words = buflen >> 1;
3182 u16 *buf16 = (u16 *) buf;
3183 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
3184
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003185 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003186 if (write_data) {
3187 for (i = 0; i < words; i++)
3188 writew(le16_to_cpu(buf16[i]), mmio);
3189 } else {
3190 for (i = 0; i < words; i++)
3191 buf16[i] = cpu_to_le16(readw(mmio));
3192 }
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003193
3194 /* Transfer trailing 1 byte, if any. */
3195 if (unlikely(buflen & 0x01)) {
3196 u16 align_buf[1] = { 0 };
3197 unsigned char *trailing_buf = buf + buflen - 1;
3198
3199 if (write_data) {
3200 memcpy(align_buf, trailing_buf, 1);
3201 writew(le16_to_cpu(align_buf[0]), mmio);
3202 } else {
3203 align_buf[0] = cpu_to_le16(readw(mmio));
3204 memcpy(trailing_buf, align_buf, 1);
3205 }
3206 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207}
3208
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003209/**
3210 * ata_pio_data_xfer - Transfer data by PIO
3211 * @ap: port to read/write
3212 * @buf: data buffer
3213 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003214 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003215 *
3216 * Transfer data from/to the device data register by PIO.
3217 *
3218 * LOCKING:
3219 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003220 */
3221
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
3223 unsigned int buflen, int write_data)
3224{
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003225 unsigned int words = buflen >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003227 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228 if (write_data)
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003229 outsw(ap->ioaddr.data_addr, buf, words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003230 else
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003231 insw(ap->ioaddr.data_addr, buf, words);
3232
3233 /* Transfer trailing 1 byte, if any. */
3234 if (unlikely(buflen & 0x01)) {
3235 u16 align_buf[1] = { 0 };
3236 unsigned char *trailing_buf = buf + buflen - 1;
3237
3238 if (write_data) {
3239 memcpy(align_buf, trailing_buf, 1);
3240 outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
3241 } else {
3242 align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
3243 memcpy(trailing_buf, align_buf, 1);
3244 }
3245 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246}
3247
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003248/**
3249 * ata_data_xfer - Transfer data from/to the data register.
3250 * @ap: port to read/write
3251 * @buf: data buffer
3252 * @buflen: buffer length
3253 * @do_write: read/write
3254 *
3255 * Transfer data from/to the device data register.
3256 *
3257 * LOCKING:
3258 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003259 */
3260
Linus Torvalds1da177e2005-04-16 15:20:36 -07003261static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
3262 unsigned int buflen, int do_write)
3263{
Alan Coxa1bd9e62006-01-17 20:53:50 +00003264 /* Make the crap hardware pay the costs not the good stuff */
3265 if (unlikely(ap->flags & ATA_FLAG_IRQ_MASK)) {
3266 unsigned long flags;
3267 local_irq_save(flags);
3268 if (ap->flags & ATA_FLAG_MMIO)
3269 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3270 else
3271 ata_pio_data_xfer(ap, buf, buflen, do_write);
3272 local_irq_restore(flags);
3273 } else {
3274 if (ap->flags & ATA_FLAG_MMIO)
3275 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3276 else
3277 ata_pio_data_xfer(ap, buf, buflen, do_write);
3278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279}
3280
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003281/**
3282 * ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
3283 * @qc: Command on going
3284 *
3285 * Transfer ATA_SECT_SIZE of data from/to the ATA device.
3286 *
3287 * LOCKING:
3288 * Inherited from caller.
3289 */
3290
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291static void ata_pio_sector(struct ata_queued_cmd *qc)
3292{
3293 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003294 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295 struct ata_port *ap = qc->ap;
3296 struct page *page;
3297 unsigned int offset;
3298 unsigned char *buf;
3299
3300 if (qc->cursect == (qc->nsect - 1))
Albert Lee14be71f2005-09-27 17:36:35 +08003301 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302
3303 page = sg[qc->cursg].page;
3304 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
3305
3306 /* get the current page and offset */
3307 page = nth_page(page, (offset >> PAGE_SHIFT));
3308 offset %= PAGE_SIZE;
3309
Albert Lee7282aa42005-10-09 09:46:07 -04003310 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3311
Albert Lee91b8b312005-10-09 09:48:44 -04003312 if (PageHighMem(page)) {
3313 unsigned long flags;
Albert Lee7282aa42005-10-09 09:46:07 -04003314
Albert Lee91b8b312005-10-09 09:48:44 -04003315 local_irq_save(flags);
3316 buf = kmap_atomic(page, KM_IRQ0);
Albert Lee083958d2005-10-09 09:47:31 -04003317
Albert Lee91b8b312005-10-09 09:48:44 -04003318 /* do the actual data transfer */
3319 ata_data_xfer(ap, buf + offset, ATA_SECT_SIZE, do_write);
3320
3321 kunmap_atomic(buf, KM_IRQ0);
3322 local_irq_restore(flags);
3323 } else {
3324 buf = page_address(page);
3325 ata_data_xfer(ap, buf + offset, ATA_SECT_SIZE, do_write);
3326 }
Albert Lee7282aa42005-10-09 09:46:07 -04003327
Linus Torvalds1da177e2005-04-16 15:20:36 -07003328 qc->cursect++;
3329 qc->cursg_ofs++;
3330
Albert Lee32529e02005-05-26 03:49:42 -04003331 if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 qc->cursg++;
3333 qc->cursg_ofs = 0;
3334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335}
3336
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003337/**
Albert Lee07f6f7d2005-11-01 19:33:20 +08003338 * ata_pio_sectors - Transfer one or many 512-byte sectors.
3339 * @qc: Command on going
3340 *
3341 * Transfer one or many ATA_SECT_SIZE of data from/to the
3342 * ATA device for the DRQ request.
3343 *
3344 * LOCKING:
3345 * Inherited from caller.
3346 */
3347
3348static void ata_pio_sectors(struct ata_queued_cmd *qc)
3349{
3350 if (is_multi_taskfile(&qc->tf)) {
3351 /* READ/WRITE MULTIPLE */
3352 unsigned int nsect;
3353
Jeff Garzik587005d2006-02-11 18:17:32 -05003354 WARN_ON(qc->dev->multi_count == 0);
Albert Lee07f6f7d2005-11-01 19:33:20 +08003355
3356 nsect = min(qc->nsect - qc->cursect, qc->dev->multi_count);
3357 while (nsect--)
3358 ata_pio_sector(qc);
3359 } else
3360 ata_pio_sector(qc);
3361}
3362
3363/**
Albert Leec71c1852005-10-04 06:03:45 -04003364 * atapi_send_cdb - Write CDB bytes to hardware
3365 * @ap: Port to which ATAPI device is attached.
3366 * @qc: Taskfile currently active
3367 *
3368 * When device has indicated its readiness to accept
3369 * a CDB, this function is called. Send the CDB.
3370 *
3371 * LOCKING:
3372 * caller.
3373 */
3374
3375static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
3376{
3377 /* send SCSI cdb */
3378 DPRINTK("send cdb\n");
Jeff Garzikdb024d52006-02-13 00:23:57 -05003379 WARN_ON(qc->dev->cdb_len < 12);
Albert Leec71c1852005-10-04 06:03:45 -04003380
Jeff Garzikdb024d52006-02-13 00:23:57 -05003381 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
Albert Leec71c1852005-10-04 06:03:45 -04003382 ata_altstatus(ap); /* flush */
3383
3384 switch (qc->tf.protocol) {
3385 case ATA_PROT_ATAPI:
3386 ap->hsm_task_state = HSM_ST;
3387 break;
3388 case ATA_PROT_ATAPI_NODATA:
3389 ap->hsm_task_state = HSM_ST_LAST;
3390 break;
3391 case ATA_PROT_ATAPI_DMA:
3392 ap->hsm_task_state = HSM_ST_LAST;
3393 /* initiate bmdma */
3394 ap->ops->bmdma_start(qc);
3395 break;
3396 }
3397}
3398
3399/**
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003400 * __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3401 * @qc: Command on going
3402 * @bytes: number of bytes
3403 *
3404 * Transfer Transfer data from/to the ATAPI device.
3405 *
3406 * LOCKING:
3407 * Inherited from caller.
3408 *
3409 */
3410
Linus Torvalds1da177e2005-04-16 15:20:36 -07003411static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3412{
3413 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003414 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003415 struct ata_port *ap = qc->ap;
3416 struct page *page;
3417 unsigned char *buf;
3418 unsigned int offset, count;
3419
Albert Lee563a6e12005-08-12 14:17:50 +08003420 if (qc->curbytes + bytes >= qc->nbytes)
Albert Lee14be71f2005-09-27 17:36:35 +08003421 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003422
3423next_sg:
Albert Lee563a6e12005-08-12 14:17:50 +08003424 if (unlikely(qc->cursg >= qc->n_elem)) {
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003425 /*
Albert Lee563a6e12005-08-12 14:17:50 +08003426 * The end of qc->sg is reached and the device expects
3427 * more data to transfer. In order not to overrun qc->sg
3428 * and fulfill length specified in the byte count register,
3429 * - for read case, discard trailing data from the device
3430 * - for write case, padding zero data to the device
3431 */
3432 u16 pad_buf[1] = { 0 };
3433 unsigned int words = bytes >> 1;
3434 unsigned int i;
3435
3436 if (words) /* warning if bytes > 1 */
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003437 printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
Albert Lee563a6e12005-08-12 14:17:50 +08003438 ap->id, bytes);
3439
3440 for (i = 0; i < words; i++)
3441 ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
3442
Albert Lee14be71f2005-09-27 17:36:35 +08003443 ap->hsm_task_state = HSM_ST_LAST;
Albert Lee563a6e12005-08-12 14:17:50 +08003444 return;
3445 }
3446
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003447 sg = &qc->__sg[qc->cursg];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 page = sg->page;
3450 offset = sg->offset + qc->cursg_ofs;
3451
3452 /* get the current page and offset */
3453 page = nth_page(page, (offset >> PAGE_SHIFT));
3454 offset %= PAGE_SIZE;
3455
Albert Lee6952df02005-06-06 15:56:03 +08003456 /* don't overrun current sg */
Albert Lee32529e02005-05-26 03:49:42 -04003457 count = min(sg->length - qc->cursg_ofs, bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003458
3459 /* don't cross page boundaries */
3460 count = min(count, (unsigned int)PAGE_SIZE - offset);
3461
Albert Lee7282aa42005-10-09 09:46:07 -04003462 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3463
Albert Lee91b8b312005-10-09 09:48:44 -04003464 if (PageHighMem(page)) {
3465 unsigned long flags;
Albert Lee7282aa42005-10-09 09:46:07 -04003466
Albert Lee91b8b312005-10-09 09:48:44 -04003467 local_irq_save(flags);
3468 buf = kmap_atomic(page, KM_IRQ0);
Albert Lee083958d2005-10-09 09:47:31 -04003469
Albert Lee91b8b312005-10-09 09:48:44 -04003470 /* do the actual data transfer */
3471 ata_data_xfer(ap, buf + offset, count, do_write);
3472
3473 kunmap_atomic(buf, KM_IRQ0);
3474 local_irq_restore(flags);
3475 } else {
3476 buf = page_address(page);
3477 ata_data_xfer(ap, buf + offset, count, do_write);
3478 }
Albert Lee7282aa42005-10-09 09:46:07 -04003479
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480 bytes -= count;
3481 qc->curbytes += count;
3482 qc->cursg_ofs += count;
3483
Albert Lee32529e02005-05-26 03:49:42 -04003484 if (qc->cursg_ofs == sg->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485 qc->cursg++;
3486 qc->cursg_ofs = 0;
3487 }
3488
Albert Lee563a6e12005-08-12 14:17:50 +08003489 if (bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003490 goto next_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491}
3492
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003493/**
3494 * atapi_pio_bytes - Transfer data from/to the ATAPI device.
3495 * @qc: Command on going
3496 *
3497 * Transfer Transfer data from/to the ATAPI device.
3498 *
3499 * LOCKING:
3500 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003501 */
3502
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3504{
3505 struct ata_port *ap = qc->ap;
3506 struct ata_device *dev = qc->dev;
3507 unsigned int ireason, bc_lo, bc_hi, bytes;
3508 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3509
3510 ap->ops->tf_read(ap, &qc->tf);
3511 ireason = qc->tf.nsect;
3512 bc_lo = qc->tf.lbam;
3513 bc_hi = qc->tf.lbah;
3514 bytes = (bc_hi << 8) | bc_lo;
3515
3516 /* shall be cleared to zero, indicating xfer of data */
3517 if (ireason & (1 << 0))
3518 goto err_out;
3519
3520 /* make sure transfer direction matches expected */
3521 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3522 if (do_write != i_write)
3523 goto err_out;
3524
Albert Lee312f7da2005-09-27 17:38:03 +08003525 VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes);
3526
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 __atapi_pio_bytes(qc, bytes);
3528
3529 return;
3530
3531err_out:
3532 printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
3533 ap->id, dev->devno);
Tejun Heo11a56d22006-01-23 13:09:36 +09003534 qc->err_mask |= AC_ERR_HSM;
Albert Lee14be71f2005-09-27 17:36:35 +08003535 ap->hsm_task_state = HSM_ST_ERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536}
3537
3538/**
Albert Leec234fb02006-03-25 17:58:38 +08003539 * ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue.
3540 * @ap: the target ata_port
3541 * @qc: qc on going
3542 *
3543 * RETURNS:
3544 * 1 if ok in workqueue, 0 otherwise.
3545 */
3546
3547static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc)
3548{
3549 if (qc->tf.flags & ATA_TFLAG_POLLING)
3550 return 1;
3551
3552 if (ap->hsm_task_state == HSM_ST_FIRST) {
3553 if (qc->tf.protocol == ATA_PROT_PIO &&
3554 (qc->tf.flags & ATA_TFLAG_WRITE))
3555 return 1;
3556
3557 if (is_atapi_taskfile(&qc->tf) &&
3558 !(qc->dev->flags & ATA_DFLAG_CDB_INTR))
3559 return 1;
3560 }
3561
3562 return 0;
3563}
3564
3565/**
Albert Leebb5cb292006-03-25 17:48:02 +08003566 * ata_hsm_move - move the HSM to the next state.
3567 * @ap: the target ata_port
3568 * @qc: qc on going
3569 * @status: current device status
3570 * @in_wq: 1 if called from workqueue, 0 otherwise
3571 *
3572 * RETURNS:
3573 * 1 when poll next status needed, 0 otherwise.
3574 */
3575
3576static int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
3577 u8 status, int in_wq)
Albert Leee2cec772006-03-25 17:43:49 +08003578{
Albert Leebb5cb292006-03-25 17:48:02 +08003579 unsigned long flags = 0;
3580 int poll_next;
3581
Albert Lee6912ccd2006-03-25 17:45:49 +08003582 WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0);
3583
Albert Leebb5cb292006-03-25 17:48:02 +08003584 /* Make sure ata_qc_issue_prot() does not throw things
3585 * like DMA polling into the workqueue. Notice that
3586 * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING).
3587 */
Albert Leec234fb02006-03-25 17:58:38 +08003588 WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc));
Albert Leebb5cb292006-03-25 17:48:02 +08003589
Albert Leee2cec772006-03-25 17:43:49 +08003590fsm_start:
Albert Lee999bb6f2006-03-25 18:07:48 +08003591 DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
3592 ap->id, qc->tf.protocol, ap->hsm_task_state, status);
3593
Albert Leee2cec772006-03-25 17:43:49 +08003594 switch (ap->hsm_task_state) {
3595 case HSM_ST_FIRST:
Albert Leebb5cb292006-03-25 17:48:02 +08003596 /* Send first data block or PACKET CDB */
3597
3598 /* If polling, we will stay in the work queue after
3599 * sending the data. Otherwise, interrupt handler
3600 * takes over after sending the data.
3601 */
3602 poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);
3603
Albert Leee2cec772006-03-25 17:43:49 +08003604 /* check device status */
3605 if (unlikely((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)) {
3606 /* Wrong status. Let EH handle this */
3607 qc->err_mask |= AC_ERR_HSM;
3608 ap->hsm_task_state = HSM_ST_ERR;
3609 goto fsm_start;
3610 }
3611
Albert Lee71601952006-03-25 18:11:12 +08003612 /* Device should not ask for data transfer (DRQ=1)
3613 * when it finds something wrong.
3614 * Anyway, we respect DRQ here and let HSM go on
3615 * without changing hsm_task_state to HSM_ST_ERR.
3616 */
3617 if (unlikely(status & (ATA_ERR | ATA_DF))) {
3618 printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
3619 ap->id, status);
3620 qc->err_mask |= AC_ERR_DEV;
3621 }
3622
Albert Leebb5cb292006-03-25 17:48:02 +08003623 /* Send the CDB (atapi) or the first data block (ata pio out).
3624 * During the state transition, interrupt handler shouldn't
3625 * be invoked before the data transfer is complete and
3626 * hsm_task_state is changed. Hence, the following locking.
3627 */
3628 if (in_wq)
3629 spin_lock_irqsave(&ap->host_set->lock, flags);
Albert Leee2cec772006-03-25 17:43:49 +08003630
Albert Leebb5cb292006-03-25 17:48:02 +08003631 if (qc->tf.protocol == ATA_PROT_PIO) {
3632 /* PIO data out protocol.
3633 * send first data block.
3634 */
3635
3636 /* ata_pio_sectors() might change the state
3637 * to HSM_ST_LAST. so, the state is changed here
3638 * before ata_pio_sectors().
3639 */
3640 ap->hsm_task_state = HSM_ST;
3641 ata_pio_sectors(qc);
3642 ata_altstatus(ap); /* flush */
3643 } else
3644 /* send CDB */
3645 atapi_send_cdb(ap, qc);
3646
3647 if (in_wq)
3648 spin_unlock_irqrestore(&ap->host_set->lock, flags);
3649
3650 /* if polling, ata_pio_task() handles the rest.
3651 * otherwise, interrupt handler takes over from here.
3652 */
Albert Leee2cec772006-03-25 17:43:49 +08003653 break;
3654
3655 case HSM_ST:
3656 /* complete command or read/write the data register */
3657 if (qc->tf.protocol == ATA_PROT_ATAPI) {
3658 /* ATAPI PIO protocol */
3659 if ((status & ATA_DRQ) == 0) {
3660 /* no more data to transfer */
3661 ap->hsm_task_state = HSM_ST_LAST;
3662 goto fsm_start;
3663 }
3664
Albert Lee71601952006-03-25 18:11:12 +08003665 /* Device should not ask for data transfer (DRQ=1)
3666 * when it finds something wrong.
3667 * Anyway, we respect DRQ here and let HSM go on
3668 * without changing hsm_task_state to HSM_ST_ERR.
3669 */
3670 if (unlikely(status & (ATA_ERR | ATA_DF))) {
3671 printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
3672 ap->id, status);
3673 qc->err_mask |= AC_ERR_DEV;
3674 }
3675
Albert Leee2cec772006-03-25 17:43:49 +08003676 atapi_pio_bytes(qc);
3677
3678 if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
3679 /* bad ireason reported by device */
3680 goto fsm_start;
3681
3682 } else {
3683 /* ATA PIO protocol */
3684 if (unlikely((status & ATA_DRQ) == 0)) {
3685 /* handle BSY=0, DRQ=0 as error */
3686 qc->err_mask |= AC_ERR_HSM;
3687 ap->hsm_task_state = HSM_ST_ERR;
3688 goto fsm_start;
3689 }
3690
Albert Lee71601952006-03-25 18:11:12 +08003691 /* Some devices may ask for data transfer (DRQ=1)
3692 * alone with ERR=1 for PIO reads.
3693 * We respect DRQ here and let HSM go on without
3694 * changing hsm_task_state to HSM_ST_ERR.
3695 */
3696 if (unlikely(status & (ATA_ERR | ATA_DF))) {
3697 /* For writes, ERR=1 DRQ=1 doesn't make
3698 * sense since the data block has been
3699 * transferred to the device.
3700 */
3701 WARN_ON(qc->tf.flags & ATA_TFLAG_WRITE);
3702
3703 /* data might be corrputed */
3704 qc->err_mask |= AC_ERR_DEV;
3705 }
3706
Albert Leee2cec772006-03-25 17:43:49 +08003707 ata_pio_sectors(qc);
3708
3709 if (ap->hsm_task_state == HSM_ST_LAST &&
3710 (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
3711 /* all data read */
3712 ata_altstatus(ap);
3713 status = ata_chk_status(ap);
3714 goto fsm_start;
3715 }
3716 }
3717
3718 ata_altstatus(ap); /* flush */
Albert Leebb5cb292006-03-25 17:48:02 +08003719 poll_next = 1;
Albert Leee2cec772006-03-25 17:43:49 +08003720 break;
3721
3722 case HSM_ST_LAST:
Albert Lee6912ccd2006-03-25 17:45:49 +08003723 if (unlikely(!ata_ok(status))) {
3724 qc->err_mask |= __ac_err_mask(status);
Albert Leee2cec772006-03-25 17:43:49 +08003725 ap->hsm_task_state = HSM_ST_ERR;
3726 goto fsm_start;
3727 }
3728
3729 /* no more data to transfer */
3730 DPRINTK("ata%u: command complete, drv_stat 0x%x\n",
3731 ap->id, status);
3732
Albert Lee6912ccd2006-03-25 17:45:49 +08003733 WARN_ON(qc->err_mask);
3734
Albert Leee2cec772006-03-25 17:43:49 +08003735 ap->hsm_task_state = HSM_ST_IDLE;
3736
3737 /* complete taskfile transaction */
Albert Leebb5cb292006-03-25 17:48:02 +08003738 if (in_wq)
3739 ata_poll_qc_complete(qc);
3740 else
3741 ata_qc_complete(qc);
3742
3743 poll_next = 0;
Albert Leee2cec772006-03-25 17:43:49 +08003744 break;
3745
3746 case HSM_ST_ERR:
3747 if (qc->tf.command != ATA_CMD_PACKET)
Albert Lee6912ccd2006-03-25 17:45:49 +08003748 printk(KERN_ERR "ata%u: command error, drv_stat 0x%x\n",
3749 ap->id, status);
Albert Leee2cec772006-03-25 17:43:49 +08003750
3751 /* make sure qc->err_mask is available to
3752 * know what's wrong and recover
3753 */
3754 WARN_ON(qc->err_mask == 0);
3755
3756 ap->hsm_task_state = HSM_ST_IDLE;
Albert Leebb5cb292006-03-25 17:48:02 +08003757
Albert Lee999bb6f2006-03-25 18:07:48 +08003758 /* complete taskfile transaction */
Albert Leebb5cb292006-03-25 17:48:02 +08003759 if (in_wq)
3760 ata_poll_qc_complete(qc);
3761 else
3762 ata_qc_complete(qc);
3763
3764 poll_next = 0;
Albert Leee2cec772006-03-25 17:43:49 +08003765 break;
3766 default:
Albert Leebb5cb292006-03-25 17:48:02 +08003767 poll_next = 0;
Albert Lee6912ccd2006-03-25 17:45:49 +08003768 BUG();
Albert Leee2cec772006-03-25 17:43:49 +08003769 }
3770
Albert Leebb5cb292006-03-25 17:48:02 +08003771 return poll_next;
Albert Leee2cec772006-03-25 17:43:49 +08003772}
3773
Linus Torvalds1da177e2005-04-16 15:20:36 -07003774static void ata_pio_task(void *_data)
3775{
3776 struct ata_port *ap = _data;
Albert Leea1af3732006-03-25 17:50:15 +08003777 struct ata_queued_cmd *qc;
3778 u8 status;
3779 int poll_next;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003780
3781fsm_start:
Albert Leea1af3732006-03-25 17:50:15 +08003782 WARN_ON(ap->hsm_task_state == HSM_ST_IDLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003783
Albert Leea1af3732006-03-25 17:50:15 +08003784 qc = ata_qc_from_tag(ap, ap->active_tag);
3785 WARN_ON(qc == NULL);
Albert Leee27486d2005-11-01 19:24:49 +08003786
Albert Leea1af3732006-03-25 17:50:15 +08003787 /*
3788 * This is purely heuristic. This is a fast path.
3789 * Sometimes when we enter, BSY will be cleared in
3790 * a chk-status or two. If not, the drive is probably seeking
3791 * or something. Snooze for a couple msecs, then
3792 * chk-status again. If still busy, queue delayed work.
3793 */
3794 status = ata_busy_wait(ap, ATA_BUSY, 5);
3795 if (status & ATA_BUSY) {
3796 msleep(2);
3797 status = ata_busy_wait(ap, ATA_BUSY, 10);
3798 if (status & ATA_BUSY) {
3799 ata_port_queue_task(ap, ata_pio_task, ap, ATA_SHORT_PAUSE);
3800 return;
3801 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003802 }
3803
Albert Leea1af3732006-03-25 17:50:15 +08003804 /* move the HSM */
3805 poll_next = ata_hsm_move(ap, qc, status, 1);
3806
3807 /* another command or interrupt handler
3808 * may be running at this point.
3809 */
3810 if (poll_next)
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003811 goto fsm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003812}
3813
Linus Torvalds1da177e2005-04-16 15:20:36 -07003814/**
3815 * ata_qc_timeout - Handle timeout of queued command
3816 * @qc: Command that timed out
3817 *
3818 * Some part of the kernel (currently, only the SCSI layer)
3819 * has noticed that the active command on port @ap has not
3820 * completed after a specified length of time. Handle this
3821 * condition by disabling DMA (if necessary) and completing
3822 * transactions, with error if necessary.
3823 *
3824 * This also handles the case of the "lost interrupt", where
3825 * for some reason (possibly hardware bug, possibly driver bug)
3826 * an interrupt was not delivered to the driver, even though the
3827 * transaction completed successfully.
3828 *
3829 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003830 * Inherited from SCSI layer (none, can sleep)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003831 */
3832
3833static void ata_qc_timeout(struct ata_queued_cmd *qc)
3834{
3835 struct ata_port *ap = qc->ap;
Jeff Garzikb8f61532005-08-25 22:01:20 -04003836 struct ata_host_set *host_set = ap->host_set;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003837 u8 host_stat = 0, drv_stat;
Jeff Garzikb8f61532005-08-25 22:01:20 -04003838 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839
3840 DPRINTK("ENTER\n");
3841
Tejun Heoc18d06f2006-02-02 00:56:10 +09003842 ap->hsm_task_state = HSM_ST_IDLE;
3843
Jeff Garzikb8f61532005-08-25 22:01:20 -04003844 spin_lock_irqsave(&host_set->lock, flags);
3845
Linus Torvalds1da177e2005-04-16 15:20:36 -07003846 switch (qc->tf.protocol) {
3847
3848 case ATA_PROT_DMA:
3849 case ATA_PROT_ATAPI_DMA:
3850 host_stat = ap->ops->bmdma_status(ap);
3851
3852 /* before we do anything else, clear DMA-Start bit */
Alan Coxb73fc892005-08-26 16:03:19 +01003853 ap->ops->bmdma_stop(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003854
3855 /* fall through */
3856
3857 default:
3858 ata_altstatus(ap);
3859 drv_stat = ata_chk_status(ap);
3860
3861 /* ack bmdma irq events */
3862 ap->ops->irq_clear(ap);
3863
3864 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
3865 ap->id, qc->tf.command, drv_stat, host_stat);
3866
Albert Lee312f7da2005-09-27 17:38:03 +08003867 ap->hsm_task_state = HSM_ST_IDLE;
3868
Linus Torvalds1da177e2005-04-16 15:20:36 -07003869 /* complete taskfile transaction */
Albert Lee555a8962006-02-08 16:50:29 +08003870 qc->err_mask |= AC_ERR_TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003871 break;
3872 }
Jeff Garzikb8f61532005-08-25 22:01:20 -04003873
3874 spin_unlock_irqrestore(&host_set->lock, flags);
3875
Tejun Heoa72ec4c2006-01-23 13:09:37 +09003876 ata_eh_qc_complete(qc);
3877
Linus Torvalds1da177e2005-04-16 15:20:36 -07003878 DPRINTK("EXIT\n");
3879}
3880
3881/**
3882 * ata_eng_timeout - Handle timeout of queued command
3883 * @ap: Port on which timed-out command is active
3884 *
3885 * Some part of the kernel (currently, only the SCSI layer)
3886 * has noticed that the active command on port @ap has not
3887 * completed after a specified length of time. Handle this
3888 * condition by disabling DMA (if necessary) and completing
3889 * transactions, with error if necessary.
3890 *
3891 * This also handles the case of the "lost interrupt", where
3892 * for some reason (possibly hardware bug, possibly driver bug)
3893 * an interrupt was not delivered to the driver, even though the
3894 * transaction completed successfully.
3895 *
3896 * LOCKING:
3897 * Inherited from SCSI layer (none, can sleep)
3898 */
3899
3900void ata_eng_timeout(struct ata_port *ap)
3901{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 DPRINTK("ENTER\n");
3903
Tejun Heof6379022006-02-10 15:10:48 +09003904 ata_qc_timeout(ata_qc_from_tag(ap, ap->active_tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003905
Linus Torvalds1da177e2005-04-16 15:20:36 -07003906 DPRINTK("EXIT\n");
3907}
3908
3909/**
3910 * ata_qc_new - Request an available ATA command, for queueing
3911 * @ap: Port associated with device @dev
3912 * @dev: Device from whom we request an available command structure
3913 *
3914 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003915 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003916 */
3917
3918static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
3919{
3920 struct ata_queued_cmd *qc = NULL;
3921 unsigned int i;
3922
3923 for (i = 0; i < ATA_MAX_QUEUE; i++)
3924 if (!test_and_set_bit(i, &ap->qactive)) {
3925 qc = ata_qc_from_tag(ap, i);
3926 break;
3927 }
3928
3929 if (qc)
3930 qc->tag = i;
3931
3932 return qc;
3933}
3934
3935/**
3936 * ata_qc_new_init - Request an available ATA command, and initialize it
3937 * @ap: Port associated with device @dev
3938 * @dev: Device from whom we request an available command structure
3939 *
3940 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003941 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003942 */
3943
3944struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
3945 struct ata_device *dev)
3946{
3947 struct ata_queued_cmd *qc;
3948
3949 qc = ata_qc_new(ap);
3950 if (qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951 qc->scsicmd = NULL;
3952 qc->ap = ap;
3953 qc->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003954
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05003955 ata_qc_reinit(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003956 }
3957
3958 return qc;
3959}
3960
Linus Torvalds1da177e2005-04-16 15:20:36 -07003961/**
3962 * ata_qc_free - free unused ata_queued_cmd
3963 * @qc: Command to complete
3964 *
3965 * Designed to free unused ata_queued_cmd object
3966 * in case something prevents using it.
3967 *
3968 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003969 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003970 */
3971void ata_qc_free(struct ata_queued_cmd *qc)
3972{
Tejun Heo4ba946e2006-01-23 13:09:36 +09003973 struct ata_port *ap = qc->ap;
3974 unsigned int tag;
3975
Tejun Heoa4631472006-02-11 19:11:13 +09003976 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003977
Tejun Heo4ba946e2006-01-23 13:09:36 +09003978 qc->flags = 0;
3979 tag = qc->tag;
3980 if (likely(ata_tag_valid(tag))) {
3981 if (tag == ap->active_tag)
3982 ap->active_tag = ATA_TAG_POISON;
3983 qc->tag = ATA_TAG_POISON;
3984 clear_bit(tag, &ap->qactive);
3985 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003986}
3987
Tejun Heo76014422006-02-11 15:13:49 +09003988void __ata_qc_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003989{
Tejun Heoa4631472006-02-11 19:11:13 +09003990 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
3991 WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003992
3993 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
3994 ata_sg_clean(qc);
3995
Albert Lee3f3791d2005-08-16 14:25:38 +08003996 /* atapi: mark qc as inactive to prevent the interrupt handler
3997 * from completing the command twice later, before the error handler
3998 * is called. (when rc != 0 and atapi request sense is needed)
3999 */
4000 qc->flags &= ~ATA_QCFLAG_ACTIVE;
4001
Linus Torvalds1da177e2005-04-16 15:20:36 -07004002 /* call completion callback */
Tejun Heo77853bf2006-01-23 13:09:36 +09004003 qc->complete_fn(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004004}
4005
4006static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
4007{
4008 struct ata_port *ap = qc->ap;
4009
4010 switch (qc->tf.protocol) {
4011 case ATA_PROT_DMA:
4012 case ATA_PROT_ATAPI_DMA:
4013 return 1;
4014
4015 case ATA_PROT_ATAPI:
4016 case ATA_PROT_PIO:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004017 if (ap->flags & ATA_FLAG_PIO_DMA)
4018 return 1;
4019
4020 /* fall through */
4021
4022 default:
4023 return 0;
4024 }
4025
4026 /* never reached */
4027}
4028
4029/**
4030 * ata_qc_issue - issue taskfile to device
4031 * @qc: command to issue to device
4032 *
4033 * Prepare an ATA command to submission to device.
4034 * This includes mapping the data into a DMA-able
4035 * area, filling in the S/G table, and finally
4036 * writing the taskfile to hardware, starting the command.
4037 *
4038 * LOCKING:
4039 * spin_lock_irqsave(host_set lock)
4040 *
4041 * RETURNS:
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004042 * Zero on success, AC_ERR_* mask on failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004043 */
4044
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004045unsigned int ata_qc_issue(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004046{
4047 struct ata_port *ap = qc->ap;
4048
4049 if (ata_should_dma_map(qc)) {
4050 if (qc->flags & ATA_QCFLAG_SG) {
4051 if (ata_sg_setup(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004052 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004053 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
4054 if (ata_sg_setup_one(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004055 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004056 }
4057 } else {
4058 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4059 }
4060
4061 ap->ops->qc_prep(qc);
4062
4063 qc->ap->active_tag = qc->tag;
4064 qc->flags |= ATA_QCFLAG_ACTIVE;
4065
4066 return ap->ops->qc_issue(qc);
4067
Tejun Heo8e436af2006-01-23 13:09:36 +09004068sg_err:
4069 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004070 return AC_ERR_SYSTEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004071}
4072
Edward Falk0baab862005-06-02 18:17:13 -04004073
Linus Torvalds1da177e2005-04-16 15:20:36 -07004074/**
4075 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
4076 * @qc: command to issue to device
4077 *
4078 * Using various libata functions and hooks, this function
4079 * starts an ATA command. ATA commands are grouped into
4080 * classes called "protocols", and issuing each type of protocol
4081 * is slightly different.
4082 *
Edward Falk0baab862005-06-02 18:17:13 -04004083 * May be used as the qc_issue() entry in ata_port_operations.
4084 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004085 * LOCKING:
4086 * spin_lock_irqsave(host_set lock)
4087 *
4088 * RETURNS:
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004089 * Zero on success, AC_ERR_* mask on failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004090 */
4091
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004092unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004093{
4094 struct ata_port *ap = qc->ap;
4095
Albert Leee50362e2005-09-27 17:39:50 +08004096 /* Use polling pio if the LLD doesn't handle
4097 * interrupt driven pio and atapi CDB interrupt.
4098 */
4099 if (ap->flags & ATA_FLAG_PIO_POLLING) {
4100 switch (qc->tf.protocol) {
4101 case ATA_PROT_PIO:
4102 case ATA_PROT_ATAPI:
4103 case ATA_PROT_ATAPI_NODATA:
4104 qc->tf.flags |= ATA_TFLAG_POLLING;
4105 break;
4106 case ATA_PROT_ATAPI_DMA:
4107 if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
Albert Leec2bbc552006-03-25 17:56:55 +08004108 /* see ata_check_atapi_dma() */
Albert Leee50362e2005-09-27 17:39:50 +08004109 BUG();
4110 break;
4111 default:
4112 break;
4113 }
4114 }
4115
Albert Lee312f7da2005-09-27 17:38:03 +08004116 /* select the device */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004117 ata_dev_select(ap, qc->dev->devno, 1, 0);
4118
Albert Lee312f7da2005-09-27 17:38:03 +08004119 /* start the command */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004120 switch (qc->tf.protocol) {
4121 case ATA_PROT_NODATA:
Albert Lee312f7da2005-09-27 17:38:03 +08004122 if (qc->tf.flags & ATA_TFLAG_POLLING)
4123 ata_qc_set_polling(qc);
4124
Jeff Garzike5338252005-10-30 21:37:17 -05004125 ata_tf_to_host(ap, &qc->tf);
Albert Lee312f7da2005-09-27 17:38:03 +08004126 ap->hsm_task_state = HSM_ST_LAST;
4127
4128 if (qc->tf.flags & ATA_TFLAG_POLLING)
Jeff Garzik46e202e2006-03-11 19:25:47 -05004129 ata_port_queue_task(ap, ata_pio_task, ap, 0);
Albert Lee312f7da2005-09-27 17:38:03 +08004130
Linus Torvalds1da177e2005-04-16 15:20:36 -07004131 break;
4132
4133 case ATA_PROT_DMA:
Jeff Garzik587005d2006-02-11 18:17:32 -05004134 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
Albert Lee312f7da2005-09-27 17:38:03 +08004135
Linus Torvalds1da177e2005-04-16 15:20:36 -07004136 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4137 ap->ops->bmdma_setup(qc); /* set up bmdma */
4138 ap->ops->bmdma_start(qc); /* initiate bmdma */
Albert Lee312f7da2005-09-27 17:38:03 +08004139 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004140 break;
4141
Albert Lee312f7da2005-09-27 17:38:03 +08004142 case ATA_PROT_PIO:
4143 if (qc->tf.flags & ATA_TFLAG_POLLING)
4144 ata_qc_set_polling(qc);
4145
Jeff Garzike5338252005-10-30 21:37:17 -05004146 ata_tf_to_host(ap, &qc->tf);
Albert Lee312f7da2005-09-27 17:38:03 +08004147
Albert Lee54f00382005-09-30 19:14:19 +08004148 if (qc->tf.flags & ATA_TFLAG_WRITE) {
4149 /* PIO data out protocol */
4150 ap->hsm_task_state = HSM_ST_FIRST;
Jeff Garzikce1e7a22006-03-11 19:21:17 -05004151 ata_port_queue_task(ap, ata_pio_task, ap, 0);
Albert Lee54f00382005-09-30 19:14:19 +08004152
4153 /* always send first data block using
Albert Leee27486d2005-11-01 19:24:49 +08004154 * the ata_pio_task() codepath.
Albert Lee54f00382005-09-30 19:14:19 +08004155 */
Albert Lee312f7da2005-09-27 17:38:03 +08004156 } else {
Albert Lee54f00382005-09-30 19:14:19 +08004157 /* PIO data in protocol */
4158 ap->hsm_task_state = HSM_ST;
Albert Lee312f7da2005-09-27 17:38:03 +08004159
Albert Lee54f00382005-09-30 19:14:19 +08004160 if (qc->tf.flags & ATA_TFLAG_POLLING)
Jeff Garzikce1e7a22006-03-11 19:21:17 -05004161 ata_port_queue_task(ap, ata_pio_task, ap, 0);
Albert Lee312f7da2005-09-27 17:38:03 +08004162
Albert Lee54f00382005-09-30 19:14:19 +08004163 /* if polling, ata_pio_task() handles the rest.
4164 * otherwise, interrupt handler takes over from here.
4165 */
Albert Lee312f7da2005-09-27 17:38:03 +08004166 }
4167
Linus Torvalds1da177e2005-04-16 15:20:36 -07004168 break;
4169
4170 case ATA_PROT_ATAPI:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004171 case ATA_PROT_ATAPI_NODATA:
Albert Lee312f7da2005-09-27 17:38:03 +08004172 if (qc->tf.flags & ATA_TFLAG_POLLING)
4173 ata_qc_set_polling(qc);
4174
Jeff Garzike5338252005-10-30 21:37:17 -05004175 ata_tf_to_host(ap, &qc->tf);
Jeff Garzikf6ef65e2006-01-27 02:45:00 -05004176
Albert Lee312f7da2005-09-27 17:38:03 +08004177 ap->hsm_task_state = HSM_ST_FIRST;
4178
4179 /* send cdb by polling if no cdb interrupt */
4180 if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
4181 (qc->tf.flags & ATA_TFLAG_POLLING))
Albert Lee13ee4622006-03-25 17:39:34 +08004182 ata_port_queue_task(ap, ata_pio_task, ap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004183 break;
4184
4185 case ATA_PROT_ATAPI_DMA:
Jeff Garzik587005d2006-02-11 18:17:32 -05004186 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
Albert Lee312f7da2005-09-27 17:38:03 +08004187
Linus Torvalds1da177e2005-04-16 15:20:36 -07004188 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4189 ap->ops->bmdma_setup(qc); /* set up bmdma */
Albert Lee312f7da2005-09-27 17:38:03 +08004190 ap->hsm_task_state = HSM_ST_FIRST;
4191
4192 /* send cdb by polling if no cdb interrupt */
4193 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
Albert Lee13ee4622006-03-25 17:39:34 +08004194 ata_port_queue_task(ap, ata_pio_task, ap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004195 break;
4196
4197 default:
4198 WARN_ON(1);
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004199 return AC_ERR_SYSTEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004200 }
4201
4202 return 0;
4203}
4204
4205/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004206 * ata_host_intr - Handle host interrupt for given (port, task)
4207 * @ap: Port on which interrupt arrived (possibly...)
4208 * @qc: Taskfile currently active in engine
4209 *
4210 * Handle host interrupt for given queued command. Currently,
4211 * only DMA interrupts are handled. All other commands are
4212 * handled via polling with interrupts disabled (nIEN bit).
4213 *
4214 * LOCKING:
4215 * spin_lock_irqsave(host_set lock)
4216 *
4217 * RETURNS:
4218 * One if interrupt was handled, zero if not (shared irq).
4219 */
4220
4221inline unsigned int ata_host_intr (struct ata_port *ap,
4222 struct ata_queued_cmd *qc)
4223{
Albert Lee312f7da2005-09-27 17:38:03 +08004224 u8 status, host_stat = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004225
Albert Lee312f7da2005-09-27 17:38:03 +08004226 VPRINTK("ata%u: protocol %d task_state %d\n",
4227 ap->id, qc->tf.protocol, ap->hsm_task_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004228
Albert Lee312f7da2005-09-27 17:38:03 +08004229 /* Check whether we are expecting interrupt in this state */
4230 switch (ap->hsm_task_state) {
4231 case HSM_ST_FIRST:
Albert Lee6912ccd2006-03-25 17:45:49 +08004232 /* Some pre-ATAPI-4 devices assert INTRQ
4233 * at this state when ready to receive CDB.
4234 */
4235
Albert Lee312f7da2005-09-27 17:38:03 +08004236 /* Check the ATA_DFLAG_CDB_INTR flag is enough here.
4237 * The flag was turned on only for atapi devices.
4238 * No need to check is_atapi_taskfile(&qc->tf) again.
4239 */
4240 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004241 goto idle_irq;
Albert Lee312f7da2005-09-27 17:38:03 +08004242 break;
4243 case HSM_ST_LAST:
4244 if (qc->tf.protocol == ATA_PROT_DMA ||
4245 qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
4246 /* check status of DMA engine */
4247 host_stat = ap->ops->bmdma_status(ap);
4248 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004249
Albert Lee312f7da2005-09-27 17:38:03 +08004250 /* if it's not our irq... */
4251 if (!(host_stat & ATA_DMA_INTR))
4252 goto idle_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004253
Albert Lee312f7da2005-09-27 17:38:03 +08004254 /* before we do anything else, clear DMA-Start bit */
4255 ap->ops->bmdma_stop(qc);
Albert Leea4f16612005-12-26 16:40:53 +08004256
4257 if (unlikely(host_stat & ATA_DMA_ERR)) {
4258 /* error when transfering data to/from memory */
4259 qc->err_mask |= AC_ERR_HOST_BUS;
4260 ap->hsm_task_state = HSM_ST_ERR;
4261 }
Albert Lee312f7da2005-09-27 17:38:03 +08004262 }
4263 break;
4264 case HSM_ST:
4265 break;
4266 default:
4267 goto idle_irq;
4268 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004269
Albert Lee312f7da2005-09-27 17:38:03 +08004270 /* check altstatus */
4271 status = ata_altstatus(ap);
4272 if (status & ATA_BUSY)
4273 goto idle_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004274
Albert Lee312f7da2005-09-27 17:38:03 +08004275 /* check main status, clearing INTRQ */
4276 status = ata_chk_status(ap);
4277 if (unlikely(status & ATA_BUSY))
4278 goto idle_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004279
Albert Lee312f7da2005-09-27 17:38:03 +08004280 /* ack bmdma irq events */
4281 ap->ops->irq_clear(ap);
4282
Albert Leebb5cb292006-03-25 17:48:02 +08004283 ata_hsm_move(ap, qc, status, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004284 return 1; /* irq handled */
4285
4286idle_irq:
4287 ap->stats.idle_irq++;
4288
4289#ifdef ATA_IRQ_TRAP
4290 if ((ap->stats.idle_irq % 1000) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004291 ata_irq_ack(ap, 0); /* debug trap */
4292 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
Alan Cox23cfce82006-03-21 16:06:53 +00004293 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004294 }
4295#endif
4296 return 0; /* irq not handled */
4297}
4298
4299/**
4300 * ata_interrupt - Default ATA host interrupt handler
Jeff Garzik0cba6322005-05-30 19:49:12 -04004301 * @irq: irq line (unused)
4302 * @dev_instance: pointer to our ata_host_set information structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004303 * @regs: unused
4304 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004305 * Default interrupt handler for PCI IDE devices. Calls
4306 * ata_host_intr() for each port that is not disabled.
4307 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004308 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004309 * Obtains host_set lock during operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004310 *
4311 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004312 * IRQ_NONE or IRQ_HANDLED.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004313 */
4314
4315irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
4316{
4317 struct ata_host_set *host_set = dev_instance;
4318 unsigned int i;
4319 unsigned int handled = 0;
4320 unsigned long flags;
4321
4322 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
4323 spin_lock_irqsave(&host_set->lock, flags);
4324
4325 for (i = 0; i < host_set->n_ports; i++) {
4326 struct ata_port *ap;
4327
4328 ap = host_set->ports[i];
Tejun Heoc1389502005-08-22 14:59:24 +09004329 if (ap &&
Albert Lee312f7da2005-09-27 17:38:03 +08004330 !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004331 struct ata_queued_cmd *qc;
4332
4333 qc = ata_qc_from_tag(ap, ap->active_tag);
Albert Lee312f7da2005-09-27 17:38:03 +08004334 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
Albert Lee21b1ed72005-04-29 17:34:59 +08004335 (qc->flags & ATA_QCFLAG_ACTIVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004336 handled |= ata_host_intr(ap, qc);
4337 }
4338 }
4339
4340 spin_unlock_irqrestore(&host_set->lock, flags);
4341
4342 return IRQ_RETVAL(handled);
4343}
4344
Edward Falk0baab862005-06-02 18:17:13 -04004345
Jens Axboe9b847542006-01-06 09:28:07 +01004346/*
4347 * Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
4348 * without filling any other registers
4349 */
4350static int ata_do_simple_cmd(struct ata_port *ap, struct ata_device *dev,
4351 u8 cmd)
4352{
4353 struct ata_taskfile tf;
4354 int err;
4355
4356 ata_tf_init(ap, &tf, dev->devno);
4357
4358 tf.command = cmd;
4359 tf.flags |= ATA_TFLAG_DEVICE;
4360 tf.protocol = ATA_PROT_NODATA;
4361
4362 err = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
4363 if (err)
4364 printk(KERN_ERR "%s: ata command failed: %d\n",
4365 __FUNCTION__, err);
4366
4367 return err;
4368}
4369
4370static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
4371{
4372 u8 cmd;
4373
4374 if (!ata_try_flush_cache(dev))
4375 return 0;
4376
4377 if (ata_id_has_flush_ext(dev->id))
4378 cmd = ATA_CMD_FLUSH_EXT;
4379 else
4380 cmd = ATA_CMD_FLUSH;
4381
4382 return ata_do_simple_cmd(ap, dev, cmd);
4383}
4384
4385static int ata_standby_drive(struct ata_port *ap, struct ata_device *dev)
4386{
4387 return ata_do_simple_cmd(ap, dev, ATA_CMD_STANDBYNOW1);
4388}
4389
4390static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
4391{
4392 return ata_do_simple_cmd(ap, dev, ATA_CMD_IDLEIMMEDIATE);
4393}
4394
4395/**
4396 * ata_device_resume - wakeup a previously suspended devices
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004397 * @ap: port the device is connected to
4398 * @dev: the device to resume
Jens Axboe9b847542006-01-06 09:28:07 +01004399 *
4400 * Kick the drive back into action, by sending it an idle immediate
4401 * command and making sure its transfer mode matches between drive
4402 * and host.
4403 *
4404 */
4405int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
4406{
4407 if (ap->flags & ATA_FLAG_SUSPENDED) {
4408 ap->flags &= ~ATA_FLAG_SUSPENDED;
4409 ata_set_mode(ap);
4410 }
4411 if (!ata_dev_present(dev))
4412 return 0;
4413 if (dev->class == ATA_DEV_ATA)
4414 ata_start_drive(ap, dev);
4415
4416 return 0;
4417}
4418
4419/**
4420 * ata_device_suspend - prepare a device for suspend
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004421 * @ap: port the device is connected to
4422 * @dev: the device to suspend
Jens Axboe9b847542006-01-06 09:28:07 +01004423 *
4424 * Flush the cache on the drive, if appropriate, then issue a
4425 * standbynow command.
Jens Axboe9b847542006-01-06 09:28:07 +01004426 */
Nigel Cunningham082776e2006-03-23 23:22:16 +10004427int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
Jens Axboe9b847542006-01-06 09:28:07 +01004428{
4429 if (!ata_dev_present(dev))
4430 return 0;
4431 if (dev->class == ATA_DEV_ATA)
4432 ata_flush_cache(ap, dev);
4433
Nigel Cunningham082776e2006-03-23 23:22:16 +10004434 if (state.event != PM_EVENT_FREEZE)
4435 ata_standby_drive(ap, dev);
Jens Axboe9b847542006-01-06 09:28:07 +01004436 ap->flags |= ATA_FLAG_SUSPENDED;
4437 return 0;
4438}
4439
Albert Lee332b5a52006-02-08 16:51:34 +08004440/**
4441 * ata_port_start - Set port up for dma.
4442 * @ap: Port to initialize
4443 *
4444 * Called just after data structures for each port are
4445 * initialized. Allocates space for PRD table.
4446 *
4447 * May be used as the port_start() entry in ata_port_operations.
4448 *
4449 * LOCKING:
4450 * Inherited from caller.
4451 */
4452
Linus Torvalds1da177e2005-04-16 15:20:36 -07004453int ata_port_start (struct ata_port *ap)
4454{
Brian King2f1f6102006-03-23 17:30:15 -06004455 struct device *dev = ap->dev;
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004456 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004457
4458 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
4459 if (!ap->prd)
4460 return -ENOMEM;
4461
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004462 rc = ata_pad_alloc(ap, dev);
4463 if (rc) {
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004464 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004465 return rc;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004466 }
4467
Linus Torvalds1da177e2005-04-16 15:20:36 -07004468 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
4469
4470 return 0;
4471}
4472
Edward Falk0baab862005-06-02 18:17:13 -04004473
4474/**
4475 * ata_port_stop - Undo ata_port_start()
4476 * @ap: Port to shut down
4477 *
4478 * Frees the PRD table.
4479 *
4480 * May be used as the port_stop() entry in ata_port_operations.
4481 *
4482 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004483 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04004484 */
4485
Linus Torvalds1da177e2005-04-16 15:20:36 -07004486void ata_port_stop (struct ata_port *ap)
4487{
Brian King2f1f6102006-03-23 17:30:15 -06004488 struct device *dev = ap->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004489
4490 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004491 ata_pad_free(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004492}
4493
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04004494void ata_host_stop (struct ata_host_set *host_set)
4495{
4496 if (host_set->mmio_base)
4497 iounmap(host_set->mmio_base);
4498}
4499
4500
Linus Torvalds1da177e2005-04-16 15:20:36 -07004501/**
4502 * ata_host_remove - Unregister SCSI host structure with upper layers
4503 * @ap: Port to unregister
4504 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
4505 *
4506 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004507 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004508 */
4509
4510static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
4511{
4512 struct Scsi_Host *sh = ap->host;
4513
4514 DPRINTK("ENTER\n");
4515
4516 if (do_unregister)
4517 scsi_remove_host(sh);
4518
4519 ap->ops->port_stop(ap);
4520}
4521
4522/**
4523 * ata_host_init - Initialize an ata_port structure
4524 * @ap: Structure to initialize
4525 * @host: associated SCSI mid-layer structure
4526 * @host_set: Collection of hosts to which @ap belongs
4527 * @ent: Probe information provided by low-level driver
4528 * @port_no: Port number associated with this ata_port
4529 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004530 * Initialize a new ata_port structure, and its associated
4531 * scsi_host.
4532 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004533 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004534 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004535 */
4536
4537static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
4538 struct ata_host_set *host_set,
Jeff Garzik057ace52005-10-22 14:27:05 -04004539 const struct ata_probe_ent *ent, unsigned int port_no)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004540{
4541 unsigned int i;
4542
4543 host->max_id = 16;
4544 host->max_lun = 1;
4545 host->max_channel = 1;
4546 host->unique_id = ata_unique_id++;
4547 host->max_cmd_len = 12;
Christoph Hellwig12413192005-06-11 01:05:01 +02004548
Linus Torvalds1da177e2005-04-16 15:20:36 -07004549 ap->flags = ATA_FLAG_PORT_DISABLED;
4550 ap->id = host->unique_id;
4551 ap->host = host;
4552 ap->ctl = ATA_DEVCTL_OBS;
4553 ap->host_set = host_set;
Brian King2f1f6102006-03-23 17:30:15 -06004554 ap->dev = ent->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004555 ap->port_no = port_no;
4556 ap->hard_port_no =
4557 ent->legacy_mode ? ent->hard_port_no : port_no;
4558 ap->pio_mask = ent->pio_mask;
4559 ap->mwdma_mask = ent->mwdma_mask;
4560 ap->udma_mask = ent->udma_mask;
4561 ap->flags |= ent->host_flags;
4562 ap->ops = ent->port_ops;
4563 ap->cbl = ATA_CBL_NONE;
4564 ap->active_tag = ATA_TAG_POISON;
4565 ap->last_ctl = 0xFF;
4566
Tejun Heo86e45b62006-03-05 15:29:09 +09004567 INIT_WORK(&ap->port_task, NULL, NULL);
Tejun Heoa72ec4c2006-01-23 13:09:37 +09004568 INIT_LIST_HEAD(&ap->eh_done_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004569
Tejun Heoacf356b2006-03-24 14:07:50 +09004570 for (i = 0; i < ATA_MAX_DEVICES; i++) {
4571 struct ata_device *dev = &ap->device[i];
4572 dev->devno = i;
4573 dev->pio_mask = UINT_MAX;
4574 dev->mwdma_mask = UINT_MAX;
4575 dev->udma_mask = UINT_MAX;
4576 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004577
4578#ifdef ATA_IRQ_TRAP
4579 ap->stats.unhandled_irq = 1;
4580 ap->stats.idle_irq = 1;
4581#endif
4582
4583 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
4584}
4585
4586/**
4587 * ata_host_add - Attach low-level ATA driver to system
4588 * @ent: Information provided by low-level driver
4589 * @host_set: Collections of ports to which we add
4590 * @port_no: Port number associated with this host
4591 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004592 * Attach low-level ATA driver to system.
4593 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004594 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004595 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596 *
4597 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004598 * New ata_port on success, for NULL on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004599 */
4600
Jeff Garzik057ace52005-10-22 14:27:05 -04004601static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004602 struct ata_host_set *host_set,
4603 unsigned int port_no)
4604{
4605 struct Scsi_Host *host;
4606 struct ata_port *ap;
4607 int rc;
4608
4609 DPRINTK("ENTER\n");
Tejun Heoaec5c3c2006-03-25 01:33:34 +09004610
4611 if (!ent->port_ops->probe_reset &&
4612 !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
4613 printk(KERN_ERR "ata%u: no reset mechanism available\n",
4614 port_no);
4615 return NULL;
4616 }
4617
Linus Torvalds1da177e2005-04-16 15:20:36 -07004618 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
4619 if (!host)
4620 return NULL;
4621
Tejun Heo30afc842006-03-18 18:40:14 +09004622 host->transportt = &ata_scsi_transport_template;
4623
Linus Torvalds1da177e2005-04-16 15:20:36 -07004624 ap = (struct ata_port *) &host->hostdata[0];
4625
4626 ata_host_init(ap, host, host_set, ent, port_no);
4627
4628 rc = ap->ops->port_start(ap);
4629 if (rc)
4630 goto err_out;
4631
4632 return ap;
4633
4634err_out:
4635 scsi_host_put(host);
4636 return NULL;
4637}
4638
4639/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04004640 * ata_device_add - Register hardware device with ATA and SCSI layers
4641 * @ent: Probe information describing hardware device to be registered
4642 *
4643 * This function processes the information provided in the probe
4644 * information struct @ent, allocates the necessary ATA and SCSI
4645 * host information structures, initializes them, and registers
4646 * everything with requisite kernel subsystems.
4647 *
4648 * This function requests irqs, probes the ATA bus, and probes
4649 * the SCSI bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004650 *
4651 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004652 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004653 *
4654 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004655 * Number of ports registered. Zero on error (no ports registered).
Linus Torvalds1da177e2005-04-16 15:20:36 -07004656 */
4657
Jeff Garzik057ace52005-10-22 14:27:05 -04004658int ata_device_add(const struct ata_probe_ent *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004659{
4660 unsigned int count = 0, i;
4661 struct device *dev = ent->dev;
4662 struct ata_host_set *host_set;
4663
4664 DPRINTK("ENTER\n");
4665 /* alloc a container for our list of ATA ports (buses) */
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004666 host_set = kzalloc(sizeof(struct ata_host_set) +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004667 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
4668 if (!host_set)
4669 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004670 spin_lock_init(&host_set->lock);
4671
4672 host_set->dev = dev;
4673 host_set->n_ports = ent->n_ports;
4674 host_set->irq = ent->irq;
4675 host_set->mmio_base = ent->mmio_base;
4676 host_set->private_data = ent->private_data;
4677 host_set->ops = ent->port_ops;
4678
4679 /* register each port bound to this device */
4680 for (i = 0; i < ent->n_ports; i++) {
4681 struct ata_port *ap;
4682 unsigned long xfer_mode_mask;
4683
4684 ap = ata_host_add(ent, host_set, i);
4685 if (!ap)
4686 goto err_out;
4687
4688 host_set->ports[i] = ap;
4689 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
4690 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
4691 (ap->pio_mask << ATA_SHIFT_PIO);
4692
4693 /* print per-port info to dmesg */
4694 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
4695 "bmdma 0x%lX irq %lu\n",
4696 ap->id,
4697 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
4698 ata_mode_string(xfer_mode_mask),
4699 ap->ioaddr.cmd_addr,
4700 ap->ioaddr.ctl_addr,
4701 ap->ioaddr.bmdma_addr,
4702 ent->irq);
4703
4704 ata_chk_status(ap);
4705 host_set->ops->irq_clear(ap);
4706 count++;
4707 }
4708
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004709 if (!count)
4710 goto err_free_ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004711
4712 /* obtain irq, that is shared between channels */
4713 if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
4714 DRV_NAME, host_set))
4715 goto err_out;
4716
4717 /* perform each probe synchronously */
4718 DPRINTK("probe begin\n");
4719 for (i = 0; i < count; i++) {
4720 struct ata_port *ap;
4721 int rc;
4722
4723 ap = host_set->ports[i];
4724
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004725 DPRINTK("ata%u: bus probe begin\n", ap->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004726 rc = ata_bus_probe(ap);
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004727 DPRINTK("ata%u: bus probe end\n", ap->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004728
4729 if (rc) {
4730 /* FIXME: do something useful here?
4731 * Current libata behavior will
4732 * tear down everything when
4733 * the module is removed
4734 * or the h/w is unplugged.
4735 */
4736 }
4737
4738 rc = scsi_add_host(ap->host, dev);
4739 if (rc) {
4740 printk(KERN_ERR "ata%u: scsi_add_host failed\n",
4741 ap->id);
4742 /* FIXME: do something useful here */
4743 /* FIXME: handle unconditional calls to
4744 * scsi_scan_host and ata_host_remove, below,
4745 * at the very least
4746 */
4747 }
4748 }
4749
4750 /* probes are done, now scan each port's disk(s) */
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004751 DPRINTK("host probe begin\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004752 for (i = 0; i < count; i++) {
4753 struct ata_port *ap = host_set->ports[i];
4754
Jeff Garzik644dd0c2005-10-03 15:55:19 -04004755 ata_scsi_scan_host(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004756 }
4757
4758 dev_set_drvdata(dev, host_set);
4759
4760 VPRINTK("EXIT, returning %u\n", ent->n_ports);
4761 return ent->n_ports; /* success */
4762
4763err_out:
4764 for (i = 0; i < count; i++) {
4765 ata_host_remove(host_set->ports[i], 1);
4766 scsi_host_put(host_set->ports[i]->host);
4767 }
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004768err_free_ret:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004769 kfree(host_set);
4770 VPRINTK("EXIT, returning 0\n");
4771 return 0;
4772}
4773
4774/**
Alan Cox17b14452005-09-15 15:44:00 +01004775 * ata_host_set_remove - PCI layer callback for device removal
4776 * @host_set: ATA host set that was removed
4777 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05004778 * Unregister all objects associated with this host set. Free those
Alan Cox17b14452005-09-15 15:44:00 +01004779 * objects.
4780 *
4781 * LOCKING:
4782 * Inherited from calling layer (may sleep).
4783 */
4784
Alan Cox17b14452005-09-15 15:44:00 +01004785void ata_host_set_remove(struct ata_host_set *host_set)
4786{
4787 struct ata_port *ap;
4788 unsigned int i;
4789
4790 for (i = 0; i < host_set->n_ports; i++) {
4791 ap = host_set->ports[i];
4792 scsi_remove_host(ap->host);
4793 }
4794
4795 free_irq(host_set->irq, host_set);
4796
4797 for (i = 0; i < host_set->n_ports; i++) {
4798 ap = host_set->ports[i];
4799
4800 ata_scsi_release(ap->host);
4801
4802 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
4803 struct ata_ioports *ioaddr = &ap->ioaddr;
4804
4805 if (ioaddr->cmd_addr == 0x1f0)
4806 release_region(0x1f0, 8);
4807 else if (ioaddr->cmd_addr == 0x170)
4808 release_region(0x170, 8);
4809 }
4810
4811 scsi_host_put(ap->host);
4812 }
4813
4814 if (host_set->ops->host_stop)
4815 host_set->ops->host_stop(host_set);
4816
4817 kfree(host_set);
4818}
4819
4820/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004821 * ata_scsi_release - SCSI layer callback hook for host unload
4822 * @host: libata host to be unloaded
4823 *
4824 * Performs all duties necessary to shut down a libata port...
4825 * Kill port kthread, disable port, and release resources.
4826 *
4827 * LOCKING:
4828 * Inherited from SCSI layer.
4829 *
4830 * RETURNS:
4831 * One.
4832 */
4833
4834int ata_scsi_release(struct Scsi_Host *host)
4835{
4836 struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
Tejun Heod9572b12006-03-01 16:09:35 +09004837 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004838
4839 DPRINTK("ENTER\n");
4840
4841 ap->ops->port_disable(ap);
4842 ata_host_remove(ap, 0);
Tejun Heod9572b12006-03-01 16:09:35 +09004843 for (i = 0; i < ATA_MAX_DEVICES; i++)
4844 kfree(ap->device[i].id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004845
4846 DPRINTK("EXIT\n");
4847 return 1;
4848}
4849
4850/**
4851 * ata_std_ports - initialize ioaddr with standard port offsets.
4852 * @ioaddr: IO address structure to be initialized
Edward Falk0baab862005-06-02 18:17:13 -04004853 *
4854 * Utility function which initializes data_addr, error_addr,
4855 * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
4856 * device_addr, status_addr, and command_addr to standard offsets
4857 * relative to cmd_addr.
4858 *
4859 * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004860 */
Edward Falk0baab862005-06-02 18:17:13 -04004861
Linus Torvalds1da177e2005-04-16 15:20:36 -07004862void ata_std_ports(struct ata_ioports *ioaddr)
4863{
4864 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
4865 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
4866 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
4867 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
4868 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
4869 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
4870 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
4871 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
4872 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
4873 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
4874}
4875
Edward Falk0baab862005-06-02 18:17:13 -04004876
Jeff Garzik374b1872005-08-30 05:42:52 -04004877#ifdef CONFIG_PCI
4878
4879void ata_pci_host_stop (struct ata_host_set *host_set)
4880{
4881 struct pci_dev *pdev = to_pci_dev(host_set->dev);
4882
4883 pci_iounmap(pdev, host_set->mmio_base);
4884}
4885
Edward Falk0baab862005-06-02 18:17:13 -04004886/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004887 * ata_pci_remove_one - PCI layer callback for device removal
4888 * @pdev: PCI device that was removed
4889 *
4890 * PCI layer indicates to libata via this hook that
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004891 * hot-unplug or module unload event has occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004892 * Handle this by unregistering all objects associated
4893 * with this PCI device. Free those objects. Then finally
4894 * release PCI resources and disable device.
4895 *
4896 * LOCKING:
4897 * Inherited from PCI layer (may sleep).
4898 */
4899
4900void ata_pci_remove_one (struct pci_dev *pdev)
4901{
4902 struct device *dev = pci_dev_to_dev(pdev);
4903 struct ata_host_set *host_set = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004904
Alan Cox17b14452005-09-15 15:44:00 +01004905 ata_host_set_remove(host_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004906 pci_release_regions(pdev);
4907 pci_disable_device(pdev);
4908 dev_set_drvdata(dev, NULL);
4909}
4910
4911/* move to PCI subsystem */
Jeff Garzik057ace52005-10-22 14:27:05 -04004912int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004913{
4914 unsigned long tmp = 0;
4915
4916 switch (bits->width) {
4917 case 1: {
4918 u8 tmp8 = 0;
4919 pci_read_config_byte(pdev, bits->reg, &tmp8);
4920 tmp = tmp8;
4921 break;
4922 }
4923 case 2: {
4924 u16 tmp16 = 0;
4925 pci_read_config_word(pdev, bits->reg, &tmp16);
4926 tmp = tmp16;
4927 break;
4928 }
4929 case 4: {
4930 u32 tmp32 = 0;
4931 pci_read_config_dword(pdev, bits->reg, &tmp32);
4932 tmp = tmp32;
4933 break;
4934 }
4935
4936 default:
4937 return -EINVAL;
4938 }
4939
4940 tmp &= bits->mask;
4941
4942 return (tmp == bits->val) ? 1 : 0;
4943}
Jens Axboe9b847542006-01-06 09:28:07 +01004944
4945int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state)
4946{
4947 pci_save_state(pdev);
4948 pci_disable_device(pdev);
4949 pci_set_power_state(pdev, PCI_D3hot);
4950 return 0;
4951}
4952
4953int ata_pci_device_resume(struct pci_dev *pdev)
4954{
4955 pci_set_power_state(pdev, PCI_D0);
4956 pci_restore_state(pdev);
4957 pci_enable_device(pdev);
4958 pci_set_master(pdev);
4959 return 0;
4960}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004961#endif /* CONFIG_PCI */
4962
4963
Linus Torvalds1da177e2005-04-16 15:20:36 -07004964static int __init ata_init(void)
4965{
4966 ata_wq = create_workqueue("ata");
4967 if (!ata_wq)
4968 return -ENOMEM;
4969
4970 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
4971 return 0;
4972}
4973
4974static void __exit ata_exit(void)
4975{
4976 destroy_workqueue(ata_wq);
4977}
4978
4979module_init(ata_init);
4980module_exit(ata_exit);
4981
Jeff Garzik67846b32005-10-05 02:58:32 -04004982static unsigned long ratelimit_time;
4983static spinlock_t ata_ratelimit_lock = SPIN_LOCK_UNLOCKED;
4984
4985int ata_ratelimit(void)
4986{
4987 int rc;
4988 unsigned long flags;
4989
4990 spin_lock_irqsave(&ata_ratelimit_lock, flags);
4991
4992 if (time_after(jiffies, ratelimit_time)) {
4993 rc = 1;
4994 ratelimit_time = jiffies + (HZ/5);
4995 } else
4996 rc = 0;
4997
4998 spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
4999
5000 return rc;
5001}
5002
Linus Torvalds1da177e2005-04-16 15:20:36 -07005003/*
5004 * libata is essentially a library of internal helper functions for
5005 * low-level ATA host controller drivers. As such, the API/ABI is
5006 * likely to change as new drivers are added and updated.
5007 * Do not depend on ABI/API stability.
5008 */
5009
5010EXPORT_SYMBOL_GPL(ata_std_bios_param);
5011EXPORT_SYMBOL_GPL(ata_std_ports);
5012EXPORT_SYMBOL_GPL(ata_device_add);
Alan Cox17b14452005-09-15 15:44:00 +01005013EXPORT_SYMBOL_GPL(ata_host_set_remove);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005014EXPORT_SYMBOL_GPL(ata_sg_init);
5015EXPORT_SYMBOL_GPL(ata_sg_init_one);
Tejun Heo76014422006-02-11 15:13:49 +09005016EXPORT_SYMBOL_GPL(__ata_qc_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005017EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
5018EXPORT_SYMBOL_GPL(ata_eng_timeout);
5019EXPORT_SYMBOL_GPL(ata_tf_load);
5020EXPORT_SYMBOL_GPL(ata_tf_read);
5021EXPORT_SYMBOL_GPL(ata_noop_dev_select);
5022EXPORT_SYMBOL_GPL(ata_std_dev_select);
5023EXPORT_SYMBOL_GPL(ata_tf_to_fis);
5024EXPORT_SYMBOL_GPL(ata_tf_from_fis);
5025EXPORT_SYMBOL_GPL(ata_check_status);
5026EXPORT_SYMBOL_GPL(ata_altstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005027EXPORT_SYMBOL_GPL(ata_exec_command);
5028EXPORT_SYMBOL_GPL(ata_port_start);
5029EXPORT_SYMBOL_GPL(ata_port_stop);
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04005030EXPORT_SYMBOL_GPL(ata_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005031EXPORT_SYMBOL_GPL(ata_interrupt);
5032EXPORT_SYMBOL_GPL(ata_qc_prep);
Brian Kinge46834c2006-03-17 17:04:03 -06005033EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005034EXPORT_SYMBOL_GPL(ata_bmdma_setup);
5035EXPORT_SYMBOL_GPL(ata_bmdma_start);
5036EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
5037EXPORT_SYMBOL_GPL(ata_bmdma_status);
5038EXPORT_SYMBOL_GPL(ata_bmdma_stop);
5039EXPORT_SYMBOL_GPL(ata_port_probe);
5040EXPORT_SYMBOL_GPL(sata_phy_reset);
5041EXPORT_SYMBOL_GPL(__sata_phy_reset);
5042EXPORT_SYMBOL_GPL(ata_bus_reset);
Tejun Heo8a19ac82006-02-02 18:20:00 +09005043EXPORT_SYMBOL_GPL(ata_std_probeinit);
Tejun Heoc2bd5802006-01-24 17:05:22 +09005044EXPORT_SYMBOL_GPL(ata_std_softreset);
5045EXPORT_SYMBOL_GPL(sata_std_hardreset);
5046EXPORT_SYMBOL_GPL(ata_std_postreset);
5047EXPORT_SYMBOL_GPL(ata_std_probe_reset);
Tejun Heoa62c0fc2006-01-24 17:05:22 +09005048EXPORT_SYMBOL_GPL(ata_drive_probe_reset);
Tejun Heo623a3122006-03-05 17:55:58 +09005049EXPORT_SYMBOL_GPL(ata_dev_revalidate);
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05005050EXPORT_SYMBOL_GPL(ata_dev_classify);
5051EXPORT_SYMBOL_GPL(ata_dev_pair);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005052EXPORT_SYMBOL_GPL(ata_port_disable);
Jeff Garzik67846b32005-10-05 02:58:32 -04005053EXPORT_SYMBOL_GPL(ata_ratelimit);
Tejun Heo6f8b9952006-01-24 17:05:21 +09005054EXPORT_SYMBOL_GPL(ata_busy_sleep);
Tejun Heo86e45b62006-03-05 15:29:09 +09005055EXPORT_SYMBOL_GPL(ata_port_queue_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005056EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
5057EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
5058EXPORT_SYMBOL_GPL(ata_scsi_error);
5059EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
5060EXPORT_SYMBOL_GPL(ata_scsi_release);
5061EXPORT_SYMBOL_GPL(ata_host_intr);
Tejun Heo6a62a042006-02-13 10:02:46 +09005062EXPORT_SYMBOL_GPL(ata_id_string);
5063EXPORT_SYMBOL_GPL(ata_id_c_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005064EXPORT_SYMBOL_GPL(ata_scsi_simulate);
Tejun Heoa72ec4c2006-01-23 13:09:37 +09005065EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
5066EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005067
Alan Cox1bc4ccf2006-01-09 17:18:14 +00005068EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
Alan Cox452503f2005-10-21 19:01:32 -04005069EXPORT_SYMBOL_GPL(ata_timing_compute);
5070EXPORT_SYMBOL_GPL(ata_timing_merge);
5071
Linus Torvalds1da177e2005-04-16 15:20:36 -07005072#ifdef CONFIG_PCI
5073EXPORT_SYMBOL_GPL(pci_test_config_bits);
Jeff Garzik374b1872005-08-30 05:42:52 -04005074EXPORT_SYMBOL_GPL(ata_pci_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005075EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
5076EXPORT_SYMBOL_GPL(ata_pci_init_one);
5077EXPORT_SYMBOL_GPL(ata_pci_remove_one);
Jens Axboe9b847542006-01-06 09:28:07 +01005078EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
5079EXPORT_SYMBOL_GPL(ata_pci_device_resume);
Alan Cox67951ad2006-03-22 15:55:54 +00005080EXPORT_SYMBOL_GPL(ata_pci_default_filter);
5081EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005082#endif /* CONFIG_PCI */
Jens Axboe9b847542006-01-06 09:28:07 +01005083
5084EXPORT_SYMBOL_GPL(ata_device_suspend);
5085EXPORT_SYMBOL_GPL(ata_device_resume);
5086EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
5087EXPORT_SYMBOL_GPL(ata_scsi_device_resume);