blob: 186a9ce4f072f3b3ccaae3a46fb319339742e11a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jeff Garzikaf36d7f2005-08-28 20:18:39 -04002 * libata-core.c - helper library for ATA
3 *
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
9 * Copyright 2003-2004 Jeff Garzik
10 *
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 *
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
29 *
30 * Hardware documentation available from http://www.t13.org/ and
31 * http://www.sata-io.org/
32 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 */
34
35#include <linux/config.h>
36#include <linux/kernel.h>
37#include <linux/module.h>
38#include <linux/pci.h>
39#include <linux/init.h>
40#include <linux/list.h>
41#include <linux/mm.h>
42#include <linux/highmem.h>
43#include <linux/spinlock.h>
44#include <linux/blkdev.h>
45#include <linux/delay.h>
46#include <linux/timer.h>
47#include <linux/interrupt.h>
48#include <linux/completion.h>
49#include <linux/suspend.h>
50#include <linux/workqueue.h>
Jeff Garzik67846b32005-10-05 02:58:32 -040051#include <linux/jiffies.h>
David Hardeman378f0582005-09-17 17:55:31 +100052#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <scsi/scsi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include "scsi_priv.h"
Jeff Garzik193515d2005-11-07 00:59:37 -050055#include <scsi/scsi_cmnd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <scsi/scsi_host.h>
57#include <linux/libata.h>
58#include <asm/io.h>
59#include <asm/semaphore.h>
60#include <asm/byteorder.h>
61
62#include "libata.h"
63
Tejun Heo6aff8f12006-02-15 18:24:09 +090064static unsigned int ata_dev_init_params(struct ata_port *ap,
Albert Lee00b6f5e2006-03-27 16:39:18 +080065 struct ata_device *dev,
66 u16 heads,
67 u16 sectors);
Tejun Heocf176e12006-04-02 17:54:46 +090068static int ata_down_xfermask_limit(struct ata_port *ap, struct ata_device *dev,
69 int force_pio0);
Tejun Heo1c3fae42006-04-02 20:53:28 +090070static int ata_down_sata_spd_limit(struct ata_port *ap);
Tejun Heoe82cbdb2006-04-01 01:38:18 +090071static int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev);
Tejun Heo83206a22006-03-24 15:25:31 +090072static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
73 struct ata_device *dev);
Tejun Heoacf356b2006-03-24 14:07:50 +090074static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76static unsigned int ata_unique_id = 1;
77static struct workqueue_struct *ata_wq;
78
Jeff Garzik418dc1f2006-03-11 20:50:08 -050079int atapi_enabled = 1;
Jeff Garzik1623c812005-08-30 03:37:42 -040080module_param(atapi_enabled, int, 0444);
81MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
82
Jeff Garzikc3c013a2006-02-27 22:31:19 -050083int libata_fua = 0;
84module_param_named(fua, libata_fua, int, 0444);
85MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
86
Linus Torvalds1da177e2005-04-16 15:20:36 -070087MODULE_AUTHOR("Jeff Garzik");
88MODULE_DESCRIPTION("Library module for ATA devices");
89MODULE_LICENSE("GPL");
90MODULE_VERSION(DRV_VERSION);
91
Edward Falk0baab862005-06-02 18:17:13 -040092
93/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
95 * @tf: Taskfile to convert
96 * @fis: Buffer into which data will output
97 * @pmp: Port multiplier port
98 *
99 * Converts a standard ATA taskfile to a Serial ATA
100 * FIS structure (Register - Host to Device).
101 *
102 * LOCKING:
103 * Inherited from caller.
104 */
105
Jeff Garzik057ace52005-10-22 14:27:05 -0400106void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
108 fis[0] = 0x27; /* Register - Host to Device FIS */
109 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
110 bit 7 indicates Command FIS */
111 fis[2] = tf->command;
112 fis[3] = tf->feature;
113
114 fis[4] = tf->lbal;
115 fis[5] = tf->lbam;
116 fis[6] = tf->lbah;
117 fis[7] = tf->device;
118
119 fis[8] = tf->hob_lbal;
120 fis[9] = tf->hob_lbam;
121 fis[10] = tf->hob_lbah;
122 fis[11] = tf->hob_feature;
123
124 fis[12] = tf->nsect;
125 fis[13] = tf->hob_nsect;
126 fis[14] = 0;
127 fis[15] = tf->ctl;
128
129 fis[16] = 0;
130 fis[17] = 0;
131 fis[18] = 0;
132 fis[19] = 0;
133}
134
135/**
136 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
137 * @fis: Buffer from which data will be input
138 * @tf: Taskfile to output
139 *
Mark Lorde12a1be2005-11-12 18:55:45 -0500140 * Converts a serial ATA FIS structure to a standard ATA taskfile.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 *
142 * LOCKING:
143 * Inherited from caller.
144 */
145
Jeff Garzik057ace52005-10-22 14:27:05 -0400146void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
148 tf->command = fis[2]; /* status */
149 tf->feature = fis[3]; /* error */
150
151 tf->lbal = fis[4];
152 tf->lbam = fis[5];
153 tf->lbah = fis[6];
154 tf->device = fis[7];
155
156 tf->hob_lbal = fis[8];
157 tf->hob_lbam = fis[9];
158 tf->hob_lbah = fis[10];
159
160 tf->nsect = fis[12];
161 tf->hob_nsect = fis[13];
162}
163
Albert Lee8cbd6df2005-10-12 15:06:27 +0800164static const u8 ata_rw_cmds[] = {
165 /* pio multi */
166 ATA_CMD_READ_MULTI,
167 ATA_CMD_WRITE_MULTI,
168 ATA_CMD_READ_MULTI_EXT,
169 ATA_CMD_WRITE_MULTI_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100170 0,
171 0,
172 0,
173 ATA_CMD_WRITE_MULTI_FUA_EXT,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800174 /* pio */
175 ATA_CMD_PIO_READ,
176 ATA_CMD_PIO_WRITE,
177 ATA_CMD_PIO_READ_EXT,
178 ATA_CMD_PIO_WRITE_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100179 0,
180 0,
181 0,
182 0,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800183 /* dma */
184 ATA_CMD_READ,
185 ATA_CMD_WRITE,
186 ATA_CMD_READ_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100187 ATA_CMD_WRITE_EXT,
188 0,
189 0,
190 0,
191 ATA_CMD_WRITE_FUA_EXT
Albert Lee8cbd6df2005-10-12 15:06:27 +0800192};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
194/**
Albert Lee8cbd6df2005-10-12 15:06:27 +0800195 * ata_rwcmd_protocol - set taskfile r/w commands and protocol
196 * @qc: command to examine and configure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500198 * Examine the device configuration and tf->flags to calculate
Albert Lee8cbd6df2005-10-12 15:06:27 +0800199 * the proper read/write commands and protocol to use.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 *
201 * LOCKING:
202 * caller.
203 */
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100204int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Albert Lee8cbd6df2005-10-12 15:06:27 +0800206 struct ata_taskfile *tf = &qc->tf;
207 struct ata_device *dev = qc->dev;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100208 u8 cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100210 int index, fua, lba48, write;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500211
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100212 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800213 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
214 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Albert Lee8cbd6df2005-10-12 15:06:27 +0800216 if (dev->flags & ATA_DFLAG_PIO) {
217 tf->protocol = ATA_PROT_PIO;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100218 index = dev->multi_count ? 0 : 8;
Alan Cox8d238e02006-01-17 20:50:31 +0000219 } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
220 /* Unable to use DMA due to host limitation */
221 tf->protocol = ATA_PROT_PIO;
Albert Lee0565c262006-02-13 18:55:25 +0800222 index = dev->multi_count ? 0 : 8;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800223 } else {
224 tf->protocol = ATA_PROT_DMA;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100225 index = 16;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100228 cmd = ata_rw_cmds[index + fua + lba48 + write];
229 if (cmd) {
230 tf->command = cmd;
231 return 0;
232 }
233 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
Tejun Heocb95d562006-03-06 04:31:56 +0900236/**
237 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
238 * @pio_mask: pio_mask
239 * @mwdma_mask: mwdma_mask
240 * @udma_mask: udma_mask
241 *
242 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
243 * unsigned int xfer_mask.
244 *
245 * LOCKING:
246 * None.
247 *
248 * RETURNS:
249 * Packed xfer_mask.
250 */
251static unsigned int ata_pack_xfermask(unsigned int pio_mask,
252 unsigned int mwdma_mask,
253 unsigned int udma_mask)
254{
255 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
256 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
257 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
258}
259
Tejun Heoc0489e42006-03-24 14:07:49 +0900260/**
261 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
262 * @xfer_mask: xfer_mask to unpack
263 * @pio_mask: resulting pio_mask
264 * @mwdma_mask: resulting mwdma_mask
265 * @udma_mask: resulting udma_mask
266 *
267 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
268 * Any NULL distination masks will be ignored.
269 */
270static void ata_unpack_xfermask(unsigned int xfer_mask,
271 unsigned int *pio_mask,
272 unsigned int *mwdma_mask,
273 unsigned int *udma_mask)
274{
275 if (pio_mask)
276 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
277 if (mwdma_mask)
278 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
279 if (udma_mask)
280 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
281}
282
Tejun Heocb95d562006-03-06 04:31:56 +0900283static const struct ata_xfer_ent {
Tejun Heobe9a50c2006-03-31 22:48:52 +0900284 int shift, bits;
Tejun Heocb95d562006-03-06 04:31:56 +0900285 u8 base;
286} ata_xfer_tbl[] = {
287 { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
288 { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
289 { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
290 { -1, },
291};
292
293/**
294 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
295 * @xfer_mask: xfer_mask of interest
296 *
297 * Return matching XFER_* value for @xfer_mask. Only the highest
298 * bit of @xfer_mask is considered.
299 *
300 * LOCKING:
301 * None.
302 *
303 * RETURNS:
304 * Matching XFER_* value, 0 if no match found.
305 */
306static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
307{
308 int highbit = fls(xfer_mask) - 1;
309 const struct ata_xfer_ent *ent;
310
311 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
312 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
313 return ent->base + highbit - ent->shift;
314 return 0;
315}
316
317/**
318 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
319 * @xfer_mode: XFER_* of interest
320 *
321 * Return matching xfer_mask for @xfer_mode.
322 *
323 * LOCKING:
324 * None.
325 *
326 * RETURNS:
327 * Matching xfer_mask, 0 if no match found.
328 */
329static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
330{
331 const struct ata_xfer_ent *ent;
332
333 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
334 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
335 return 1 << (ent->shift + xfer_mode - ent->base);
336 return 0;
337}
338
339/**
340 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
341 * @xfer_mode: XFER_* of interest
342 *
343 * Return matching xfer_shift for @xfer_mode.
344 *
345 * LOCKING:
346 * None.
347 *
348 * RETURNS:
349 * Matching xfer_shift, -1 if no match found.
350 */
351static int ata_xfer_mode2shift(unsigned int xfer_mode)
352{
353 const struct ata_xfer_ent *ent;
354
355 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
356 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
357 return ent->shift;
358 return -1;
359}
360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361/**
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900362 * ata_mode_string - convert xfer_mask to string
363 * @xfer_mask: mask of bits supported; only highest bit counts.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 *
365 * Determine string which represents the highest speed
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900366 * (highest bit in @modemask).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 *
368 * LOCKING:
369 * None.
370 *
371 * RETURNS:
372 * Constant C string representing highest speed listed in
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900373 * @mode_mask, or the constant C string "<n/a>".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 */
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900375static const char *ata_mode_string(unsigned int xfer_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376{
Tejun Heo75f554b2006-03-06 04:31:57 +0900377 static const char * const xfer_mode_str[] = {
378 "PIO0",
379 "PIO1",
380 "PIO2",
381 "PIO3",
382 "PIO4",
383 "MWDMA0",
384 "MWDMA1",
385 "MWDMA2",
386 "UDMA/16",
387 "UDMA/25",
388 "UDMA/33",
389 "UDMA/44",
390 "UDMA/66",
391 "UDMA/100",
392 "UDMA/133",
393 "UDMA7",
394 };
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900395 int highbit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900397 highbit = fls(xfer_mask) - 1;
398 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
399 return xfer_mode_str[highbit];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 return "<n/a>";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401}
402
Tejun Heo4c360c82006-04-01 01:38:17 +0900403static const char *sata_spd_string(unsigned int spd)
404{
405 static const char * const spd_str[] = {
406 "1.5 Gbps",
407 "3.0 Gbps",
408 };
409
410 if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
411 return "<unknown>";
412 return spd_str[spd - 1];
413}
414
Tejun Heo0b8efb02006-03-24 15:25:31 +0900415static void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
416{
Tejun Heoe1211e32006-04-01 01:38:18 +0900417 if (ata_dev_enabled(dev)) {
Tejun Heo0b8efb02006-03-24 15:25:31 +0900418 printk(KERN_WARNING "ata%u: dev %u disabled\n",
419 ap->id, dev->devno);
420 dev->class++;
421 }
422}
423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424/**
425 * ata_pio_devchk - PATA device presence detection
426 * @ap: ATA channel to examine
427 * @device: Device to examine (starting at zero)
428 *
429 * This technique was originally described in
430 * Hale Landis's ATADRVR (www.ata-atapi.com), and
431 * later found its way into the ATA/ATAPI spec.
432 *
433 * Write a pattern to the ATA shadow registers,
434 * and if a device is present, it will respond by
435 * correctly storing and echoing back the
436 * ATA shadow register contents.
437 *
438 * LOCKING:
439 * caller.
440 */
441
442static unsigned int ata_pio_devchk(struct ata_port *ap,
443 unsigned int device)
444{
445 struct ata_ioports *ioaddr = &ap->ioaddr;
446 u8 nsect, lbal;
447
448 ap->ops->dev_select(ap, device);
449
450 outb(0x55, ioaddr->nsect_addr);
451 outb(0xaa, ioaddr->lbal_addr);
452
453 outb(0xaa, ioaddr->nsect_addr);
454 outb(0x55, ioaddr->lbal_addr);
455
456 outb(0x55, ioaddr->nsect_addr);
457 outb(0xaa, ioaddr->lbal_addr);
458
459 nsect = inb(ioaddr->nsect_addr);
460 lbal = inb(ioaddr->lbal_addr);
461
462 if ((nsect == 0x55) && (lbal == 0xaa))
463 return 1; /* we found a device */
464
465 return 0; /* nothing found */
466}
467
468/**
469 * ata_mmio_devchk - PATA device presence detection
470 * @ap: ATA channel to examine
471 * @device: Device to examine (starting at zero)
472 *
473 * This technique was originally described in
474 * Hale Landis's ATADRVR (www.ata-atapi.com), and
475 * later found its way into the ATA/ATAPI spec.
476 *
477 * Write a pattern to the ATA shadow registers,
478 * and if a device is present, it will respond by
479 * correctly storing and echoing back the
480 * ATA shadow register contents.
481 *
482 * LOCKING:
483 * caller.
484 */
485
486static unsigned int ata_mmio_devchk(struct ata_port *ap,
487 unsigned int device)
488{
489 struct ata_ioports *ioaddr = &ap->ioaddr;
490 u8 nsect, lbal;
491
492 ap->ops->dev_select(ap, device);
493
494 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
495 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
496
497 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
498 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
499
500 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
501 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
502
503 nsect = readb((void __iomem *) ioaddr->nsect_addr);
504 lbal = readb((void __iomem *) ioaddr->lbal_addr);
505
506 if ((nsect == 0x55) && (lbal == 0xaa))
507 return 1; /* we found a device */
508
509 return 0; /* nothing found */
510}
511
512/**
513 * ata_devchk - PATA device presence detection
514 * @ap: ATA channel to examine
515 * @device: Device to examine (starting at zero)
516 *
517 * Dispatch ATA device presence detection, depending
518 * on whether we are using PIO or MMIO to talk to the
519 * ATA shadow registers.
520 *
521 * LOCKING:
522 * caller.
523 */
524
525static unsigned int ata_devchk(struct ata_port *ap,
526 unsigned int device)
527{
528 if (ap->flags & ATA_FLAG_MMIO)
529 return ata_mmio_devchk(ap, device);
530 return ata_pio_devchk(ap, device);
531}
532
533/**
534 * ata_dev_classify - determine device type based on ATA-spec signature
535 * @tf: ATA taskfile register set for device to be identified
536 *
537 * Determine from taskfile register contents whether a device is
538 * ATA or ATAPI, as per "Signature and persistence" section
539 * of ATA/PI spec (volume 1, sect 5.14).
540 *
541 * LOCKING:
542 * None.
543 *
544 * RETURNS:
545 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
546 * the event of failure.
547 */
548
Jeff Garzik057ace52005-10-22 14:27:05 -0400549unsigned int ata_dev_classify(const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
551 /* Apple's open source Darwin code hints that some devices only
552 * put a proper signature into the LBA mid/high registers,
553 * So, we only check those. It's sufficient for uniqueness.
554 */
555
556 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
557 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
558 DPRINTK("found ATA device by sig\n");
559 return ATA_DEV_ATA;
560 }
561
562 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
563 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
564 DPRINTK("found ATAPI device by sig\n");
565 return ATA_DEV_ATAPI;
566 }
567
568 DPRINTK("unknown device\n");
569 return ATA_DEV_UNKNOWN;
570}
571
572/**
573 * ata_dev_try_classify - Parse returned ATA device signature
574 * @ap: ATA channel to examine
575 * @device: Device to examine (starting at zero)
Tejun Heob4dc7622006-01-24 17:05:22 +0900576 * @r_err: Value of error register on completion
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 *
578 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
579 * an ATA/ATAPI-defined set of values is placed in the ATA
580 * shadow registers, indicating the results of device detection
581 * and diagnostics.
582 *
583 * Select the ATA device, and read the values from the ATA shadow
584 * registers. Then parse according to the Error register value,
585 * and the spec-defined values examined by ata_dev_classify().
586 *
587 * LOCKING:
588 * caller.
Tejun Heob4dc7622006-01-24 17:05:22 +0900589 *
590 * RETURNS:
591 * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 */
593
Tejun Heob4dc7622006-01-24 17:05:22 +0900594static unsigned int
595ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 struct ata_taskfile tf;
598 unsigned int class;
599 u8 err;
600
601 ap->ops->dev_select(ap, device);
602
603 memset(&tf, 0, sizeof(tf));
604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 ap->ops->tf_read(ap, &tf);
Jeff Garzik0169e282005-10-29 21:25:10 -0400606 err = tf.feature;
Tejun Heob4dc7622006-01-24 17:05:22 +0900607 if (r_err)
608 *r_err = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
610 /* see if device passed diags */
611 if (err == 1)
612 /* do nothing */ ;
613 else if ((device == 0) && (err == 0x81))
614 /* do nothing */ ;
615 else
Tejun Heob4dc7622006-01-24 17:05:22 +0900616 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Tejun Heob4dc7622006-01-24 17:05:22 +0900618 /* determine if device is ATA or ATAPI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 class = ata_dev_classify(&tf);
Tejun Heob4dc7622006-01-24 17:05:22 +0900620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 if (class == ATA_DEV_UNKNOWN)
Tejun Heob4dc7622006-01-24 17:05:22 +0900622 return ATA_DEV_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
Tejun Heob4dc7622006-01-24 17:05:22 +0900624 return ATA_DEV_NONE;
625 return class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626}
627
628/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900629 * ata_id_string - Convert IDENTIFY DEVICE page into string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 * @id: IDENTIFY DEVICE results we will examine
631 * @s: string into which data is output
632 * @ofs: offset into identify device page
633 * @len: length of string to return. must be an even number.
634 *
635 * The strings in the IDENTIFY DEVICE page are broken up into
636 * 16-bit chunks. Run through the string, and output each
637 * 8-bit chunk linearly, regardless of platform.
638 *
639 * LOCKING:
640 * caller.
641 */
642
Tejun Heo6a62a042006-02-13 10:02:46 +0900643void ata_id_string(const u16 *id, unsigned char *s,
644 unsigned int ofs, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645{
646 unsigned int c;
647
648 while (len > 0) {
649 c = id[ofs] >> 8;
650 *s = c;
651 s++;
652
653 c = id[ofs] & 0xff;
654 *s = c;
655 s++;
656
657 ofs++;
658 len -= 2;
659 }
660}
661
Tejun Heo0e949ff2006-02-12 22:47:04 +0900662/**
Tejun Heo6a62a042006-02-13 10:02:46 +0900663 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
Tejun Heo0e949ff2006-02-12 22:47:04 +0900664 * @id: IDENTIFY DEVICE results we will examine
665 * @s: string into which data is output
666 * @ofs: offset into identify device page
667 * @len: length of string to return. must be an odd number.
668 *
Tejun Heo6a62a042006-02-13 10:02:46 +0900669 * This function is identical to ata_id_string except that it
Tejun Heo0e949ff2006-02-12 22:47:04 +0900670 * trims trailing spaces and terminates the resulting string with
671 * null. @len must be actual maximum length (even number) + 1.
672 *
673 * LOCKING:
674 * caller.
675 */
Tejun Heo6a62a042006-02-13 10:02:46 +0900676void ata_id_c_string(const u16 *id, unsigned char *s,
677 unsigned int ofs, unsigned int len)
Tejun Heo0e949ff2006-02-12 22:47:04 +0900678{
679 unsigned char *p;
680
681 WARN_ON(!(len & 1));
682
Tejun Heo6a62a042006-02-13 10:02:46 +0900683 ata_id_string(id, s, ofs, len - 1);
Tejun Heo0e949ff2006-02-12 22:47:04 +0900684
685 p = s + strnlen(s, len - 1);
686 while (p > s && p[-1] == ' ')
687 p--;
688 *p = '\0';
689}
Edward Falk0baab862005-06-02 18:17:13 -0400690
Tejun Heo29407402006-02-12 22:47:04 +0900691static u64 ata_id_n_sectors(const u16 *id)
692{
693 if (ata_id_has_lba(id)) {
694 if (ata_id_has_lba48(id))
695 return ata_id_u64(id, 100);
696 else
697 return ata_id_u32(id, 60);
698 } else {
699 if (ata_id_current_chs_valid(id))
700 return ata_id_u32(id, 57);
701 else
702 return id[1] * id[3] * id[6];
703 }
704}
705
Edward Falk0baab862005-06-02 18:17:13 -0400706/**
707 * ata_noop_dev_select - Select device 0/1 on ATA bus
708 * @ap: ATA channel to manipulate
709 * @device: ATA device (numbered from zero) to select
710 *
711 * This function performs no actual function.
712 *
713 * May be used as the dev_select() entry in ata_port_operations.
714 *
715 * LOCKING:
716 * caller.
717 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
719{
720}
721
Edward Falk0baab862005-06-02 18:17:13 -0400722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723/**
724 * ata_std_dev_select - Select device 0/1 on ATA bus
725 * @ap: ATA channel to manipulate
726 * @device: ATA device (numbered from zero) to select
727 *
728 * Use the method defined in the ATA specification to
729 * make either device 0, or device 1, active on the
Edward Falk0baab862005-06-02 18:17:13 -0400730 * ATA channel. Works with both PIO and MMIO.
731 *
732 * May be used as the dev_select() entry in ata_port_operations.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 *
734 * LOCKING:
735 * caller.
736 */
737
738void ata_std_dev_select (struct ata_port *ap, unsigned int device)
739{
740 u8 tmp;
741
742 if (device == 0)
743 tmp = ATA_DEVICE_OBS;
744 else
745 tmp = ATA_DEVICE_OBS | ATA_DEV1;
746
747 if (ap->flags & ATA_FLAG_MMIO) {
748 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
749 } else {
750 outb(tmp, ap->ioaddr.device_addr);
751 }
752 ata_pause(ap); /* needed; also flushes, for mmio */
753}
754
755/**
756 * ata_dev_select - Select device 0/1 on ATA bus
757 * @ap: ATA channel to manipulate
758 * @device: ATA device (numbered from zero) to select
759 * @wait: non-zero to wait for Status register BSY bit to clear
760 * @can_sleep: non-zero if context allows sleeping
761 *
762 * Use the method defined in the ATA specification to
763 * make either device 0, or device 1, active on the
764 * ATA channel.
765 *
766 * This is a high-level version of ata_std_dev_select(),
767 * which additionally provides the services of inserting
768 * the proper pauses and status polling, where needed.
769 *
770 * LOCKING:
771 * caller.
772 */
773
774void ata_dev_select(struct ata_port *ap, unsigned int device,
775 unsigned int wait, unsigned int can_sleep)
776{
777 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
778 ap->id, device, wait);
779
780 if (wait)
781 ata_wait_idle(ap);
782
783 ap->ops->dev_select(ap, device);
784
785 if (wait) {
786 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
787 msleep(150);
788 ata_wait_idle(ap);
789 }
790}
791
792/**
793 * ata_dump_id - IDENTIFY DEVICE info debugging output
Tejun Heo0bd33002006-02-12 22:47:05 +0900794 * @id: IDENTIFY DEVICE page to dump
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 *
Tejun Heo0bd33002006-02-12 22:47:05 +0900796 * Dump selected 16-bit words from the given IDENTIFY DEVICE
797 * page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 *
799 * LOCKING:
800 * caller.
801 */
802
Tejun Heo0bd33002006-02-12 22:47:05 +0900803static inline void ata_dump_id(const u16 *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804{
805 DPRINTK("49==0x%04x "
806 "53==0x%04x "
807 "63==0x%04x "
808 "64==0x%04x "
809 "75==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900810 id[49],
811 id[53],
812 id[63],
813 id[64],
814 id[75]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 DPRINTK("80==0x%04x "
816 "81==0x%04x "
817 "82==0x%04x "
818 "83==0x%04x "
819 "84==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900820 id[80],
821 id[81],
822 id[82],
823 id[83],
824 id[84]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 DPRINTK("88==0x%04x "
826 "93==0x%04x\n",
Tejun Heo0bd33002006-02-12 22:47:05 +0900827 id[88],
828 id[93]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
Tejun Heocb95d562006-03-06 04:31:56 +0900831/**
832 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
833 * @id: IDENTIFY data to compute xfer mask from
834 *
835 * Compute the xfermask for this device. This is not as trivial
836 * as it seems if we must consider early devices correctly.
837 *
838 * FIXME: pre IDE drive timing (do we care ?).
839 *
840 * LOCKING:
841 * None.
842 *
843 * RETURNS:
844 * Computed xfermask
845 */
846static unsigned int ata_id_xfermask(const u16 *id)
847{
848 unsigned int pio_mask, mwdma_mask, udma_mask;
849
850 /* Usual case. Word 53 indicates word 64 is valid */
851 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
852 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
853 pio_mask <<= 3;
854 pio_mask |= 0x7;
855 } else {
856 /* If word 64 isn't valid then Word 51 high byte holds
857 * the PIO timing number for the maximum. Turn it into
858 * a mask.
859 */
860 pio_mask = (2 << (id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
861
862 /* But wait.. there's more. Design your standards by
863 * committee and you too can get a free iordy field to
864 * process. However its the speeds not the modes that
865 * are supported... Note drivers using the timing API
866 * will get this right anyway
867 */
868 }
869
870 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
Tejun Heofb21f0d2006-03-12 12:34:35 +0900871
872 udma_mask = 0;
873 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
874 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
Tejun Heocb95d562006-03-06 04:31:56 +0900875
876 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
877}
878
Tejun Heo86e45b62006-03-05 15:29:09 +0900879/**
880 * ata_port_queue_task - Queue port_task
881 * @ap: The ata_port to queue port_task for
882 *
883 * Schedule @fn(@data) for execution after @delay jiffies using
884 * port_task. There is one port_task per port and it's the
885 * user(low level driver)'s responsibility to make sure that only
886 * one task is active at any given time.
887 *
888 * libata core layer takes care of synchronization between
889 * port_task and EH. ata_port_queue_task() may be ignored for EH
890 * synchronization.
891 *
892 * LOCKING:
893 * Inherited from caller.
894 */
895void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *), void *data,
896 unsigned long delay)
897{
898 int rc;
899
Tejun Heo2e755f62006-03-05 15:29:09 +0900900 if (ap->flags & ATA_FLAG_FLUSH_PORT_TASK)
Tejun Heo86e45b62006-03-05 15:29:09 +0900901 return;
902
903 PREPARE_WORK(&ap->port_task, fn, data);
904
905 if (!delay)
906 rc = queue_work(ata_wq, &ap->port_task);
907 else
908 rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
909
910 /* rc == 0 means that another user is using port task */
911 WARN_ON(rc == 0);
912}
913
914/**
915 * ata_port_flush_task - Flush port_task
916 * @ap: The ata_port to flush port_task for
917 *
918 * After this function completes, port_task is guranteed not to
919 * be running or scheduled.
920 *
921 * LOCKING:
922 * Kernel thread context (may sleep)
923 */
924void ata_port_flush_task(struct ata_port *ap)
925{
926 unsigned long flags;
927
928 DPRINTK("ENTER\n");
929
930 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900931 ap->flags |= ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heo86e45b62006-03-05 15:29:09 +0900932 spin_unlock_irqrestore(&ap->host_set->lock, flags);
933
934 DPRINTK("flush #1\n");
935 flush_workqueue(ata_wq);
936
937 /*
938 * At this point, if a task is running, it's guaranteed to see
939 * the FLUSH flag; thus, it will never queue pio tasks again.
940 * Cancel and flush.
941 */
942 if (!cancel_delayed_work(&ap->port_task)) {
943 DPRINTK("flush #2\n");
944 flush_workqueue(ata_wq);
945 }
946
947 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo2e755f62006-03-05 15:29:09 +0900948 ap->flags &= ~ATA_FLAG_FLUSH_PORT_TASK;
Tejun Heo86e45b62006-03-05 15:29:09 +0900949 spin_unlock_irqrestore(&ap->host_set->lock, flags);
950
951 DPRINTK("EXIT\n");
952}
953
Tejun Heo77853bf2006-01-23 13:09:36 +0900954void ata_qc_complete_internal(struct ata_queued_cmd *qc)
Tejun Heoa2a7a662005-12-13 14:48:31 +0900955{
Tejun Heo77853bf2006-01-23 13:09:36 +0900956 struct completion *waiting = qc->private_data;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900957
Tejun Heo77853bf2006-01-23 13:09:36 +0900958 qc->ap->ops->tf_read(qc->ap, &qc->tf);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900959 complete(waiting);
Tejun Heoa2a7a662005-12-13 14:48:31 +0900960}
961
962/**
963 * ata_exec_internal - execute libata internal command
964 * @ap: Port to which the command is sent
965 * @dev: Device to which the command is sent
966 * @tf: Taskfile registers for the command and the result
Tejun Heod69cf372006-04-02 18:51:53 +0900967 * @cdb: CDB for packet command
Tejun Heoa2a7a662005-12-13 14:48:31 +0900968 * @dma_dir: Data tranfer direction of the command
969 * @buf: Data buffer of the command
970 * @buflen: Length of data buffer
971 *
972 * Executes libata internal command with timeout. @tf contains
973 * command on entry and result on return. Timeout and error
974 * conditions are reported via return value. No recovery action
975 * is taken after a command times out. It's caller's duty to
976 * clean up after timeout.
977 *
978 * LOCKING:
979 * None. Should be called with kernel context, might sleep.
980 */
981
982static unsigned
983ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
Tejun Heod69cf372006-04-02 18:51:53 +0900984 struct ata_taskfile *tf, const u8 *cdb,
Tejun Heoa2a7a662005-12-13 14:48:31 +0900985 int dma_dir, void *buf, unsigned int buflen)
986{
987 u8 command = tf->command;
988 struct ata_queued_cmd *qc;
989 DECLARE_COMPLETION(wait);
990 unsigned long flags;
Tejun Heo77853bf2006-01-23 13:09:36 +0900991 unsigned int err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +0900992
993 spin_lock_irqsave(&ap->host_set->lock, flags);
994
995 qc = ata_qc_new_init(ap, dev);
996 BUG_ON(qc == NULL);
997
998 qc->tf = *tf;
Tejun Heod69cf372006-04-02 18:51:53 +0900999 if (cdb)
1000 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001001 qc->dma_dir = dma_dir;
1002 if (dma_dir != DMA_NONE) {
1003 ata_sg_init_one(qc, buf, buflen);
1004 qc->nsect = buflen / ATA_SECT_SIZE;
1005 }
1006
Tejun Heo77853bf2006-01-23 13:09:36 +09001007 qc->private_data = &wait;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001008 qc->complete_fn = ata_qc_complete_internal;
1009
Tejun Heo8e0e6942006-03-31 20:41:11 +09001010 ata_qc_issue(qc);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001011
1012 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1013
1014 if (!wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL)) {
Albert Lee41ade502006-03-14 11:19:04 +08001015 ata_port_flush_task(ap);
1016
Tejun Heoa2a7a662005-12-13 14:48:31 +09001017 spin_lock_irqsave(&ap->host_set->lock, flags);
1018
1019 /* We're racing with irq here. If we lose, the
1020 * following test prevents us from completing the qc
1021 * again. If completion irq occurs after here but
1022 * before the caller cleans up, it will result in a
1023 * spurious interrupt. We can live with that.
1024 */
Tejun Heo77853bf2006-01-23 13:09:36 +09001025 if (qc->flags & ATA_QCFLAG_ACTIVE) {
Tejun Heo11a56d22006-01-23 13:09:36 +09001026 qc->err_mask = AC_ERR_TIMEOUT;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001027 ata_qc_complete(qc);
1028 printk(KERN_WARNING "ata%u: qc timeout (cmd 0x%x)\n",
1029 ap->id, command);
1030 }
1031
1032 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1033 }
1034
Tejun Heo77853bf2006-01-23 13:09:36 +09001035 *tf = qc->tf;
1036 err_mask = qc->err_mask;
1037
1038 ata_qc_free(qc);
1039
Tejun Heo1f7dd3e92006-03-24 15:25:30 +09001040 /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1041 * Until those drivers are fixed, we detect the condition
1042 * here, fail the command with AC_ERR_SYSTEM and reenable the
1043 * port.
1044 *
1045 * Note that this doesn't change any behavior as internal
1046 * command failure results in disabling the device in the
1047 * higher layer for LLDDs without new reset/EH callbacks.
1048 *
1049 * Kill the following code as soon as those drivers are fixed.
1050 */
Tejun Heo198e0fe2006-04-02 18:51:52 +09001051 if (ap->flags & ATA_FLAG_DISABLED) {
Tejun Heo1f7dd3e92006-03-24 15:25:30 +09001052 err_mask |= AC_ERR_SYSTEM;
1053 ata_port_probe(ap);
1054 }
1055
Tejun Heo77853bf2006-01-23 13:09:36 +09001056 return err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001057}
1058
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059/**
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001060 * ata_pio_need_iordy - check if iordy needed
1061 * @adev: ATA device
1062 *
1063 * Check if the current speed of the device requires IORDY. Used
1064 * by various controllers for chip configuration.
1065 */
1066
1067unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1068{
1069 int pio;
1070 int speed = adev->pio_mode - XFER_PIO_0;
1071
1072 if (speed < 2)
1073 return 0;
1074 if (speed > 2)
1075 return 1;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001076
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001077 /* If we have no drive specific rule, then PIO 2 is non IORDY */
1078
1079 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1080 pio = adev->id[ATA_ID_EIDE_PIO];
1081 /* Is the speed faster than the drive allows non IORDY ? */
1082 if (pio) {
1083 /* This is cycle times not frequency - watch the logic! */
1084 if (pio > 240) /* PIO2 is 240nS per cycle */
1085 return 1;
1086 return 0;
1087 }
1088 }
1089 return 0;
1090}
1091
1092/**
Tejun Heo49016ac2006-02-21 02:12:11 +09001093 * ata_dev_read_id - Read ID data from the specified device
1094 * @ap: port on which target device resides
1095 * @dev: target device
1096 * @p_class: pointer to class of the target device (may be changed)
1097 * @post_reset: is this read ID post-reset?
Tejun Heod9572b12006-03-01 16:09:35 +09001098 * @p_id: read IDENTIFY page (newly allocated)
Tejun Heo49016ac2006-02-21 02:12:11 +09001099 *
1100 * Read ID data from the specified device. ATA_CMD_ID_ATA is
1101 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
Tejun Heoaec5c3c2006-03-25 01:33:34 +09001102 * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS
1103 * for pre-ATA4 drives.
Tejun Heo49016ac2006-02-21 02:12:11 +09001104 *
1105 * LOCKING:
1106 * Kernel thread context (may sleep)
1107 *
1108 * RETURNS:
1109 * 0 on success, -errno otherwise.
1110 */
1111static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
Tejun Heod9572b12006-03-01 16:09:35 +09001112 unsigned int *p_class, int post_reset, u16 **p_id)
Tejun Heo49016ac2006-02-21 02:12:11 +09001113{
1114 unsigned int class = *p_class;
Tejun Heo49016ac2006-02-21 02:12:11 +09001115 struct ata_taskfile tf;
1116 unsigned int err_mask = 0;
Tejun Heod9572b12006-03-01 16:09:35 +09001117 u16 *id;
Tejun Heo49016ac2006-02-21 02:12:11 +09001118 const char *reason;
1119 int rc;
1120
1121 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1122
Tejun Heo49016ac2006-02-21 02:12:11 +09001123 ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1124
Tejun Heod9572b12006-03-01 16:09:35 +09001125 id = kmalloc(sizeof(id[0]) * ATA_ID_WORDS, GFP_KERNEL);
1126 if (id == NULL) {
1127 rc = -ENOMEM;
1128 reason = "out of memory";
1129 goto err_out;
1130 }
1131
Tejun Heo49016ac2006-02-21 02:12:11 +09001132 retry:
1133 ata_tf_init(ap, &tf, dev->devno);
1134
1135 switch (class) {
1136 case ATA_DEV_ATA:
1137 tf.command = ATA_CMD_ID_ATA;
1138 break;
1139 case ATA_DEV_ATAPI:
1140 tf.command = ATA_CMD_ID_ATAPI;
1141 break;
1142 default:
1143 rc = -ENODEV;
1144 reason = "unsupported class";
1145 goto err_out;
1146 }
1147
1148 tf.protocol = ATA_PROT_PIO;
1149
Tejun Heod69cf372006-04-02 18:51:53 +09001150 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_FROM_DEVICE,
Tejun Heo49016ac2006-02-21 02:12:11 +09001151 id, sizeof(id[0]) * ATA_ID_WORDS);
Tejun Heo49016ac2006-02-21 02:12:11 +09001152 if (err_mask) {
1153 rc = -EIO;
1154 reason = "I/O error";
Tejun Heo49016ac2006-02-21 02:12:11 +09001155 goto err_out;
1156 }
1157
1158 swap_buf_le16(id, ATA_ID_WORDS);
1159
Tejun Heo49016ac2006-02-21 02:12:11 +09001160 /* sanity check */
Alan Cox692785e2006-03-27 18:49:19 +01001161 if ((class == ATA_DEV_ATA) != (ata_id_is_ata(id) | ata_id_is_cfa(id))) {
Tejun Heo49016ac2006-02-21 02:12:11 +09001162 rc = -EINVAL;
1163 reason = "device reports illegal type";
1164 goto err_out;
1165 }
1166
1167 if (post_reset && class == ATA_DEV_ATA) {
1168 /*
1169 * The exact sequence expected by certain pre-ATA4 drives is:
1170 * SRST RESET
1171 * IDENTIFY
1172 * INITIALIZE DEVICE PARAMETERS
1173 * anything else..
1174 * Some drives were very specific about that exact sequence.
1175 */
1176 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
Albert Lee00b6f5e2006-03-27 16:39:18 +08001177 err_mask = ata_dev_init_params(ap, dev, id[3], id[6]);
Tejun Heo49016ac2006-02-21 02:12:11 +09001178 if (err_mask) {
1179 rc = -EIO;
1180 reason = "INIT_DEV_PARAMS failed";
1181 goto err_out;
1182 }
1183
1184 /* current CHS translation info (id[53-58]) might be
1185 * changed. reread the identify device info.
1186 */
1187 post_reset = 0;
1188 goto retry;
1189 }
1190 }
1191
1192 *p_class = class;
Tejun Heod9572b12006-03-01 16:09:35 +09001193 *p_id = id;
Tejun Heo49016ac2006-02-21 02:12:11 +09001194 return 0;
1195
1196 err_out:
1197 printk(KERN_WARNING "ata%u: dev %u failed to IDENTIFY (%s)\n",
1198 ap->id, dev->devno, reason);
Tejun Heod9572b12006-03-01 16:09:35 +09001199 kfree(id);
Tejun Heo49016ac2006-02-21 02:12:11 +09001200 return rc;
1201}
1202
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001203static inline u8 ata_dev_knobble(const struct ata_port *ap,
1204 struct ata_device *dev)
1205{
1206 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
1207}
1208
Tejun Heo49016ac2006-02-21 02:12:11 +09001209/**
Tejun Heoffeae412006-03-01 16:09:35 +09001210 * ata_dev_configure - Configure the specified ATA/ATAPI device
1211 * @ap: Port on which target device resides
1212 * @dev: Target device to configure
Tejun Heo4c2d7212006-03-05 17:55:58 +09001213 * @print_info: Enable device info printout
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 *
Tejun Heoffeae412006-03-01 16:09:35 +09001215 * Configure @dev according to @dev->id. Generic and low-level
1216 * driver specific fixups are also applied.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 *
1218 * LOCKING:
Tejun Heoffeae412006-03-01 16:09:35 +09001219 * Kernel thread context (may sleep)
1220 *
1221 * RETURNS:
1222 * 0 on success, -errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001224static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
1225 int print_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226{
Tejun Heo1148c3a2006-03-13 19:48:04 +09001227 const u16 *id = dev->id;
Tejun Heoff8854b2006-03-06 04:31:56 +09001228 unsigned int xfer_mask;
Tejun Heo6e7846e2006-02-12 23:32:58 +09001229 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
Tejun Heoe1211e32006-04-01 01:38:18 +09001231 if (!ata_dev_enabled(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
Tejun Heoffeae412006-03-01 16:09:35 +09001233 ap->id, dev->devno);
1234 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 }
1236
Tejun Heoffeae412006-03-01 16:09:35 +09001237 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
Tejun Heoc39f5eb2006-03-13 19:51:19 +09001239 /* print device capabilities */
1240 if (print_info)
1241 printk(KERN_DEBUG "ata%u: dev %u cfg 49:%04x 82:%04x 83:%04x "
1242 "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1243 ap->id, dev->devno, id[49], id[82], id[83],
1244 id[84], id[85], id[86], id[87], id[88]);
1245
Tejun Heo208a9932006-03-05 17:55:58 +09001246 /* initialize to-be-configured parameters */
Tejun Heoea1dd4e2006-04-02 18:51:53 +09001247 dev->flags &= ~ATA_DFLAG_CFG_MASK;
Tejun Heo208a9932006-03-05 17:55:58 +09001248 dev->max_sectors = 0;
1249 dev->cdb_len = 0;
1250 dev->n_sectors = 0;
1251 dev->cylinders = 0;
1252 dev->heads = 0;
1253 dev->sectors = 0;
1254
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 /*
1256 * common ATA, ATAPI feature tests
1257 */
1258
Tejun Heoff8854b2006-03-06 04:31:56 +09001259 /* find max transfer mode; for printk only */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001260 xfer_mask = ata_id_xfermask(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
Tejun Heo1148c3a2006-03-13 19:48:04 +09001262 ata_dump_id(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
1264 /* ATA-specific feature tests */
1265 if (dev->class == ATA_DEV_ATA) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001266 dev->n_sectors = ata_id_n_sectors(id);
Tejun Heo29407402006-02-12 22:47:04 +09001267
Tejun Heo1148c3a2006-03-13 19:48:04 +09001268 if (ata_id_has_lba(id)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001269 const char *lba_desc;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001270
Tejun Heo4c2d7212006-03-05 17:55:58 +09001271 lba_desc = "LBA";
1272 dev->flags |= ATA_DFLAG_LBA;
Tejun Heo1148c3a2006-03-13 19:48:04 +09001273 if (ata_id_has_lba48(id)) {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001274 dev->flags |= ATA_DFLAG_LBA48;
Tejun Heo4c2d7212006-03-05 17:55:58 +09001275 lba_desc = "LBA48";
1276 }
Albert Lee8bf62ece2005-05-12 15:29:42 -04001277
1278 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001279 if (print_info)
1280 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1281 "max %s, %Lu sectors: %s\n",
1282 ap->id, dev->devno,
Tejun Heo1148c3a2006-03-13 19:48:04 +09001283 ata_id_major_version(id),
Tejun Heoff8854b2006-03-06 04:31:56 +09001284 ata_mode_string(xfer_mask),
Tejun Heo4c2d7212006-03-05 17:55:58 +09001285 (unsigned long long)dev->n_sectors,
1286 lba_desc);
Tejun Heoffeae412006-03-01 16:09:35 +09001287 } else {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001288 /* CHS */
1289
1290 /* Default translation */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001291 dev->cylinders = id[1];
1292 dev->heads = id[3];
1293 dev->sectors = id[6];
Albert Lee8bf62ece2005-05-12 15:29:42 -04001294
Tejun Heo1148c3a2006-03-13 19:48:04 +09001295 if (ata_id_current_chs_valid(id)) {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001296 /* Current CHS translation is valid. */
Tejun Heo1148c3a2006-03-13 19:48:04 +09001297 dev->cylinders = id[54];
1298 dev->heads = id[55];
1299 dev->sectors = id[56];
Albert Lee8bf62ece2005-05-12 15:29:42 -04001300 }
1301
1302 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001303 if (print_info)
1304 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1305 "max %s, %Lu sectors: CHS %u/%u/%u\n",
1306 ap->id, dev->devno,
Tejun Heo1148c3a2006-03-13 19:48:04 +09001307 ata_id_major_version(id),
Tejun Heoff8854b2006-03-06 04:31:56 +09001308 ata_mode_string(xfer_mask),
Tejun Heo4c2d7212006-03-05 17:55:58 +09001309 (unsigned long long)dev->n_sectors,
1310 dev->cylinders, dev->heads, dev->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 }
1312
Tejun Heo6e7846e2006-02-12 23:32:58 +09001313 dev->cdb_len = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 }
1315
1316 /* ATAPI-specific feature tests */
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05001317 else if (dev->class == ATA_DEV_ATAPI) {
Tejun Heo1148c3a2006-03-13 19:48:04 +09001318 rc = atapi_cdb_len(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1320 printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
Tejun Heoffeae412006-03-01 16:09:35 +09001321 rc = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 goto err_out_nosup;
1323 }
Tejun Heo6e7846e2006-02-12 23:32:58 +09001324 dev->cdb_len = (unsigned int) rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
1326 /* print device info to dmesg */
Tejun Heo4c2d7212006-03-05 17:55:58 +09001327 if (print_info)
1328 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
Tejun Heoff8854b2006-03-06 04:31:56 +09001329 ap->id, dev->devno, ata_mode_string(xfer_mask));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 }
1331
Tejun Heo6e7846e2006-02-12 23:32:58 +09001332 ap->host->max_cmd_len = 0;
1333 for (i = 0; i < ATA_MAX_DEVICES; i++)
1334 ap->host->max_cmd_len = max_t(unsigned int,
1335 ap->host->max_cmd_len,
1336 ap->device[i].cdb_len);
1337
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001338 /* limit bridge transfers to udma5, 200 sectors */
1339 if (ata_dev_knobble(ap, dev)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09001340 if (print_info)
1341 printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
1342 ap->id, dev->devno);
Tejun Heo5a529132006-03-24 14:07:50 +09001343 dev->udma_mask &= ATA_UDMA5;
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09001344 dev->max_sectors = ATA_MAX_SECTORS;
1345 }
1346
1347 if (ap->ops->dev_config)
1348 ap->ops->dev_config(ap, dev);
1349
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
Tejun Heoffeae412006-03-01 16:09:35 +09001351 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352
1353err_out_nosup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 DPRINTK("EXIT, err\n");
Tejun Heoffeae412006-03-01 16:09:35 +09001355 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356}
1357
1358/**
1359 * ata_bus_probe - Reset and probe ATA bus
1360 * @ap: Bus to probe
1361 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001362 * Master ATA bus probing function. Initiates a hardware-dependent
1363 * bus reset, then attempts to identify any devices found on
1364 * the bus.
1365 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001367 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 *
1369 * RETURNS:
Tejun Heo96072e62006-04-01 01:38:17 +09001370 * Zero on success, negative errno otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 */
1372
1373static int ata_bus_probe(struct ata_port *ap)
1374{
Tejun Heo28ca5c52006-03-01 16:09:36 +09001375 unsigned int classes[ATA_MAX_DEVICES];
Tejun Heo14d2bac2006-04-02 17:54:46 +09001376 int tries[ATA_MAX_DEVICES];
1377 int i, rc, down_xfermask;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001378 struct ata_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
Tejun Heo28ca5c52006-03-01 16:09:36 +09001380 ata_port_probe(ap);
1381
Tejun Heo14d2bac2006-04-02 17:54:46 +09001382 for (i = 0; i < ATA_MAX_DEVICES; i++)
1383 tries[i] = ATA_PROBE_MAX_TRIES;
1384
1385 retry:
1386 down_xfermask = 0;
1387
Tejun Heo20444702006-03-13 01:57:01 +09001388 /* reset and determine device classes */
1389 for (i = 0; i < ATA_MAX_DEVICES; i++)
1390 classes[i] = ATA_DEV_UNKNOWN;
Tejun Heo2061a472006-03-12 00:57:39 +09001391
Tejun Heo20444702006-03-13 01:57:01 +09001392 if (ap->ops->probe_reset) {
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001393 rc = ap->ops->probe_reset(ap, classes);
Tejun Heo28ca5c52006-03-01 16:09:36 +09001394 if (rc) {
1395 printk("ata%u: reset failed (errno=%d)\n", ap->id, rc);
1396 return rc;
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001397 }
Tejun Heo28ca5c52006-03-01 16:09:36 +09001398 } else {
Tejun Heoc19ba8a2006-01-24 17:05:22 +09001399 ap->ops->phy_reset(ap);
1400
Tejun Heo198e0fe2006-04-02 18:51:52 +09001401 if (!(ap->flags & ATA_FLAG_DISABLED))
Tejun Heo20444702006-03-13 01:57:01 +09001402 for (i = 0; i < ATA_MAX_DEVICES; i++)
Tejun Heo28ca5c52006-03-01 16:09:36 +09001403 classes[i] = ap->device[i].class;
Tejun Heo20444702006-03-13 01:57:01 +09001404
Tejun Heo28ca5c52006-03-01 16:09:36 +09001405 ata_port_probe(ap);
1406 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407
Tejun Heo20444702006-03-13 01:57:01 +09001408 for (i = 0; i < ATA_MAX_DEVICES; i++)
1409 if (classes[i] == ATA_DEV_UNKNOWN)
1410 classes[i] = ATA_DEV_NONE;
1411
Tejun Heo28ca5c52006-03-01 16:09:36 +09001412 /* read IDENTIFY page and configure devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001414 dev = &ap->device[i];
Tejun Heo28ca5c52006-03-01 16:09:36 +09001415 dev->class = classes[i];
1416
Tejun Heo14d2bac2006-04-02 17:54:46 +09001417 if (!tries[i]) {
1418 ata_down_xfermask_limit(ap, dev, 1);
1419 ata_dev_disable(ap, dev);
1420 }
1421
Tejun Heoe1211e32006-04-01 01:38:18 +09001422 if (!ata_dev_enabled(dev))
Tejun Heoffeae412006-03-01 16:09:35 +09001423 continue;
1424
Tejun Heo14d2bac2006-04-02 17:54:46 +09001425 kfree(dev->id);
1426 dev->id = NULL;
1427 rc = ata_dev_read_id(ap, dev, &dev->class, 1, &dev->id);
1428 if (rc)
1429 goto fail;
Tejun Heoffeae412006-03-01 16:09:35 +09001430
Tejun Heo14d2bac2006-04-02 17:54:46 +09001431 rc = ata_dev_configure(ap, dev, 1);
1432 if (rc)
1433 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 }
1435
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001436 /* configure transfer mode */
1437 if (ap->ops->set_mode) {
1438 /* FIXME: make ->set_mode handle no device case and
1439 * return error code and failing device on failure as
1440 * ata_set_mode() does.
1441 */
Tejun Heo14d2bac2006-04-02 17:54:46 +09001442 for (i = 0; i < ATA_MAX_DEVICES; i++)
1443 if (ata_dev_enabled(&ap->device[i])) {
1444 ap->ops->set_mode(ap);
1445 break;
1446 }
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001447 rc = 0;
1448 } else {
Tejun Heo14d2bac2006-04-02 17:54:46 +09001449 rc = ata_set_mode(ap, &dev);
1450 if (rc) {
1451 down_xfermask = 1;
1452 goto fail;
1453 }
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001456 for (i = 0; i < ATA_MAX_DEVICES; i++)
1457 if (ata_dev_enabled(&ap->device[i]))
1458 return 0;
Alan Coxe35a9e02006-03-27 18:46:37 +01001459
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001460 /* no device present, disable port */
1461 ata_port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 ap->ops->port_disable(ap);
Tejun Heo96072e62006-04-01 01:38:17 +09001463 return -ENODEV;
Tejun Heo14d2bac2006-04-02 17:54:46 +09001464
1465 fail:
1466 switch (rc) {
1467 case -EINVAL:
1468 case -ENODEV:
1469 tries[dev->devno] = 0;
1470 break;
1471 case -EIO:
1472 ata_down_sata_spd_limit(ap);
1473 /* fall through */
1474 default:
1475 tries[dev->devno]--;
1476 if (down_xfermask &&
1477 ata_down_xfermask_limit(ap, dev, tries[dev->devno] == 1))
1478 tries[dev->devno] = 0;
1479 }
1480
1481 goto retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482}
1483
1484/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04001485 * ata_port_probe - Mark port as enabled
1486 * @ap: Port for which we indicate enablement
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04001488 * Modify @ap data structure such that the system
1489 * thinks that the entire port is enabled.
1490 *
1491 * LOCKING: host_set lock, or some other form of
1492 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 */
1494
1495void ata_port_probe(struct ata_port *ap)
1496{
Tejun Heo198e0fe2006-04-02 18:51:52 +09001497 ap->flags &= ~ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498}
1499
1500/**
Tejun Heo3be680b2005-12-19 22:35:02 +09001501 * sata_print_link_status - Print SATA link status
1502 * @ap: SATA port to printk link status about
1503 *
1504 * This function prints link speed and status of a SATA link.
1505 *
1506 * LOCKING:
1507 * None.
1508 */
1509static void sata_print_link_status(struct ata_port *ap)
1510{
1511 u32 sstatus, tmp;
Tejun Heo3be680b2005-12-19 22:35:02 +09001512
1513 if (!ap->ops->scr_read)
1514 return;
1515
1516 sstatus = scr_read(ap, SCR_STATUS);
1517
1518 if (sata_dev_present(ap)) {
1519 tmp = (sstatus >> 4) & 0xf;
Tejun Heo4c360c82006-04-01 01:38:17 +09001520 printk(KERN_INFO "ata%u: SATA link up %s (SStatus %X)\n",
1521 ap->id, sata_spd_string(tmp), sstatus);
Tejun Heo3be680b2005-12-19 22:35:02 +09001522 } else {
1523 printk(KERN_INFO "ata%u: SATA link down (SStatus %X)\n",
1524 ap->id, sstatus);
1525 }
1526}
1527
1528/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001529 * __sata_phy_reset - Wake/reset a low-level SATA PHY
1530 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001532 * This function issues commands to standard SATA Sxxx
1533 * PHY registers, to wake up the phy (and device), and
1534 * clear any reset condition.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 *
1536 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001537 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 *
1539 */
1540void __sata_phy_reset(struct ata_port *ap)
1541{
1542 u32 sstatus;
1543 unsigned long timeout = jiffies + (HZ * 5);
1544
1545 if (ap->flags & ATA_FLAG_SATA_RESET) {
Brett Russcdcca89e2005-03-28 15:10:27 -05001546 /* issue phy wake/reset */
1547 scr_write_flush(ap, SCR_CONTROL, 0x301);
Tejun Heo62ba2842005-06-26 23:27:19 +09001548 /* Couldn't find anything in SATA I/II specs, but
1549 * AHCI-1.1 10.4.2 says at least 1 ms. */
1550 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 }
Brett Russcdcca89e2005-03-28 15:10:27 -05001552 scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
1554 /* wait for phy to become ready, if necessary */
1555 do {
1556 msleep(200);
1557 sstatus = scr_read(ap, SCR_STATUS);
1558 if ((sstatus & 0xf) != 1)
1559 break;
1560 } while (time_before(jiffies, timeout));
1561
Tejun Heo3be680b2005-12-19 22:35:02 +09001562 /* print link status */
1563 sata_print_link_status(ap);
Jeff Garzik656563e2005-11-20 03:36:45 -05001564
Tejun Heo3be680b2005-12-19 22:35:02 +09001565 /* TODO: phy layer with polling, timeouts, etc. */
1566 if (sata_dev_present(ap))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 ata_port_probe(ap);
Tejun Heo3be680b2005-12-19 22:35:02 +09001568 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 ata_port_disable(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
Tejun Heo198e0fe2006-04-02 18:51:52 +09001571 if (ap->flags & ATA_FLAG_DISABLED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 return;
1573
1574 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1575 ata_port_disable(ap);
1576 return;
1577 }
1578
1579 ap->cbl = ATA_CBL_SATA;
1580}
1581
1582/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001583 * sata_phy_reset - Reset SATA bus.
1584 * @ap: SATA port associated with target SATA PHY.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001586 * This function resets the SATA bus, and then probes
1587 * the bus for devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 *
1589 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001590 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 *
1592 */
1593void sata_phy_reset(struct ata_port *ap)
1594{
1595 __sata_phy_reset(ap);
Tejun Heo198e0fe2006-04-02 18:51:52 +09001596 if (ap->flags & ATA_FLAG_DISABLED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 return;
1598 ata_bus_reset(ap);
1599}
1600
1601/**
Alan Coxebdfca62006-03-23 15:38:34 +00001602 * ata_dev_pair - return other device on cable
1603 * @ap: port
1604 * @adev: device
1605 *
1606 * Obtain the other device on the same cable, or if none is
1607 * present NULL is returned
1608 */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001609
Alan Coxebdfca62006-03-23 15:38:34 +00001610struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
1611{
1612 struct ata_device *pair = &ap->device[1 - adev->devno];
Tejun Heoe1211e32006-04-01 01:38:18 +09001613 if (!ata_dev_enabled(pair))
Alan Coxebdfca62006-03-23 15:38:34 +00001614 return NULL;
1615 return pair;
1616}
1617
1618/**
Jeff Garzik780a87f2005-05-30 15:41:05 -04001619 * ata_port_disable - Disable port.
1620 * @ap: Port to be disabled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04001622 * Modify @ap data structure such that the system
1623 * thinks that the entire port is disabled, and should
1624 * never attempt to probe or communicate with devices
1625 * on this port.
1626 *
1627 * LOCKING: host_set lock, or some other form of
1628 * serialization.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 */
1630
1631void ata_port_disable(struct ata_port *ap)
1632{
1633 ap->device[0].class = ATA_DEV_NONE;
1634 ap->device[1].class = ATA_DEV_NONE;
Tejun Heo198e0fe2006-04-02 18:51:52 +09001635 ap->flags |= ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636}
1637
Tejun Heo1c3fae42006-04-02 20:53:28 +09001638/**
1639 * ata_down_sata_spd_limit - adjust SATA spd limit downward
1640 * @ap: Port to adjust SATA spd limit for
1641 *
1642 * Adjust SATA spd limit of @ap downward. Note that this
1643 * function only adjusts the limit. The change must be applied
1644 * using ata_set_sata_spd().
1645 *
1646 * LOCKING:
1647 * Inherited from caller.
1648 *
1649 * RETURNS:
1650 * 0 on success, negative errno on failure
1651 */
1652static int ata_down_sata_spd_limit(struct ata_port *ap)
1653{
1654 u32 spd, mask;
1655 int highbit;
1656
1657 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1658 return -EOPNOTSUPP;
1659
1660 mask = ap->sata_spd_limit;
1661 if (mask <= 1)
1662 return -EINVAL;
1663 highbit = fls(mask) - 1;
1664 mask &= ~(1 << highbit);
1665
1666 spd = (scr_read(ap, SCR_STATUS) >> 4) & 0xf;
1667 if (spd <= 1)
1668 return -EINVAL;
1669 spd--;
1670 mask &= (1 << spd) - 1;
1671 if (!mask)
1672 return -EINVAL;
1673
1674 ap->sata_spd_limit = mask;
1675
1676 printk(KERN_WARNING "ata%u: limiting SATA link speed to %s\n",
1677 ap->id, sata_spd_string(fls(mask)));
1678
1679 return 0;
1680}
1681
1682static int __ata_set_sata_spd_needed(struct ata_port *ap, u32 *scontrol)
1683{
1684 u32 spd, limit;
1685
1686 if (ap->sata_spd_limit == UINT_MAX)
1687 limit = 0;
1688 else
1689 limit = fls(ap->sata_spd_limit);
1690
1691 spd = (*scontrol >> 4) & 0xf;
1692 *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
1693
1694 return spd != limit;
1695}
1696
1697/**
1698 * ata_set_sata_spd_needed - is SATA spd configuration needed
1699 * @ap: Port in question
1700 *
1701 * Test whether the spd limit in SControl matches
1702 * @ap->sata_spd_limit. This function is used to determine
1703 * whether hardreset is necessary to apply SATA spd
1704 * configuration.
1705 *
1706 * LOCKING:
1707 * Inherited from caller.
1708 *
1709 * RETURNS:
1710 * 1 if SATA spd configuration is needed, 0 otherwise.
1711 */
1712static int ata_set_sata_spd_needed(struct ata_port *ap)
1713{
1714 u32 scontrol;
1715
1716 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1717 return 0;
1718
1719 scontrol = scr_read(ap, SCR_CONTROL);
1720
1721 return __ata_set_sata_spd_needed(ap, &scontrol);
1722}
1723
1724/**
1725 * ata_set_sata_spd - set SATA spd according to spd limit
1726 * @ap: Port to set SATA spd for
1727 *
1728 * Set SATA spd of @ap according to sata_spd_limit.
1729 *
1730 * LOCKING:
1731 * Inherited from caller.
1732 *
1733 * RETURNS:
1734 * 0 if spd doesn't need to be changed, 1 if spd has been
1735 * changed. -EOPNOTSUPP if SCR registers are inaccessible.
1736 */
1737static int ata_set_sata_spd(struct ata_port *ap)
1738{
1739 u32 scontrol;
1740
1741 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1742 return -EOPNOTSUPP;
1743
1744 scontrol = scr_read(ap, SCR_CONTROL);
1745 if (!__ata_set_sata_spd_needed(ap, &scontrol))
1746 return 0;
1747
1748 scr_write(ap, SCR_CONTROL, scontrol);
1749 return 1;
1750}
1751
Alan Cox452503f2005-10-21 19:01:32 -04001752/*
1753 * This mode timing computation functionality is ported over from
1754 * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
1755 */
1756/*
1757 * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
1758 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
1759 * for PIO 5, which is a nonstandard extension and UDMA6, which
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001760 * is currently supported only by Maxtor drives.
Alan Cox452503f2005-10-21 19:01:32 -04001761 */
1762
1763static const struct ata_timing ata_timing[] = {
1764
1765 { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 },
1766 { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 },
1767 { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 },
1768 { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 },
1769
1770 { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 },
1771 { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 },
1772 { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 },
1773
1774/* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001775
Alan Cox452503f2005-10-21 19:01:32 -04001776 { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 },
1777 { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 },
1778 { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 },
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001779
Alan Cox452503f2005-10-21 19:01:32 -04001780 { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 },
1781 { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 },
1782 { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 },
1783
1784/* { XFER_PIO_5, 20, 50, 30, 100, 50, 30, 100, 0 }, */
1785 { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 },
1786 { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 },
1787
1788 { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 },
1789 { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 },
1790 { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 },
1791
1792/* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */
1793
1794 { 0xFF }
1795};
1796
1797#define ENOUGH(v,unit) (((v)-1)/(unit)+1)
1798#define EZ(v,unit) ((v)?ENOUGH(v,unit):0)
1799
1800static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
1801{
1802 q->setup = EZ(t->setup * 1000, T);
1803 q->act8b = EZ(t->act8b * 1000, T);
1804 q->rec8b = EZ(t->rec8b * 1000, T);
1805 q->cyc8b = EZ(t->cyc8b * 1000, T);
1806 q->active = EZ(t->active * 1000, T);
1807 q->recover = EZ(t->recover * 1000, T);
1808 q->cycle = EZ(t->cycle * 1000, T);
1809 q->udma = EZ(t->udma * 1000, UT);
1810}
1811
1812void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
1813 struct ata_timing *m, unsigned int what)
1814{
1815 if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup);
1816 if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b);
1817 if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b);
1818 if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b);
1819 if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active);
1820 if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
1821 if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle);
1822 if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma);
1823}
1824
1825static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
1826{
1827 const struct ata_timing *t;
1828
1829 for (t = ata_timing; t->mode != speed; t++)
Alan Cox91190752005-10-26 12:17:46 -04001830 if (t->mode == 0xFF)
Alan Cox452503f2005-10-21 19:01:32 -04001831 return NULL;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001832 return t;
Alan Cox452503f2005-10-21 19:01:32 -04001833}
1834
1835int ata_timing_compute(struct ata_device *adev, unsigned short speed,
1836 struct ata_timing *t, int T, int UT)
1837{
1838 const struct ata_timing *s;
1839 struct ata_timing p;
1840
1841 /*
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001842 * Find the mode.
Albert Lee75b1f2f2005-11-16 17:06:18 +08001843 */
Alan Cox452503f2005-10-21 19:01:32 -04001844
1845 if (!(s = ata_timing_find_mode(speed)))
1846 return -EINVAL;
1847
Albert Lee75b1f2f2005-11-16 17:06:18 +08001848 memcpy(t, s, sizeof(*s));
1849
Alan Cox452503f2005-10-21 19:01:32 -04001850 /*
1851 * If the drive is an EIDE drive, it can tell us it needs extended
1852 * PIO/MW_DMA cycle timing.
1853 */
1854
1855 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
1856 memset(&p, 0, sizeof(p));
1857 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
1858 if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
1859 else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
1860 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
1861 p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
1862 }
1863 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
1864 }
1865
1866 /*
1867 * Convert the timing to bus clock counts.
1868 */
1869
Albert Lee75b1f2f2005-11-16 17:06:18 +08001870 ata_timing_quantize(t, t, T, UT);
Alan Cox452503f2005-10-21 19:01:32 -04001871
1872 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001873 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
1874 * S.M.A.R.T * and some other commands. We have to ensure that the
1875 * DMA cycle timing is slower/equal than the fastest PIO timing.
Alan Cox452503f2005-10-21 19:01:32 -04001876 */
1877
1878 if (speed > XFER_PIO_4) {
1879 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
1880 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
1881 }
1882
1883 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05001884 * Lengthen active & recovery time so that cycle time is correct.
Alan Cox452503f2005-10-21 19:01:32 -04001885 */
1886
1887 if (t->act8b + t->rec8b < t->cyc8b) {
1888 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
1889 t->rec8b = t->cyc8b - t->act8b;
1890 }
1891
1892 if (t->active + t->recover < t->cycle) {
1893 t->active += (t->cycle - (t->active + t->recover)) / 2;
1894 t->recover = t->cycle - t->active;
1895 }
1896
1897 return 0;
1898}
1899
Tejun Heocf176e12006-04-02 17:54:46 +09001900/**
1901 * ata_down_xfermask_limit - adjust dev xfer masks downward
1902 * @ap: Port associated with device @dev
1903 * @dev: Device to adjust xfer masks
1904 * @force_pio0: Force PIO0
1905 *
1906 * Adjust xfer masks of @dev downward. Note that this function
1907 * does not apply the change. Invoking ata_set_mode() afterwards
1908 * will apply the limit.
1909 *
1910 * LOCKING:
1911 * Inherited from caller.
1912 *
1913 * RETURNS:
1914 * 0 on success, negative errno on failure
1915 */
1916static int ata_down_xfermask_limit(struct ata_port *ap, struct ata_device *dev,
1917 int force_pio0)
1918{
1919 unsigned long xfer_mask;
1920 int highbit;
1921
1922 xfer_mask = ata_pack_xfermask(dev->pio_mask, dev->mwdma_mask,
1923 dev->udma_mask);
1924
1925 if (!xfer_mask)
1926 goto fail;
1927 /* don't gear down to MWDMA from UDMA, go directly to PIO */
1928 if (xfer_mask & ATA_MASK_UDMA)
1929 xfer_mask &= ~ATA_MASK_MWDMA;
1930
1931 highbit = fls(xfer_mask) - 1;
1932 xfer_mask &= ~(1 << highbit);
1933 if (force_pio0)
1934 xfer_mask &= 1 << ATA_SHIFT_PIO;
1935 if (!xfer_mask)
1936 goto fail;
1937
1938 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
1939 &dev->udma_mask);
1940
1941 printk(KERN_WARNING "ata%u: dev %u limiting speed to %s\n",
1942 ap->id, dev->devno, ata_mode_string(xfer_mask));
1943
1944 return 0;
1945
1946 fail:
1947 return -EINVAL;
1948}
1949
Tejun Heo83206a22006-03-24 15:25:31 +09001950static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951{
Tejun Heo83206a22006-03-24 15:25:31 +09001952 unsigned int err_mask;
1953 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954
Tejun Heoe8384602006-04-02 18:51:53 +09001955 dev->flags &= ~ATA_DFLAG_PIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 if (dev->xfer_shift == ATA_SHIFT_PIO)
1957 dev->flags |= ATA_DFLAG_PIO;
1958
Tejun Heo83206a22006-03-24 15:25:31 +09001959 err_mask = ata_dev_set_xfermode(ap, dev);
1960 if (err_mask) {
1961 printk(KERN_ERR
1962 "ata%u: failed to set xfermode (err_mask=0x%x)\n",
1963 ap->id, err_mask);
1964 return -EIO;
1965 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966
Tejun Heo83206a22006-03-24 15:25:31 +09001967 rc = ata_dev_revalidate(ap, dev, 0);
Tejun Heo5eb45c02006-04-02 18:51:52 +09001968 if (rc)
Tejun Heo83206a22006-03-24 15:25:31 +09001969 return rc;
Tejun Heo48a8a142006-03-05 17:55:58 +09001970
Tejun Heo23e71c32006-03-06 04:31:57 +09001971 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
1972 dev->xfer_shift, (int)dev->xfer_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973
1974 printk(KERN_INFO "ata%u: dev %u configured for %s\n",
Tejun Heo23e71c32006-03-06 04:31:57 +09001975 ap->id, dev->devno,
1976 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
Tejun Heo83206a22006-03-24 15:25:31 +09001977 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978}
1979
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980/**
1981 * ata_set_mode - Program timings and issue SET FEATURES - XFER
1982 * @ap: port on which timings will be programmed
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001983 * @r_failed_dev: out paramter for failed device
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 *
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001985 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
1986 * ata_set_mode() fails, pointer to the failing device is
1987 * returned in @r_failed_dev.
Jeff Garzik780a87f2005-05-30 15:41:05 -04001988 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04001990 * PCI/etc. bus probe sem.
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001991 *
1992 * RETURNS:
1993 * 0 on success, negative errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 */
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001995static int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996{
Tejun Heoe8e06192006-04-01 01:38:18 +09001997 struct ata_device *dev;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09001998 int i, rc = 0, used_dma = 0, found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999
Tejun Heoa6d5a512006-03-06 04:31:57 +09002000 /* step 1: calculate xfer_mask */
2001 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoacf356b2006-03-24 14:07:50 +09002002 unsigned int pio_mask, dma_mask;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002003
Tejun Heoe8e06192006-04-01 01:38:18 +09002004 dev = &ap->device[i];
2005
Tejun Heoe1211e32006-04-01 01:38:18 +09002006 if (!ata_dev_enabled(dev))
Tejun Heoa6d5a512006-03-06 04:31:57 +09002007 continue;
2008
Tejun Heoacf356b2006-03-24 14:07:50 +09002009 ata_dev_xfermask(ap, dev);
Tejun Heoa6d5a512006-03-06 04:31:57 +09002010
Tejun Heoacf356b2006-03-24 14:07:50 +09002011 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
2012 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
2013 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
2014 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
Alan Cox5444a6f2006-03-27 18:58:20 +01002015
Tejun Heo4f659772006-04-01 01:38:18 +09002016 found = 1;
Alan Cox5444a6f2006-03-27 18:58:20 +01002017 if (dev->dma_mode)
2018 used_dma = 1;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002019 }
Tejun Heo4f659772006-04-01 01:38:18 +09002020 if (!found)
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002021 goto out;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002022
2023 /* step 2: always set host PIO timings */
Tejun Heoe8e06192006-04-01 01:38:18 +09002024 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2025 dev = &ap->device[i];
2026 if (!ata_dev_enabled(dev))
2027 continue;
2028
2029 if (!dev->pio_mode) {
2030 printk(KERN_WARNING "ata%u: dev %u no PIO support\n",
2031 ap->id, dev->devno);
2032 rc = -EINVAL;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002033 goto out;
Tejun Heoe8e06192006-04-01 01:38:18 +09002034 }
2035
2036 dev->xfer_mode = dev->pio_mode;
2037 dev->xfer_shift = ATA_SHIFT_PIO;
2038 if (ap->ops->set_piomode)
2039 ap->ops->set_piomode(ap, dev);
2040 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041
Tejun Heoa6d5a512006-03-06 04:31:57 +09002042 /* step 3: set host DMA timings */
Tejun Heoe8e06192006-04-01 01:38:18 +09002043 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2044 dev = &ap->device[i];
2045
2046 if (!ata_dev_enabled(dev) || !dev->dma_mode)
2047 continue;
2048
2049 dev->xfer_mode = dev->dma_mode;
2050 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
2051 if (ap->ops->set_dmamode)
2052 ap->ops->set_dmamode(ap, dev);
2053 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054
2055 /* step 4: update devices' xfer mode */
Tejun Heo83206a22006-03-24 15:25:31 +09002056 for (i = 0; i < ATA_MAX_DEVICES; i++) {
Tejun Heoe8e06192006-04-01 01:38:18 +09002057 dev = &ap->device[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058
Tejun Heoe1211e32006-04-01 01:38:18 +09002059 if (!ata_dev_enabled(dev))
Tejun Heo83206a22006-03-24 15:25:31 +09002060 continue;
2061
Tejun Heo5bbc53f2006-04-01 01:38:17 +09002062 rc = ata_dev_set_mode(ap, dev);
2063 if (rc)
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002064 goto out;
Tejun Heo83206a22006-03-24 15:25:31 +09002065 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
Tejun Heoe8e06192006-04-01 01:38:18 +09002067 /* Record simplex status. If we selected DMA then the other
2068 * host channels are not permitted to do so.
Alan Cox5444a6f2006-03-27 18:58:20 +01002069 */
Alan Cox5444a6f2006-03-27 18:58:20 +01002070 if (used_dma && (ap->host_set->flags & ATA_HOST_SIMPLEX))
2071 ap->host_set->simplex_claimed = 1;
2072
Tejun Heoe8e06192006-04-01 01:38:18 +09002073 /* step5: chip specific finalisation */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 if (ap->ops->post_set_mode)
2075 ap->ops->post_set_mode(ap);
2076
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002077 out:
2078 if (rc)
2079 *r_failed_dev = dev;
2080 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081}
2082
2083/**
Jeff Garzik1fdffbc2006-02-09 05:15:27 -05002084 * ata_tf_to_host - issue ATA taskfile to host controller
2085 * @ap: port to which command is being issued
2086 * @tf: ATA taskfile register set
2087 *
2088 * Issues ATA taskfile register set to ATA host controller,
2089 * with proper synchronization with interrupt handler and
2090 * other threads.
2091 *
2092 * LOCKING:
2093 * spin_lock_irqsave(host_set lock)
2094 */
2095
2096static inline void ata_tf_to_host(struct ata_port *ap,
2097 const struct ata_taskfile *tf)
2098{
2099 ap->ops->tf_load(ap, tf);
2100 ap->ops->exec_command(ap, tf);
2101}
2102
2103/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 * ata_busy_sleep - sleep until BSY clears, or timeout
2105 * @ap: port containing status register to be polled
2106 * @tmout_pat: impatience timeout
2107 * @tmout: overall timeout
2108 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002109 * Sleep until ATA Status register bit BSY clears,
2110 * or a timeout occurs.
2111 *
2112 * LOCKING: None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 */
2114
Tejun Heo6f8b9952006-01-24 17:05:21 +09002115unsigned int ata_busy_sleep (struct ata_port *ap,
2116 unsigned long tmout_pat, unsigned long tmout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117{
2118 unsigned long timer_start, timeout;
2119 u8 status;
2120
2121 status = ata_busy_wait(ap, ATA_BUSY, 300);
2122 timer_start = jiffies;
2123 timeout = timer_start + tmout_pat;
2124 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2125 msleep(50);
2126 status = ata_busy_wait(ap, ATA_BUSY, 3);
2127 }
2128
2129 if (status & ATA_BUSY)
2130 printk(KERN_WARNING "ata%u is slow to respond, "
2131 "please be patient\n", ap->id);
2132
2133 timeout = timer_start + tmout;
2134 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2135 msleep(50);
2136 status = ata_chk_status(ap);
2137 }
2138
2139 if (status & ATA_BUSY) {
2140 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
2141 ap->id, tmout / HZ);
2142 return 1;
2143 }
2144
2145 return 0;
2146}
2147
2148static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
2149{
2150 struct ata_ioports *ioaddr = &ap->ioaddr;
2151 unsigned int dev0 = devmask & (1 << 0);
2152 unsigned int dev1 = devmask & (1 << 1);
2153 unsigned long timeout;
2154
2155 /* if device 0 was found in ata_devchk, wait for its
2156 * BSY bit to clear
2157 */
2158 if (dev0)
2159 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2160
2161 /* if device 1 was found in ata_devchk, wait for
2162 * register access, then wait for BSY to clear
2163 */
2164 timeout = jiffies + ATA_TMOUT_BOOT;
2165 while (dev1) {
2166 u8 nsect, lbal;
2167
2168 ap->ops->dev_select(ap, 1);
2169 if (ap->flags & ATA_FLAG_MMIO) {
2170 nsect = readb((void __iomem *) ioaddr->nsect_addr);
2171 lbal = readb((void __iomem *) ioaddr->lbal_addr);
2172 } else {
2173 nsect = inb(ioaddr->nsect_addr);
2174 lbal = inb(ioaddr->lbal_addr);
2175 }
2176 if ((nsect == 1) && (lbal == 1))
2177 break;
2178 if (time_after(jiffies, timeout)) {
2179 dev1 = 0;
2180 break;
2181 }
2182 msleep(50); /* give drive a breather */
2183 }
2184 if (dev1)
2185 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2186
2187 /* is all this really necessary? */
2188 ap->ops->dev_select(ap, 0);
2189 if (dev1)
2190 ap->ops->dev_select(ap, 1);
2191 if (dev0)
2192 ap->ops->dev_select(ap, 0);
2193}
2194
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195static unsigned int ata_bus_softreset(struct ata_port *ap,
2196 unsigned int devmask)
2197{
2198 struct ata_ioports *ioaddr = &ap->ioaddr;
2199
2200 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
2201
2202 /* software reset. causes dev0 to be selected */
2203 if (ap->flags & ATA_FLAG_MMIO) {
2204 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2205 udelay(20); /* FIXME: flush */
2206 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
2207 udelay(20); /* FIXME: flush */
2208 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2209 } else {
2210 outb(ap->ctl, ioaddr->ctl_addr);
2211 udelay(10);
2212 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2213 udelay(10);
2214 outb(ap->ctl, ioaddr->ctl_addr);
2215 }
2216
2217 /* spec mandates ">= 2ms" before checking status.
2218 * We wait 150ms, because that was the magic delay used for
2219 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
2220 * between when the ATA command register is written, and then
2221 * status is checked. Because waiting for "a while" before
2222 * checking status is fine, post SRST, we perform this magic
2223 * delay here as well.
Alan Cox09c7ad72006-03-22 15:52:40 +00002224 *
2225 * Old drivers/ide uses the 2mS rule and then waits for ready
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 */
2227 msleep(150);
2228
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002229 /* Before we perform post reset processing we want to see if
Tejun Heo298a41c2006-03-25 02:58:13 +09002230 * the bus shows 0xFF because the odd clown forgets the D7
2231 * pulldown resistor.
2232 */
Alan Cox09c7ad72006-03-22 15:52:40 +00002233 if (ata_check_status(ap) == 0xFF)
Tejun Heo298a41c2006-03-25 02:58:13 +09002234 return AC_ERR_OTHER;
Alan Cox09c7ad72006-03-22 15:52:40 +00002235
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 ata_bus_post_reset(ap, devmask);
2237
2238 return 0;
2239}
2240
2241/**
2242 * ata_bus_reset - reset host port and associated ATA channel
2243 * @ap: port to reset
2244 *
2245 * This is typically the first time we actually start issuing
2246 * commands to the ATA channel. We wait for BSY to clear, then
2247 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
2248 * result. Determine what devices, if any, are on the channel
2249 * by looking at the device 0/1 error register. Look at the signature
2250 * stored in each device's taskfile registers, to determine if
2251 * the device is ATA or ATAPI.
2252 *
2253 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002254 * PCI/etc. bus probe sem.
2255 * Obtains host_set lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 *
2257 * SIDE EFFECTS:
Tejun Heo198e0fe2006-04-02 18:51:52 +09002258 * Sets ATA_FLAG_DISABLED if bus reset fails.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 */
2260
2261void ata_bus_reset(struct ata_port *ap)
2262{
2263 struct ata_ioports *ioaddr = &ap->ioaddr;
2264 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2265 u8 err;
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002266 unsigned int dev0, dev1 = 0, devmask = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267
2268 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
2269
2270 /* determine if device 0/1 are present */
2271 if (ap->flags & ATA_FLAG_SATA_RESET)
2272 dev0 = 1;
2273 else {
2274 dev0 = ata_devchk(ap, 0);
2275 if (slave_possible)
2276 dev1 = ata_devchk(ap, 1);
2277 }
2278
2279 if (dev0)
2280 devmask |= (1 << 0);
2281 if (dev1)
2282 devmask |= (1 << 1);
2283
2284 /* select device 0 again */
2285 ap->ops->dev_select(ap, 0);
2286
2287 /* issue bus reset */
2288 if (ap->flags & ATA_FLAG_SRST)
Tejun Heoaec5c3c2006-03-25 01:33:34 +09002289 if (ata_bus_softreset(ap, devmask))
2290 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291
2292 /*
2293 * determine by signature whether we have ATA or ATAPI devices
2294 */
Tejun Heob4dc7622006-01-24 17:05:22 +09002295 ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 if ((slave_possible) && (err != 0x81))
Tejun Heob4dc7622006-01-24 17:05:22 +09002297 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298
2299 /* re-enable interrupts */
2300 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2301 ata_irq_on(ap);
2302
2303 /* is double-select really necessary? */
2304 if (ap->device[1].class != ATA_DEV_NONE)
2305 ap->ops->dev_select(ap, 1);
2306 if (ap->device[0].class != ATA_DEV_NONE)
2307 ap->ops->dev_select(ap, 0);
2308
2309 /* if no devices were detected, disable this port */
2310 if ((ap->device[0].class == ATA_DEV_NONE) &&
2311 (ap->device[1].class == ATA_DEV_NONE))
2312 goto err_out;
2313
2314 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2315 /* set up device control for ATA_FLAG_SATA_RESET */
2316 if (ap->flags & ATA_FLAG_MMIO)
2317 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2318 else
2319 outb(ap->ctl, ioaddr->ctl_addr);
2320 }
2321
2322 DPRINTK("EXIT\n");
2323 return;
2324
2325err_out:
2326 printk(KERN_ERR "ata%u: disabling port\n", ap->id);
2327 ap->ops->port_disable(ap);
2328
2329 DPRINTK("EXIT\n");
2330}
2331
Tejun Heo7a7921e2006-02-02 18:20:00 +09002332static int sata_phy_resume(struct ata_port *ap)
2333{
2334 unsigned long timeout = jiffies + (HZ * 5);
Tejun Heo852ee162006-04-01 01:38:18 +09002335 u32 scontrol, sstatus;
Tejun Heo7a7921e2006-02-02 18:20:00 +09002336
Tejun Heo852ee162006-04-01 01:38:18 +09002337 scontrol = scr_read(ap, SCR_CONTROL);
2338 scontrol = (scontrol & 0x0f0) | 0x300;
2339 scr_write_flush(ap, SCR_CONTROL, scontrol);
Tejun Heo7a7921e2006-02-02 18:20:00 +09002340
2341 /* Wait for phy to become ready, if necessary. */
2342 do {
2343 msleep(200);
2344 sstatus = scr_read(ap, SCR_STATUS);
2345 if ((sstatus & 0xf) != 1)
2346 return 0;
2347 } while (time_before(jiffies, timeout));
2348
2349 return -1;
2350}
2351
Tejun Heoc2bd5802006-01-24 17:05:22 +09002352/**
Tejun Heo8a19ac82006-02-02 18:20:00 +09002353 * ata_std_probeinit - initialize probing
2354 * @ap: port to be probed
2355 *
2356 * @ap is about to be probed. Initialize it. This function is
2357 * to be used as standard callback for ata_drive_probe_reset().
Tejun Heo3a397462006-02-10 23:58:48 +09002358 *
2359 * NOTE!!! Do not use this function as probeinit if a low level
2360 * driver implements only hardreset. Just pass NULL as probeinit
2361 * in that case. Using this function is probably okay but doing
2362 * so makes reset sequence different from the original
2363 * ->phy_reset implementation and Jeff nervous. :-P
Tejun Heo8a19ac82006-02-02 18:20:00 +09002364 */
Alan Cox17efc5f2006-03-27 19:01:32 +01002365void ata_std_probeinit(struct ata_port *ap)
Tejun Heo8a19ac82006-02-02 18:20:00 +09002366{
Alan Cox17efc5f2006-03-27 19:01:32 +01002367 if ((ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read) {
Tejun Heo1c3fae42006-04-02 20:53:28 +09002368 u32 spd;
2369
Tejun Heo8a19ac82006-02-02 18:20:00 +09002370 sata_phy_resume(ap);
Tejun Heo1c3fae42006-04-02 20:53:28 +09002371
2372 spd = (scr_read(ap, SCR_CONTROL) & 0xf0) >> 4;
2373 if (spd)
2374 ap->sata_spd_limit &= (1 << spd) - 1;
2375
Tejun Heo3a397462006-02-10 23:58:48 +09002376 if (sata_dev_present(ap))
2377 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2378 }
Tejun Heo8a19ac82006-02-02 18:20:00 +09002379}
2380
2381/**
Tejun Heoc2bd5802006-01-24 17:05:22 +09002382 * ata_std_softreset - reset host port via ATA SRST
2383 * @ap: port to reset
2384 * @verbose: fail verbosely
2385 * @classes: resulting classes of attached devices
2386 *
2387 * Reset host port using ATA SRST. This function is to be used
2388 * as standard callback for ata_drive_*_reset() functions.
2389 *
2390 * LOCKING:
2391 * Kernel thread context (may sleep)
2392 *
2393 * RETURNS:
2394 * 0 on success, -errno otherwise.
2395 */
2396int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
2397{
2398 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2399 unsigned int devmask = 0, err_mask;
2400 u8 err;
2401
2402 DPRINTK("ENTER\n");
2403
Tejun Heo3a397462006-02-10 23:58:48 +09002404 if (ap->ops->scr_read && !sata_dev_present(ap)) {
2405 classes[0] = ATA_DEV_NONE;
2406 goto out;
2407 }
2408
Tejun Heoc2bd5802006-01-24 17:05:22 +09002409 /* determine if device 0/1 are present */
2410 if (ata_devchk(ap, 0))
2411 devmask |= (1 << 0);
2412 if (slave_possible && ata_devchk(ap, 1))
2413 devmask |= (1 << 1);
2414
Tejun Heoc2bd5802006-01-24 17:05:22 +09002415 /* select device 0 again */
2416 ap->ops->dev_select(ap, 0);
2417
2418 /* issue bus reset */
2419 DPRINTK("about to softreset, devmask=%x\n", devmask);
2420 err_mask = ata_bus_softreset(ap, devmask);
2421 if (err_mask) {
2422 if (verbose)
2423 printk(KERN_ERR "ata%u: SRST failed (err_mask=0x%x)\n",
2424 ap->id, err_mask);
2425 else
2426 DPRINTK("EXIT, softreset failed (err_mask=0x%x)\n",
2427 err_mask);
2428 return -EIO;
2429 }
2430
2431 /* determine by signature whether we have ATA or ATAPI devices */
2432 classes[0] = ata_dev_try_classify(ap, 0, &err);
2433 if (slave_possible && err != 0x81)
2434 classes[1] = ata_dev_try_classify(ap, 1, &err);
2435
Tejun Heo3a397462006-02-10 23:58:48 +09002436 out:
Tejun Heoc2bd5802006-01-24 17:05:22 +09002437 DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
2438 return 0;
2439}
2440
2441/**
2442 * sata_std_hardreset - reset host port via SATA phy reset
2443 * @ap: port to reset
2444 * @verbose: fail verbosely
2445 * @class: resulting class of attached device
2446 *
2447 * SATA phy-reset host port using DET bits of SControl register.
2448 * This function is to be used as standard callback for
2449 * ata_drive_*_reset().
2450 *
2451 * LOCKING:
2452 * Kernel thread context (may sleep)
2453 *
2454 * RETURNS:
2455 * 0 on success, -errno otherwise.
2456 */
2457int sata_std_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
2458{
Tejun Heo852ee162006-04-01 01:38:18 +09002459 u32 scontrol;
2460
Tejun Heoc2bd5802006-01-24 17:05:22 +09002461 DPRINTK("ENTER\n");
2462
Tejun Heo1c3fae42006-04-02 20:53:28 +09002463 if (ata_set_sata_spd_needed(ap)) {
2464 /* SATA spec says nothing about how to reconfigure
2465 * spd. To be on the safe side, turn off phy during
2466 * reconfiguration. This works for at least ICH7 AHCI
2467 * and Sil3124.
2468 */
2469 scontrol = scr_read(ap, SCR_CONTROL);
2470 scontrol = (scontrol & 0x0f0) | 0x302;
2471 scr_write_flush(ap, SCR_CONTROL, scontrol);
2472
2473 ata_set_sata_spd(ap);
2474 }
2475
2476 /* issue phy wake/reset */
Tejun Heo852ee162006-04-01 01:38:18 +09002477 scontrol = scr_read(ap, SCR_CONTROL);
2478 scontrol = (scontrol & 0x0f0) | 0x301;
2479 scr_write_flush(ap, SCR_CONTROL, scontrol);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002480
Tejun Heo1c3fae42006-04-02 20:53:28 +09002481 /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
Tejun Heoc2bd5802006-01-24 17:05:22 +09002482 * 10.4.2 says at least 1 ms.
2483 */
2484 msleep(1);
2485
Tejun Heo1c3fae42006-04-02 20:53:28 +09002486 /* bring phy back */
Tejun Heo7a7921e2006-02-02 18:20:00 +09002487 sata_phy_resume(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002488
Tejun Heoc2bd5802006-01-24 17:05:22 +09002489 /* TODO: phy layer with polling, timeouts, etc. */
2490 if (!sata_dev_present(ap)) {
2491 *class = ATA_DEV_NONE;
2492 DPRINTK("EXIT, link offline\n");
2493 return 0;
2494 }
2495
2496 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
2497 if (verbose)
2498 printk(KERN_ERR "ata%u: COMRESET failed "
2499 "(device not ready)\n", ap->id);
2500 else
2501 DPRINTK("EXIT, device not ready\n");
2502 return -EIO;
2503 }
2504
Tejun Heo3a397462006-02-10 23:58:48 +09002505 ap->ops->dev_select(ap, 0); /* probably unnecessary */
2506
Tejun Heoc2bd5802006-01-24 17:05:22 +09002507 *class = ata_dev_try_classify(ap, 0, NULL);
2508
2509 DPRINTK("EXIT, class=%u\n", *class);
2510 return 0;
2511}
2512
2513/**
2514 * ata_std_postreset - standard postreset callback
2515 * @ap: the target ata_port
2516 * @classes: classes of attached devices
2517 *
2518 * This function is invoked after a successful reset. Note that
2519 * the device might have been reset more than once using
2520 * different reset methods before postreset is invoked.
Tejun Heoc2bd5802006-01-24 17:05:22 +09002521 *
2522 * This function is to be used as standard callback for
2523 * ata_drive_*_reset().
2524 *
2525 * LOCKING:
2526 * Kernel thread context (may sleep)
2527 */
2528void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
2529{
2530 DPRINTK("ENTER\n");
2531
Tejun Heo56497bd2006-02-15 15:01:42 +09002532 /* set cable type if it isn't already set */
Tejun Heoc2bd5802006-01-24 17:05:22 +09002533 if (ap->cbl == ATA_CBL_NONE && ap->flags & ATA_FLAG_SATA)
2534 ap->cbl = ATA_CBL_SATA;
2535
2536 /* print link status */
2537 if (ap->cbl == ATA_CBL_SATA)
2538 sata_print_link_status(ap);
2539
Tejun Heo3a397462006-02-10 23:58:48 +09002540 /* re-enable interrupts */
2541 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2542 ata_irq_on(ap);
Tejun Heoc2bd5802006-01-24 17:05:22 +09002543
2544 /* is double-select really necessary? */
2545 if (classes[0] != ATA_DEV_NONE)
2546 ap->ops->dev_select(ap, 1);
2547 if (classes[1] != ATA_DEV_NONE)
2548 ap->ops->dev_select(ap, 0);
2549
Tejun Heo3a397462006-02-10 23:58:48 +09002550 /* bail out if no device is present */
2551 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2552 DPRINTK("EXIT, no device\n");
2553 return;
2554 }
2555
2556 /* set up device control */
2557 if (ap->ioaddr.ctl_addr) {
2558 if (ap->flags & ATA_FLAG_MMIO)
2559 writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
2560 else
2561 outb(ap->ctl, ap->ioaddr.ctl_addr);
2562 }
Tejun Heoc2bd5802006-01-24 17:05:22 +09002563
2564 DPRINTK("EXIT\n");
2565}
2566
2567/**
2568 * ata_std_probe_reset - standard probe reset method
2569 * @ap: prot to perform probe-reset
2570 * @classes: resulting classes of attached devices
2571 *
2572 * The stock off-the-shelf ->probe_reset method.
2573 *
2574 * LOCKING:
2575 * Kernel thread context (may sleep)
2576 *
2577 * RETURNS:
2578 * 0 on success, -errno otherwise.
2579 */
2580int ata_std_probe_reset(struct ata_port *ap, unsigned int *classes)
2581{
2582 ata_reset_fn_t hardreset;
2583
2584 hardreset = NULL;
Tejun Heob911fc32006-02-02 18:20:00 +09002585 if (ap->flags & ATA_FLAG_SATA && ap->ops->scr_read)
Tejun Heoc2bd5802006-01-24 17:05:22 +09002586 hardreset = sata_std_hardreset;
2587
Tejun Heo8a19ac82006-02-02 18:20:00 +09002588 return ata_drive_probe_reset(ap, ata_std_probeinit,
Tejun Heo7944ea92006-02-02 18:20:00 +09002589 ata_std_softreset, hardreset,
Tejun Heoc2bd5802006-01-24 17:05:22 +09002590 ata_std_postreset, classes);
2591}
2592
Tejun Heo9974e7c2006-04-01 01:38:17 +09002593static int ata_do_reset(struct ata_port *ap,
2594 ata_reset_fn_t reset, ata_postreset_fn_t postreset,
2595 int verbose, unsigned int *classes)
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002596{
2597 int i, rc;
2598
2599 for (i = 0; i < ATA_MAX_DEVICES; i++)
2600 classes[i] = ATA_DEV_UNKNOWN;
2601
Tejun Heo9974e7c2006-04-01 01:38:17 +09002602 rc = reset(ap, verbose, classes);
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002603 if (rc)
2604 return rc;
2605
2606 /* If any class isn't ATA_DEV_UNKNOWN, consider classification
2607 * is complete and convert all ATA_DEV_UNKNOWN to
2608 * ATA_DEV_NONE.
2609 */
2610 for (i = 0; i < ATA_MAX_DEVICES; i++)
2611 if (classes[i] != ATA_DEV_UNKNOWN)
2612 break;
2613
2614 if (i < ATA_MAX_DEVICES)
2615 for (i = 0; i < ATA_MAX_DEVICES; i++)
2616 if (classes[i] == ATA_DEV_UNKNOWN)
2617 classes[i] = ATA_DEV_NONE;
2618
2619 if (postreset)
2620 postreset(ap, classes);
2621
Tejun Heo9974e7c2006-04-01 01:38:17 +09002622 return 0;
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002623}
2624
2625/**
2626 * ata_drive_probe_reset - Perform probe reset with given methods
2627 * @ap: port to reset
Tejun Heo7944ea92006-02-02 18:20:00 +09002628 * @probeinit: probeinit method (can be NULL)
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002629 * @softreset: softreset method (can be NULL)
2630 * @hardreset: hardreset method (can be NULL)
2631 * @postreset: postreset method (can be NULL)
2632 * @classes: resulting classes of attached devices
2633 *
2634 * Reset the specified port and classify attached devices using
2635 * given methods. This function prefers softreset but tries all
2636 * possible reset sequences to reset and classify devices. This
2637 * function is intended to be used for constructing ->probe_reset
2638 * callback by low level drivers.
2639 *
2640 * Reset methods should follow the following rules.
2641 *
2642 * - Return 0 on sucess, -errno on failure.
2643 * - If classification is supported, fill classes[] with
2644 * recognized class codes.
2645 * - If classification is not supported, leave classes[] alone.
2646 * - If verbose is non-zero, print error message on failure;
2647 * otherwise, shut up.
2648 *
2649 * LOCKING:
2650 * Kernel thread context (may sleep)
2651 *
2652 * RETURNS:
2653 * 0 on success, -EINVAL if no reset method is avaliable, -ENODEV
2654 * if classification fails, and any error code from reset
2655 * methods.
2656 */
Tejun Heo7944ea92006-02-02 18:20:00 +09002657int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002658 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2659 ata_postreset_fn_t postreset, unsigned int *classes)
2660{
2661 int rc = -EINVAL;
2662
Tejun Heo7944ea92006-02-02 18:20:00 +09002663 if (probeinit)
2664 probeinit(ap);
2665
Tejun Heo90dac022006-04-02 17:54:46 +09002666 if (softreset && !ata_set_sata_spd_needed(ap)) {
Tejun Heo9974e7c2006-04-01 01:38:17 +09002667 rc = ata_do_reset(ap, softreset, postreset, 0, classes);
2668 if (rc == 0 && classes[0] != ATA_DEV_UNKNOWN)
2669 goto done;
Tejun Heoedbabd82006-04-02 20:55:02 +09002670 printk(KERN_INFO "ata%u: softreset failed, will try "
2671 "hardreset in 5 secs\n", ap->id);
2672 ssleep(5);
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002673 }
2674
2675 if (!hardreset)
Tejun Heo9974e7c2006-04-01 01:38:17 +09002676 goto done;
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002677
Tejun Heo90dac022006-04-02 17:54:46 +09002678 while (1) {
2679 rc = ata_do_reset(ap, hardreset, postreset, 0, classes);
2680 if (rc == 0) {
2681 if (classes[0] != ATA_DEV_UNKNOWN)
2682 goto done;
2683 break;
2684 }
2685
2686 if (ata_down_sata_spd_limit(ap))
2687 goto done;
Tejun Heoedbabd82006-04-02 20:55:02 +09002688
2689 printk(KERN_INFO "ata%u: hardreset failed, will retry "
2690 "in 5 secs\n", ap->id);
2691 ssleep(5);
Tejun Heo90dac022006-04-02 17:54:46 +09002692 }
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002693
Tejun Heoedbabd82006-04-02 20:55:02 +09002694 if (softreset) {
2695 printk(KERN_INFO "ata%u: hardreset succeeded without "
2696 "classification, will retry softreset in 5 secs\n",
2697 ap->id);
2698 ssleep(5);
2699
Tejun Heo9974e7c2006-04-01 01:38:17 +09002700 rc = ata_do_reset(ap, softreset, postreset, 0, classes);
Tejun Heoedbabd82006-04-02 20:55:02 +09002701 }
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002702
Tejun Heo9974e7c2006-04-01 01:38:17 +09002703 done:
2704 if (rc == 0 && classes[0] == ATA_DEV_UNKNOWN)
2705 rc = -ENODEV;
Tejun Heoa62c0fc2006-01-24 17:05:22 +09002706 return rc;
2707}
2708
Tejun Heo623a3122006-03-05 17:55:58 +09002709/**
2710 * ata_dev_same_device - Determine whether new ID matches configured device
2711 * @ap: port on which the device to compare against resides
2712 * @dev: device to compare against
2713 * @new_class: class of the new device
2714 * @new_id: IDENTIFY page of the new device
2715 *
2716 * Compare @new_class and @new_id against @dev and determine
2717 * whether @dev is the device indicated by @new_class and
2718 * @new_id.
2719 *
2720 * LOCKING:
2721 * None.
2722 *
2723 * RETURNS:
2724 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
2725 */
2726static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
2727 unsigned int new_class, const u16 *new_id)
2728{
2729 const u16 *old_id = dev->id;
2730 unsigned char model[2][41], serial[2][21];
2731 u64 new_n_sectors;
2732
2733 if (dev->class != new_class) {
2734 printk(KERN_INFO
2735 "ata%u: dev %u class mismatch %d != %d\n",
2736 ap->id, dev->devno, dev->class, new_class);
2737 return 0;
2738 }
2739
2740 ata_id_c_string(old_id, model[0], ATA_ID_PROD_OFS, sizeof(model[0]));
2741 ata_id_c_string(new_id, model[1], ATA_ID_PROD_OFS, sizeof(model[1]));
2742 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO_OFS, sizeof(serial[0]));
2743 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO_OFS, sizeof(serial[1]));
2744 new_n_sectors = ata_id_n_sectors(new_id);
2745
2746 if (strcmp(model[0], model[1])) {
2747 printk(KERN_INFO
2748 "ata%u: dev %u model number mismatch '%s' != '%s'\n",
2749 ap->id, dev->devno, model[0], model[1]);
2750 return 0;
2751 }
2752
2753 if (strcmp(serial[0], serial[1])) {
2754 printk(KERN_INFO
2755 "ata%u: dev %u serial number mismatch '%s' != '%s'\n",
2756 ap->id, dev->devno, serial[0], serial[1]);
2757 return 0;
2758 }
2759
2760 if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
2761 printk(KERN_INFO
2762 "ata%u: dev %u n_sectors mismatch %llu != %llu\n",
2763 ap->id, dev->devno, (unsigned long long)dev->n_sectors,
2764 (unsigned long long)new_n_sectors);
2765 return 0;
2766 }
2767
2768 return 1;
2769}
2770
2771/**
2772 * ata_dev_revalidate - Revalidate ATA device
2773 * @ap: port on which the device to revalidate resides
2774 * @dev: device to revalidate
2775 * @post_reset: is this revalidation after reset?
2776 *
2777 * Re-read IDENTIFY page and make sure @dev is still attached to
2778 * the port.
2779 *
2780 * LOCKING:
2781 * Kernel thread context (may sleep)
2782 *
2783 * RETURNS:
2784 * 0 on success, negative errno otherwise
2785 */
2786int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
2787 int post_reset)
2788{
Tejun Heo5eb45c02006-04-02 18:51:52 +09002789 unsigned int class = dev->class;
2790 u16 *id = NULL;
Tejun Heo623a3122006-03-05 17:55:58 +09002791 int rc;
2792
Tejun Heo5eb45c02006-04-02 18:51:52 +09002793 if (!ata_dev_enabled(dev)) {
2794 rc = -ENODEV;
2795 goto fail;
2796 }
Tejun Heo623a3122006-03-05 17:55:58 +09002797
2798 /* allocate & read ID data */
2799 rc = ata_dev_read_id(ap, dev, &class, post_reset, &id);
2800 if (rc)
2801 goto fail;
2802
2803 /* is the device still there? */
2804 if (!ata_dev_same_device(ap, dev, class, id)) {
2805 rc = -ENODEV;
2806 goto fail;
2807 }
2808
2809 kfree(dev->id);
2810 dev->id = id;
2811
2812 /* configure device according to the new ID */
Tejun Heo5eb45c02006-04-02 18:51:52 +09002813 rc = ata_dev_configure(ap, dev, 0);
2814 if (rc == 0)
2815 return 0;
Tejun Heo623a3122006-03-05 17:55:58 +09002816
2817 fail:
2818 printk(KERN_ERR "ata%u: dev %u revalidation failed (errno=%d)\n",
2819 ap->id, dev->devno, rc);
2820 kfree(id);
2821 return rc;
2822}
2823
Arjan van de Ven98ac62d2005-11-28 10:06:23 +01002824static const char * const ata_dma_blacklist [] = {
Alan Coxf4b15fe2006-03-22 15:54:04 +00002825 "WDC AC11000H", NULL,
2826 "WDC AC22100H", NULL,
2827 "WDC AC32500H", NULL,
2828 "WDC AC33100H", NULL,
2829 "WDC AC31600H", NULL,
2830 "WDC AC32100H", "24.09P07",
2831 "WDC AC23200L", "21.10N21",
2832 "Compaq CRD-8241B", NULL,
2833 "CRD-8400B", NULL,
2834 "CRD-8480B", NULL,
2835 "CRD-8482B", NULL,
2836 "CRD-84", NULL,
2837 "SanDisk SDP3B", NULL,
2838 "SanDisk SDP3B-64", NULL,
2839 "SANYO CD-ROM CRD", NULL,
2840 "HITACHI CDR-8", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002841 "HITACHI CDR-8335", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002842 "HITACHI CDR-8435", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002843 "Toshiba CD-ROM XM-6202B", NULL,
2844 "TOSHIBA CD-ROM XM-1702BC", NULL,
2845 "CD-532E-A", NULL,
2846 "E-IDE CD-ROM CR-840", NULL,
2847 "CD-ROM Drive/F5A", NULL,
2848 "WPI CDD-820", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002849 "SAMSUNG CD-ROM SC-148C", NULL,
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002850 "SAMSUNG CD-ROM SC", NULL,
Alan Coxf4b15fe2006-03-22 15:54:04 +00002851 "SanDisk SDP3B-64", NULL,
2852 "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
2853 "_NEC DV5800A", NULL,
2854 "SAMSUNG CD-ROM SN-124", "N001"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855};
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002856
Alan Coxf4b15fe2006-03-22 15:54:04 +00002857static int ata_strim(char *s, size_t len)
2858{
2859 len = strnlen(s, len);
2860
2861 /* ATAPI specifies that empty space is blank-filled; remove blanks */
2862 while ((len > 0) && (s[len - 1] == ' ')) {
2863 len--;
2864 s[len] = 0;
2865 }
2866 return len;
2867}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868
Jeff Garzik057ace52005-10-22 14:27:05 -04002869static int ata_dma_blacklisted(const struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870{
Alan Coxf4b15fe2006-03-22 15:54:04 +00002871 unsigned char model_num[40];
2872 unsigned char model_rev[16];
2873 unsigned int nlen, rlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 int i;
2875
Alan Coxf4b15fe2006-03-22 15:54:04 +00002876 ata_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
2877 sizeof(model_num));
2878 ata_id_string(dev->id, model_rev, ATA_ID_FW_REV_OFS,
2879 sizeof(model_rev));
2880 nlen = ata_strim(model_num, sizeof(model_num));
2881 rlen = ata_strim(model_rev, sizeof(model_rev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882
Alan Coxf4b15fe2006-03-22 15:54:04 +00002883 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i += 2) {
2884 if (!strncmp(ata_dma_blacklist[i], model_num, nlen)) {
2885 if (ata_dma_blacklist[i+1] == NULL)
2886 return 1;
2887 if (!strncmp(ata_dma_blacklist[i], model_rev, rlen))
2888 return 1;
2889 }
2890 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891 return 0;
2892}
2893
Tejun Heoa6d5a512006-03-06 04:31:57 +09002894/**
2895 * ata_dev_xfermask - Compute supported xfermask of the given device
2896 * @ap: Port on which the device to compute xfermask for resides
2897 * @dev: Device to compute xfermask for
2898 *
Tejun Heoacf356b2006-03-24 14:07:50 +09002899 * Compute supported xfermask of @dev and store it in
2900 * dev->*_mask. This function is responsible for applying all
2901 * known limits including host controller limits, device
2902 * blacklist, etc...
Tejun Heoa6d5a512006-03-06 04:31:57 +09002903 *
Tejun Heo600511e2006-03-25 11:14:07 +09002904 * FIXME: The current implementation limits all transfer modes to
2905 * the fastest of the lowested device on the port. This is not
Tejun Heo05c8e0a2006-03-25 14:28:57 +09002906 * required on most controllers.
Tejun Heo600511e2006-03-25 11:14:07 +09002907 *
Tejun Heoa6d5a512006-03-06 04:31:57 +09002908 * LOCKING:
2909 * None.
Tejun Heoa6d5a512006-03-06 04:31:57 +09002910 */
Tejun Heoacf356b2006-03-24 14:07:50 +09002911static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912{
Alan Cox5444a6f2006-03-27 18:58:20 +01002913 struct ata_host_set *hs = ap->host_set;
Tejun Heoa6d5a512006-03-06 04:31:57 +09002914 unsigned long xfer_mask;
2915 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916
Tejun Heo565083e2006-04-02 17:54:47 +09002917 xfer_mask = ata_pack_xfermask(ap->pio_mask,
2918 ap->mwdma_mask, ap->udma_mask);
2919
2920 /* Apply cable rule here. Don't apply it early because when
2921 * we handle hot plug the cable type can itself change.
2922 */
2923 if (ap->cbl == ATA_CBL_PATA40)
2924 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925
Alan Cox5444a6f2006-03-27 18:58:20 +01002926 /* FIXME: Use port-wide xfermask for now */
Tejun Heoa6d5a512006-03-06 04:31:57 +09002927 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2928 struct ata_device *d = &ap->device[i];
Tejun Heo565083e2006-04-02 17:54:47 +09002929
2930 if (ata_dev_absent(d))
Tejun Heoa6d5a512006-03-06 04:31:57 +09002931 continue;
Tejun Heo565083e2006-04-02 17:54:47 +09002932
2933 if (ata_dev_disabled(d)) {
2934 /* to avoid violating device selection timing */
2935 xfer_mask &= ata_pack_xfermask(d->pio_mask,
2936 UINT_MAX, UINT_MAX);
2937 continue;
2938 }
2939
2940 xfer_mask &= ata_pack_xfermask(d->pio_mask,
2941 d->mwdma_mask, d->udma_mask);
Tejun Heoa6d5a512006-03-06 04:31:57 +09002942 xfer_mask &= ata_id_xfermask(d->id);
2943 if (ata_dma_blacklisted(d))
2944 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945 }
2946
Tejun Heoa6d5a512006-03-06 04:31:57 +09002947 if (ata_dma_blacklisted(dev))
2948 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, "
2949 "disabling DMA\n", ap->id, dev->devno);
2950
Alan Cox5444a6f2006-03-27 18:58:20 +01002951 if (hs->flags & ATA_HOST_SIMPLEX) {
2952 if (hs->simplex_claimed)
2953 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
2954 }
Tejun Heo565083e2006-04-02 17:54:47 +09002955
Alan Cox5444a6f2006-03-27 18:58:20 +01002956 if (ap->ops->mode_filter)
2957 xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask);
2958
Tejun Heo565083e2006-04-02 17:54:47 +09002959 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
2960 &dev->mwdma_mask, &dev->udma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961}
2962
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
2965 * @ap: Port associated with device @dev
2966 * @dev: Device to which command will be sent
2967 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04002968 * Issue SET FEATURES - XFER MODE command to device @dev
2969 * on port @ap.
2970 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002972 * PCI/etc. bus probe sem.
Tejun Heo83206a22006-03-24 15:25:31 +09002973 *
2974 * RETURNS:
2975 * 0 on success, AC_ERR_* mask otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976 */
2977
Tejun Heo83206a22006-03-24 15:25:31 +09002978static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
2979 struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980{
Tejun Heoa0123702005-12-13 14:49:31 +09002981 struct ata_taskfile tf;
Tejun Heo83206a22006-03-24 15:25:31 +09002982 unsigned int err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983
2984 /* set up set-features taskfile */
2985 DPRINTK("set features - xfer mode\n");
2986
Tejun Heoa0123702005-12-13 14:49:31 +09002987 ata_tf_init(ap, &tf, dev->devno);
2988 tf.command = ATA_CMD_SET_FEATURES;
2989 tf.feature = SETFEATURES_XFER;
2990 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2991 tf.protocol = ATA_PROT_NODATA;
2992 tf.nsect = dev->xfer_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993
Tejun Heod69cf372006-04-02 18:51:53 +09002994 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995
Tejun Heo83206a22006-03-24 15:25:31 +09002996 DPRINTK("EXIT, err_mask=%x\n", err_mask);
2997 return err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998}
2999
3000/**
Albert Lee8bf62ece2005-05-12 15:29:42 -04003001 * ata_dev_init_params - Issue INIT DEV PARAMS command
3002 * @ap: Port associated with device @dev
3003 * @dev: Device to which command will be sent
3004 *
3005 * LOCKING:
Tejun Heo6aff8f12006-02-15 18:24:09 +09003006 * Kernel thread context (may sleep)
3007 *
3008 * RETURNS:
3009 * 0 on success, AC_ERR_* mask otherwise.
Albert Lee8bf62ece2005-05-12 15:29:42 -04003010 */
3011
Tejun Heo6aff8f12006-02-15 18:24:09 +09003012static unsigned int ata_dev_init_params(struct ata_port *ap,
Albert Lee00b6f5e2006-03-27 16:39:18 +08003013 struct ata_device *dev,
3014 u16 heads,
3015 u16 sectors)
Albert Lee8bf62ece2005-05-12 15:29:42 -04003016{
Tejun Heoa0123702005-12-13 14:49:31 +09003017 struct ata_taskfile tf;
Tejun Heo6aff8f12006-02-15 18:24:09 +09003018 unsigned int err_mask;
Albert Lee8bf62ece2005-05-12 15:29:42 -04003019
3020 /* Number of sectors per track 1-255. Number of heads 1-16 */
3021 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
Albert Lee00b6f5e2006-03-27 16:39:18 +08003022 return AC_ERR_INVALID;
Albert Lee8bf62ece2005-05-12 15:29:42 -04003023
3024 /* set up init dev params taskfile */
3025 DPRINTK("init dev params \n");
3026
Tejun Heoa0123702005-12-13 14:49:31 +09003027 ata_tf_init(ap, &tf, dev->devno);
3028 tf.command = ATA_CMD_INIT_DEV_PARAMS;
3029 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3030 tf.protocol = ATA_PROT_NODATA;
3031 tf.nsect = sectors;
3032 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
Albert Lee8bf62ece2005-05-12 15:29:42 -04003033
Tejun Heod69cf372006-04-02 18:51:53 +09003034 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
Albert Lee8bf62ece2005-05-12 15:29:42 -04003035
Tejun Heo6aff8f12006-02-15 18:24:09 +09003036 DPRINTK("EXIT, err_mask=%x\n", err_mask);
3037 return err_mask;
Albert Lee8bf62ece2005-05-12 15:29:42 -04003038}
3039
3040/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003041 * ata_sg_clean - Unmap DMA memory associated with command
3042 * @qc: Command containing DMA memory to be released
3043 *
3044 * Unmap all mapped DMA memory associated with this command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 *
3046 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003047 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 */
3049
3050static void ata_sg_clean(struct ata_queued_cmd *qc)
3051{
3052 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003053 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003055 void *pad_buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056
Tejun Heoa46314742006-02-11 19:11:13 +09003057 WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
3058 WARN_ON(sg == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059
3060 if (qc->flags & ATA_QCFLAG_SINGLE)
Jeff Garzikf1318832006-02-20 16:55:56 -05003061 WARN_ON(qc->n_elem > 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05003063 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003065 /* if we padded the buffer out to 32-bit bound, and data
3066 * xfer direction is from-device, we must copy from the
3067 * pad buffer back into the supplied buffer
3068 */
3069 if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
3070 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3071
3072 if (qc->flags & ATA_QCFLAG_SG) {
Jeff Garzike1410f22005-11-14 14:06:26 -05003073 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06003074 dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003075 /* restore last sg */
3076 sg[qc->orig_n_elem - 1].length += qc->pad_len;
3077 if (pad_buf) {
3078 struct scatterlist *psg = &qc->pad_sgent;
3079 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3080 memcpy(addr + psg->offset, pad_buf, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05003081 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003082 }
3083 } else {
Tejun Heo2e242fa2006-02-20 23:48:38 +09003084 if (qc->n_elem)
Brian King2f1f6102006-03-23 17:30:15 -06003085 dma_unmap_single(ap->dev,
Jeff Garzike1410f22005-11-14 14:06:26 -05003086 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
3087 dir);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003088 /* restore sg */
3089 sg->length += qc->pad_len;
3090 if (pad_buf)
3091 memcpy(qc->buf_virt + sg->length - qc->pad_len,
3092 pad_buf, qc->pad_len);
3093 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094
3095 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003096 qc->__sg = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097}
3098
3099/**
3100 * ata_fill_sg - Fill PCI IDE PRD table
3101 * @qc: Metadata associated with taskfile to be transferred
3102 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003103 * Fill PCI IDE PRD (scatter-gather) table with segments
3104 * associated with the current disk command.
3105 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106 * LOCKING:
Jeff Garzik780a87f2005-05-30 15:41:05 -04003107 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 *
3109 */
3110static void ata_fill_sg(struct ata_queued_cmd *qc)
3111{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003113 struct scatterlist *sg;
3114 unsigned int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115
Tejun Heoa46314742006-02-11 19:11:13 +09003116 WARN_ON(qc->__sg == NULL);
Jeff Garzikf1318832006-02-20 16:55:56 -05003117 WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118
3119 idx = 0;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003120 ata_for_each_sg(sg, qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 u32 addr, offset;
3122 u32 sg_len, len;
3123
3124 /* determine if physical DMA addr spans 64K boundary.
3125 * Note h/w doesn't support 64-bit, so we unconditionally
3126 * truncate dma_addr_t to u32.
3127 */
3128 addr = (u32) sg_dma_address(sg);
3129 sg_len = sg_dma_len(sg);
3130
3131 while (sg_len) {
3132 offset = addr & 0xffff;
3133 len = sg_len;
3134 if ((offset + sg_len) > 0x10000)
3135 len = 0x10000 - offset;
3136
3137 ap->prd[idx].addr = cpu_to_le32(addr);
3138 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
3139 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
3140
3141 idx++;
3142 sg_len -= len;
3143 addr += len;
3144 }
3145 }
3146
3147 if (idx)
3148 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
3149}
3150/**
3151 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
3152 * @qc: Metadata associated with taskfile to check
3153 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003154 * Allow low-level driver to filter ATA PACKET commands, returning
3155 * a status indicating whether or not it is OK to use DMA for the
3156 * supplied PACKET command.
3157 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003159 * spin_lock_irqsave(host_set lock)
3160 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161 * RETURNS: 0 when ATAPI DMA can be used
3162 * nonzero otherwise
3163 */
3164int ata_check_atapi_dma(struct ata_queued_cmd *qc)
3165{
3166 struct ata_port *ap = qc->ap;
3167 int rc = 0; /* Assume ATAPI DMA is OK by default */
3168
3169 if (ap->ops->check_atapi_dma)
3170 rc = ap->ops->check_atapi_dma(qc);
3171
3172 return rc;
3173}
3174/**
3175 * ata_qc_prep - Prepare taskfile for submission
3176 * @qc: Metadata associated with taskfile to be prepared
3177 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04003178 * Prepare ATA taskfile for submission.
3179 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180 * LOCKING:
3181 * spin_lock_irqsave(host_set lock)
3182 */
3183void ata_qc_prep(struct ata_queued_cmd *qc)
3184{
3185 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
3186 return;
3187
3188 ata_fill_sg(qc);
3189}
3190
Brian Kinge46834c2006-03-17 17:04:03 -06003191void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
3192
Jeff Garzik0cba6322005-05-30 19:49:12 -04003193/**
3194 * ata_sg_init_one - Associate command with memory buffer
3195 * @qc: Command to be associated
3196 * @buf: Memory buffer
3197 * @buflen: Length of memory buffer, in bytes.
3198 *
3199 * Initialize the data-related elements of queued_cmd @qc
3200 * to point to a single memory buffer, @buf of byte length @buflen.
3201 *
3202 * LOCKING:
3203 * spin_lock_irqsave(host_set lock)
3204 */
3205
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
3207{
3208 struct scatterlist *sg;
3209
3210 qc->flags |= ATA_QCFLAG_SINGLE;
3211
3212 memset(&qc->sgent, 0, sizeof(qc->sgent));
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003213 qc->__sg = &qc->sgent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003214 qc->n_elem = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003215 qc->orig_n_elem = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003216 qc->buf_virt = buf;
3217
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003218 sg = qc->__sg;
Jeff Garzikf0612bb2005-10-30 01:58:18 -05003219 sg_init_one(sg, buf, buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220}
3221
Jeff Garzik0cba6322005-05-30 19:49:12 -04003222/**
3223 * ata_sg_init - Associate command with scatter-gather table.
3224 * @qc: Command to be associated
3225 * @sg: Scatter-gather table.
3226 * @n_elem: Number of elements in s/g table.
3227 *
3228 * Initialize the data-related elements of queued_cmd @qc
3229 * to point to a scatter-gather table @sg, containing @n_elem
3230 * elements.
3231 *
3232 * LOCKING:
3233 * spin_lock_irqsave(host_set lock)
3234 */
3235
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
3237 unsigned int n_elem)
3238{
3239 qc->flags |= ATA_QCFLAG_SG;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003240 qc->__sg = sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003241 qc->n_elem = n_elem;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003242 qc->orig_n_elem = n_elem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243}
3244
3245/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003246 * ata_sg_setup_one - DMA-map the memory buffer associated with a command.
3247 * @qc: Command with memory buffer to be mapped.
3248 *
3249 * DMA-map the memory buffer associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003250 *
3251 * LOCKING:
3252 * spin_lock_irqsave(host_set lock)
3253 *
3254 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003255 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003256 */
3257
3258static int ata_sg_setup_one(struct ata_queued_cmd *qc)
3259{
3260 struct ata_port *ap = qc->ap;
3261 int dir = qc->dma_dir;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003262 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003263 dma_addr_t dma_address;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003264 int trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003265
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003266 /* we must lengthen transfers to end on a 32-bit boundary */
3267 qc->pad_len = sg->length & 3;
3268 if (qc->pad_len) {
3269 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3270 struct scatterlist *psg = &qc->pad_sgent;
3271
Tejun Heoa46314742006-02-11 19:11:13 +09003272 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003273
3274 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3275
3276 if (qc->tf.flags & ATA_TFLAG_WRITE)
3277 memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
3278 qc->pad_len);
3279
3280 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3281 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3282 /* trim sg */
3283 sg->length -= qc->pad_len;
Tejun Heo2e242fa2006-02-20 23:48:38 +09003284 if (sg->length == 0)
3285 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003286
3287 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
3288 sg->length, qc->pad_len);
3289 }
3290
Tejun Heo2e242fa2006-02-20 23:48:38 +09003291 if (trim_sg) {
3292 qc->n_elem--;
Jeff Garzike1410f22005-11-14 14:06:26 -05003293 goto skip_map;
3294 }
3295
Brian King2f1f6102006-03-23 17:30:15 -06003296 dma_address = dma_map_single(ap->dev, qc->buf_virt,
Albert Lee32529e02005-05-26 03:49:42 -04003297 sg->length, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003298 if (dma_mapping_error(dma_address)) {
3299 /* restore sg */
3300 sg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003301 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303
3304 sg_dma_address(sg) = dma_address;
Albert Lee32529e02005-05-26 03:49:42 -04003305 sg_dma_len(sg) = sg->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003306
Tejun Heo2e242fa2006-02-20 23:48:38 +09003307skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003308 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
3309 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3310
3311 return 0;
3312}
3313
3314/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04003315 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
3316 * @qc: Command with scatter-gather table to be mapped.
3317 *
3318 * DMA-map the scatter-gather table associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319 *
3320 * LOCKING:
3321 * spin_lock_irqsave(host_set lock)
3322 *
3323 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003324 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003325 *
3326 */
3327
3328static int ata_sg_setup(struct ata_queued_cmd *qc)
3329{
3330 struct ata_port *ap = qc->ap;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003331 struct scatterlist *sg = qc->__sg;
3332 struct scatterlist *lsg = &sg[qc->n_elem - 1];
Jeff Garzike1410f22005-11-14 14:06:26 -05003333 int n_elem, pre_n_elem, dir, trim_sg = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334
3335 VPRINTK("ENTER, ata%u\n", ap->id);
Tejun Heoa46314742006-02-11 19:11:13 +09003336 WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003337
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003338 /* we must lengthen transfers to end on a 32-bit boundary */
3339 qc->pad_len = lsg->length & 3;
3340 if (qc->pad_len) {
3341 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3342 struct scatterlist *psg = &qc->pad_sgent;
3343 unsigned int offset;
3344
Tejun Heoa46314742006-02-11 19:11:13 +09003345 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003346
3347 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3348
3349 /*
3350 * psg->page/offset are used to copy to-be-written
3351 * data in this function or read data in ata_sg_clean.
3352 */
3353 offset = lsg->offset + lsg->length - qc->pad_len;
3354 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
3355 psg->offset = offset_in_page(offset);
3356
3357 if (qc->tf.flags & ATA_TFLAG_WRITE) {
3358 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3359 memcpy(pad_buf, addr + psg->offset, qc->pad_len);
Mark Lorddfa15982005-12-12 23:19:28 -05003360 kunmap_atomic(addr, KM_IRQ0);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003361 }
3362
3363 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3364 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3365 /* trim last sg */
3366 lsg->length -= qc->pad_len;
Jeff Garzike1410f22005-11-14 14:06:26 -05003367 if (lsg->length == 0)
3368 trim_sg = 1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003369
3370 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
3371 qc->n_elem - 1, lsg->length, qc->pad_len);
3372 }
3373
Jeff Garzike1410f22005-11-14 14:06:26 -05003374 pre_n_elem = qc->n_elem;
3375 if (trim_sg && pre_n_elem)
3376 pre_n_elem--;
3377
3378 if (!pre_n_elem) {
3379 n_elem = 0;
3380 goto skip_map;
3381 }
3382
Linus Torvalds1da177e2005-04-16 15:20:36 -07003383 dir = qc->dma_dir;
Brian King2f1f6102006-03-23 17:30:15 -06003384 n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
Tejun Heo537a95d2005-11-05 14:29:01 -05003385 if (n_elem < 1) {
3386 /* restore last sg */
3387 lsg->length += qc->pad_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388 return -1;
Tejun Heo537a95d2005-11-05 14:29:01 -05003389 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003390
3391 DPRINTK("%d sg elements mapped\n", n_elem);
3392
Jeff Garzike1410f22005-11-14 14:06:26 -05003393skip_map:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003394 qc->n_elem = n_elem;
3395
3396 return 0;
3397}
3398
3399/**
Tejun Heo40e8c822005-08-22 17:12:45 +09003400 * ata_poll_qc_complete - turn irq back on and finish qc
3401 * @qc: Command to complete
Randy Dunlap8e8b77d2005-11-01 21:29:27 -08003402 * @err_mask: ATA status register content
Tejun Heo40e8c822005-08-22 17:12:45 +09003403 *
3404 * LOCKING:
3405 * None. (grabs host lock)
3406 */
3407
Albert Leea22e2eb2005-12-05 15:38:02 +08003408void ata_poll_qc_complete(struct ata_queued_cmd *qc)
Tejun Heo40e8c822005-08-22 17:12:45 +09003409{
3410 struct ata_port *ap = qc->ap;
Jeff Garzikb8f61532005-08-25 22:01:20 -04003411 unsigned long flags;
Tejun Heo40e8c822005-08-22 17:12:45 +09003412
Jeff Garzikb8f61532005-08-25 22:01:20 -04003413 spin_lock_irqsave(&ap->host_set->lock, flags);
Tejun Heo40e8c822005-08-22 17:12:45 +09003414 ap->flags &= ~ATA_FLAG_NOINTR;
3415 ata_irq_on(ap);
Albert Leea22e2eb2005-12-05 15:38:02 +08003416 ata_qc_complete(qc);
Jeff Garzikb8f61532005-08-25 22:01:20 -04003417 spin_unlock_irqrestore(&ap->host_set->lock, flags);
Tejun Heo40e8c822005-08-22 17:12:45 +09003418}
3419
3420/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003421 * ata_pio_poll - poll using PIO, depending on current state
Tejun Heoc91af2c2006-04-02 18:51:53 +09003422 * @qc: qc in progress
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423 *
3424 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003425 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 *
3427 * RETURNS:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003428 * timeout value to use
Linus Torvalds1da177e2005-04-16 15:20:36 -07003429 */
Tejun Heoc91af2c2006-04-02 18:51:53 +09003430static unsigned long ata_pio_poll(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003431{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003432 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433 u8 status;
Albert Lee14be71f2005-09-27 17:36:35 +08003434 unsigned int poll_state = HSM_ST_UNKNOWN;
3435 unsigned int reg_state = HSM_ST_UNKNOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003436
Albert Lee14be71f2005-09-27 17:36:35 +08003437 switch (ap->hsm_task_state) {
3438 case HSM_ST:
3439 case HSM_ST_POLL:
3440 poll_state = HSM_ST_POLL;
3441 reg_state = HSM_ST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003442 break;
Albert Lee14be71f2005-09-27 17:36:35 +08003443 case HSM_ST_LAST:
3444 case HSM_ST_LAST_POLL:
3445 poll_state = HSM_ST_LAST_POLL;
3446 reg_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003447 break;
3448 default:
3449 BUG();
3450 break;
3451 }
3452
3453 status = ata_chk_status(ap);
3454 if (status & ATA_BUSY) {
3455 if (time_after(jiffies, ap->pio_task_timeout)) {
Tejun Heo11a56d22006-01-23 13:09:36 +09003456 qc->err_mask |= AC_ERR_TIMEOUT;
Albert Lee7c398332005-11-09 13:03:30 +08003457 ap->hsm_task_state = HSM_ST_TMOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003458 return 0;
3459 }
Albert Lee14be71f2005-09-27 17:36:35 +08003460 ap->hsm_task_state = poll_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461 return ATA_SHORT_PAUSE;
3462 }
3463
Albert Lee14be71f2005-09-27 17:36:35 +08003464 ap->hsm_task_state = reg_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003465 return 0;
3466}
3467
3468/**
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003469 * ata_pio_complete - check if drive is busy or idle
Tejun Heoc91af2c2006-04-02 18:51:53 +09003470 * @qc: qc to complete
Linus Torvalds1da177e2005-04-16 15:20:36 -07003471 *
3472 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003473 * None. (executing in kernel thread context)
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003474 *
3475 * RETURNS:
3476 * Non-zero if qc completed, zero otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 */
Tejun Heoc91af2c2006-04-02 18:51:53 +09003478static int ata_pio_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003479{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003480 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481 u8 drv_stat;
3482
3483 /*
Alan Cox31433ea2005-08-26 15:56:47 +01003484 * This is purely heuristic. This is a fast path. Sometimes when
3485 * we enter, BSY will be cleared in a chk-status or two. If not,
3486 * the drive is probably seeking or something. Snooze for a couple
3487 * msecs, then chk-status again. If still busy, fall back to
Albert Lee14be71f2005-09-27 17:36:35 +08003488 * HSM_ST_POLL state.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489 */
Albert Leefe79e682005-12-06 11:34:59 +08003490 drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
3491 if (drv_stat & ATA_BUSY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003492 msleep(2);
Albert Leefe79e682005-12-06 11:34:59 +08003493 drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
3494 if (drv_stat & ATA_BUSY) {
Albert Lee14be71f2005-09-27 17:36:35 +08003495 ap->hsm_task_state = HSM_ST_LAST_POLL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003497 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498 }
3499 }
3500
3501 drv_stat = ata_wait_idle(ap);
3502 if (!ata_ok(drv_stat)) {
Albert Lee1c848982005-12-05 15:40:15 +08003503 qc->err_mask |= __ac_err_mask(drv_stat);
Albert Lee14be71f2005-09-27 17:36:35 +08003504 ap->hsm_task_state = HSM_ST_ERR;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003505 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506 }
3507
Albert Lee14be71f2005-09-27 17:36:35 +08003508 ap->hsm_task_state = HSM_ST_IDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509
Tejun Heoa46314742006-02-11 19:11:13 +09003510 WARN_ON(qc->err_mask);
Albert Leea22e2eb2005-12-05 15:38:02 +08003511 ata_poll_qc_complete(qc);
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003512
3513 /* another command may start at this point */
3514
3515 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516}
3517
Edward Falk0baab862005-06-02 18:17:13 -04003518
3519/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003520 * swap_buf_le16 - swap halves of 16-bit words in place
Edward Falk0baab862005-06-02 18:17:13 -04003521 * @buf: Buffer to swap
3522 * @buf_words: Number of 16-bit words in buffer.
3523 *
3524 * Swap halves of 16-bit words if needed to convert from
3525 * little-endian byte order to native cpu byte order, or
3526 * vice-versa.
3527 *
3528 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003529 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04003530 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003531void swap_buf_le16(u16 *buf, unsigned int buf_words)
3532{
3533#ifdef __BIG_ENDIAN
3534 unsigned int i;
3535
3536 for (i = 0; i < buf_words; i++)
3537 buf[i] = le16_to_cpu(buf[i]);
3538#endif /* __BIG_ENDIAN */
3539}
3540
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003541/**
3542 * ata_mmio_data_xfer - Transfer data by MMIO
3543 * @ap: port to read/write
3544 * @buf: data buffer
3545 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003546 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003547 *
3548 * Transfer data from/to the device data register by MMIO.
3549 *
3550 * LOCKING:
3551 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003552 */
3553
Linus Torvalds1da177e2005-04-16 15:20:36 -07003554static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
3555 unsigned int buflen, int write_data)
3556{
3557 unsigned int i;
3558 unsigned int words = buflen >> 1;
3559 u16 *buf16 = (u16 *) buf;
3560 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
3561
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003562 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003563 if (write_data) {
3564 for (i = 0; i < words; i++)
3565 writew(le16_to_cpu(buf16[i]), mmio);
3566 } else {
3567 for (i = 0; i < words; i++)
3568 buf16[i] = cpu_to_le16(readw(mmio));
3569 }
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003570
3571 /* Transfer trailing 1 byte, if any. */
3572 if (unlikely(buflen & 0x01)) {
3573 u16 align_buf[1] = { 0 };
3574 unsigned char *trailing_buf = buf + buflen - 1;
3575
3576 if (write_data) {
3577 memcpy(align_buf, trailing_buf, 1);
3578 writew(le16_to_cpu(align_buf[0]), mmio);
3579 } else {
3580 align_buf[0] = cpu_to_le16(readw(mmio));
3581 memcpy(trailing_buf, align_buf, 1);
3582 }
3583 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003584}
3585
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003586/**
3587 * ata_pio_data_xfer - Transfer data by PIO
3588 * @ap: port to read/write
3589 * @buf: data buffer
3590 * @buflen: buffer length
Jeff Garzik344baba2005-09-07 01:15:17 -04003591 * @write_data: read/write
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003592 *
3593 * Transfer data from/to the device data register by PIO.
3594 *
3595 * LOCKING:
3596 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003597 */
3598
Linus Torvalds1da177e2005-04-16 15:20:36 -07003599static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
3600 unsigned int buflen, int write_data)
3601{
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003602 unsigned int words = buflen >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003604 /* Transfer multiple of 2 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003605 if (write_data)
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003606 outsw(ap->ioaddr.data_addr, buf, words);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003607 else
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003608 insw(ap->ioaddr.data_addr, buf, words);
3609
3610 /* Transfer trailing 1 byte, if any. */
3611 if (unlikely(buflen & 0x01)) {
3612 u16 align_buf[1] = { 0 };
3613 unsigned char *trailing_buf = buf + buflen - 1;
3614
3615 if (write_data) {
3616 memcpy(align_buf, trailing_buf, 1);
3617 outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
3618 } else {
3619 align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
3620 memcpy(trailing_buf, align_buf, 1);
3621 }
3622 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623}
3624
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003625/**
3626 * ata_data_xfer - Transfer data from/to the data register.
3627 * @ap: port to read/write
3628 * @buf: data buffer
3629 * @buflen: buffer length
3630 * @do_write: read/write
3631 *
3632 * Transfer data from/to the device data register.
3633 *
3634 * LOCKING:
3635 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003636 */
3637
Linus Torvalds1da177e2005-04-16 15:20:36 -07003638static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
3639 unsigned int buflen, int do_write)
3640{
Alan Coxa1bd9e62006-01-17 20:53:50 +00003641 /* Make the crap hardware pay the costs not the good stuff */
3642 if (unlikely(ap->flags & ATA_FLAG_IRQ_MASK)) {
3643 unsigned long flags;
3644 local_irq_save(flags);
3645 if (ap->flags & ATA_FLAG_MMIO)
3646 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3647 else
3648 ata_pio_data_xfer(ap, buf, buflen, do_write);
3649 local_irq_restore(flags);
3650 } else {
3651 if (ap->flags & ATA_FLAG_MMIO)
3652 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3653 else
3654 ata_pio_data_xfer(ap, buf, buflen, do_write);
3655 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003656}
3657
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003658/**
3659 * ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
3660 * @qc: Command on going
3661 *
3662 * Transfer ATA_SECT_SIZE of data from/to the ATA device.
3663 *
3664 * LOCKING:
3665 * Inherited from caller.
3666 */
3667
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668static void ata_pio_sector(struct ata_queued_cmd *qc)
3669{
3670 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003671 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003672 struct ata_port *ap = qc->ap;
3673 struct page *page;
3674 unsigned int offset;
3675 unsigned char *buf;
3676
3677 if (qc->cursect == (qc->nsect - 1))
Albert Lee14be71f2005-09-27 17:36:35 +08003678 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003679
3680 page = sg[qc->cursg].page;
3681 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
3682
3683 /* get the current page and offset */
3684 page = nth_page(page, (offset >> PAGE_SHIFT));
3685 offset %= PAGE_SIZE;
3686
3687 buf = kmap(page) + offset;
3688
3689 qc->cursect++;
3690 qc->cursg_ofs++;
3691
Albert Lee32529e02005-05-26 03:49:42 -04003692 if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003693 qc->cursg++;
3694 qc->cursg_ofs = 0;
3695 }
3696
3697 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3698
3699 /* do the actual data transfer */
3700 do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3701 ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
3702
3703 kunmap(page);
3704}
3705
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003706/**
3707 * __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3708 * @qc: Command on going
3709 * @bytes: number of bytes
3710 *
3711 * Transfer Transfer data from/to the ATAPI device.
3712 *
3713 * LOCKING:
3714 * Inherited from caller.
3715 *
3716 */
3717
Linus Torvalds1da177e2005-04-16 15:20:36 -07003718static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3719{
3720 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003721 struct scatterlist *sg = qc->__sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003722 struct ata_port *ap = qc->ap;
3723 struct page *page;
3724 unsigned char *buf;
3725 unsigned int offset, count;
3726
Albert Lee563a6e12005-08-12 14:17:50 +08003727 if (qc->curbytes + bytes >= qc->nbytes)
Albert Lee14be71f2005-09-27 17:36:35 +08003728 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003729
3730next_sg:
Albert Lee563a6e12005-08-12 14:17:50 +08003731 if (unlikely(qc->cursg >= qc->n_elem)) {
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003732 /*
Albert Lee563a6e12005-08-12 14:17:50 +08003733 * The end of qc->sg is reached and the device expects
3734 * more data to transfer. In order not to overrun qc->sg
3735 * and fulfill length specified in the byte count register,
3736 * - for read case, discard trailing data from the device
3737 * - for write case, padding zero data to the device
3738 */
3739 u16 pad_buf[1] = { 0 };
3740 unsigned int words = bytes >> 1;
3741 unsigned int i;
3742
3743 if (words) /* warning if bytes > 1 */
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003744 printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
Albert Lee563a6e12005-08-12 14:17:50 +08003745 ap->id, bytes);
3746
3747 for (i = 0; i < words; i++)
3748 ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
3749
Albert Lee14be71f2005-09-27 17:36:35 +08003750 ap->hsm_task_state = HSM_ST_LAST;
Albert Lee563a6e12005-08-12 14:17:50 +08003751 return;
3752 }
3753
Jeff Garzikcedc9a42005-10-05 07:13:30 -04003754 sg = &qc->__sg[qc->cursg];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003755
Linus Torvalds1da177e2005-04-16 15:20:36 -07003756 page = sg->page;
3757 offset = sg->offset + qc->cursg_ofs;
3758
3759 /* get the current page and offset */
3760 page = nth_page(page, (offset >> PAGE_SHIFT));
3761 offset %= PAGE_SIZE;
3762
Albert Lee6952df02005-06-06 15:56:03 +08003763 /* don't overrun current sg */
Albert Lee32529e02005-05-26 03:49:42 -04003764 count = min(sg->length - qc->cursg_ofs, bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003765
3766 /* don't cross page boundaries */
3767 count = min(count, (unsigned int)PAGE_SIZE - offset);
3768
3769 buf = kmap(page) + offset;
3770
3771 bytes -= count;
3772 qc->curbytes += count;
3773 qc->cursg_ofs += count;
3774
Albert Lee32529e02005-05-26 03:49:42 -04003775 if (qc->cursg_ofs == sg->length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776 qc->cursg++;
3777 qc->cursg_ofs = 0;
3778 }
3779
3780 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3781
3782 /* do the actual data transfer */
3783 ata_data_xfer(ap, buf, count, do_write);
3784
3785 kunmap(page);
3786
Albert Lee563a6e12005-08-12 14:17:50 +08003787 if (bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003788 goto next_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003789}
3790
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003791/**
3792 * atapi_pio_bytes - Transfer data from/to the ATAPI device.
3793 * @qc: Command on going
3794 *
3795 * Transfer Transfer data from/to the ATAPI device.
3796 *
3797 * LOCKING:
3798 * Inherited from caller.
Albert Lee6ae4cfb2005-08-12 14:15:34 +08003799 */
3800
Linus Torvalds1da177e2005-04-16 15:20:36 -07003801static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3802{
3803 struct ata_port *ap = qc->ap;
3804 struct ata_device *dev = qc->dev;
3805 unsigned int ireason, bc_lo, bc_hi, bytes;
3806 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3807
3808 ap->ops->tf_read(ap, &qc->tf);
3809 ireason = qc->tf.nsect;
3810 bc_lo = qc->tf.lbam;
3811 bc_hi = qc->tf.lbah;
3812 bytes = (bc_hi << 8) | bc_lo;
3813
3814 /* shall be cleared to zero, indicating xfer of data */
3815 if (ireason & (1 << 0))
3816 goto err_out;
3817
3818 /* make sure transfer direction matches expected */
3819 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3820 if (do_write != i_write)
3821 goto err_out;
3822
3823 __atapi_pio_bytes(qc, bytes);
3824
3825 return;
3826
3827err_out:
3828 printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
3829 ap->id, dev->devno);
Tejun Heo11a56d22006-01-23 13:09:36 +09003830 qc->err_mask |= AC_ERR_HSM;
Albert Lee14be71f2005-09-27 17:36:35 +08003831 ap->hsm_task_state = HSM_ST_ERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003832}
3833
3834/**
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003835 * ata_pio_block - start PIO on a block
Tejun Heoc91af2c2006-04-02 18:51:53 +09003836 * @qc: qc to transfer block for
Linus Torvalds1da177e2005-04-16 15:20:36 -07003837 *
3838 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003839 * None. (executing in kernel thread context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003840 */
Tejun Heoc91af2c2006-04-02 18:51:53 +09003841static void ata_pio_block(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003842{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003843 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003844 u8 status;
3845
3846 /*
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04003847 * This is purely heuristic. This is a fast path.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003848 * Sometimes when we enter, BSY will be cleared in
3849 * a chk-status or two. If not, the drive is probably seeking
3850 * or something. Snooze for a couple msecs, then
3851 * chk-status again. If still busy, fall back to
Albert Lee14be71f2005-09-27 17:36:35 +08003852 * HSM_ST_POLL state.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003853 */
3854 status = ata_busy_wait(ap, ATA_BUSY, 5);
3855 if (status & ATA_BUSY) {
3856 msleep(2);
3857 status = ata_busy_wait(ap, ATA_BUSY, 10);
3858 if (status & ATA_BUSY) {
Albert Lee14be71f2005-09-27 17:36:35 +08003859 ap->hsm_task_state = HSM_ST_POLL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003860 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
3861 return;
3862 }
3863 }
3864
Albert Leefe79e682005-12-06 11:34:59 +08003865 /* check error */
3866 if (status & (ATA_ERR | ATA_DF)) {
3867 qc->err_mask |= AC_ERR_DEV;
3868 ap->hsm_task_state = HSM_ST_ERR;
3869 return;
3870 }
3871
3872 /* transfer data if any */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003873 if (is_atapi_taskfile(&qc->tf)) {
Albert Leefe79e682005-12-06 11:34:59 +08003874 /* DRQ=0 means no more data to transfer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003875 if ((status & ATA_DRQ) == 0) {
Albert Lee14be71f2005-09-27 17:36:35 +08003876 ap->hsm_task_state = HSM_ST_LAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003877 return;
3878 }
3879
3880 atapi_pio_bytes(qc);
3881 } else {
3882 /* handle BSY=0, DRQ=0 as error */
3883 if ((status & ATA_DRQ) == 0) {
Tejun Heo11a56d22006-01-23 13:09:36 +09003884 qc->err_mask |= AC_ERR_HSM;
Albert Lee14be71f2005-09-27 17:36:35 +08003885 ap->hsm_task_state = HSM_ST_ERR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003886 return;
3887 }
3888
3889 ata_pio_sector(qc);
3890 }
3891}
3892
Tejun Heoc91af2c2006-04-02 18:51:53 +09003893static void ata_pio_error(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003895 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003896
Albert Lee0565c262006-02-13 18:55:25 +08003897 if (qc->tf.command != ATA_CMD_PACKET)
Tejun Heod63cb4a2006-04-02 18:51:52 +09003898 printk(KERN_WARNING "ata%u: dev %u PIO error\n",
3899 ap->id, qc->dev->devno);
Albert Lee0565c262006-02-13 18:55:25 +08003900
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05003901 /* make sure qc->err_mask is available to
Albert Lee1c848982005-12-05 15:40:15 +08003902 * know what's wrong and recover
3903 */
Tejun Heoa46314742006-02-11 19:11:13 +09003904 WARN_ON(qc->err_mask == 0);
Albert Lee1c848982005-12-05 15:40:15 +08003905
Albert Lee14be71f2005-09-27 17:36:35 +08003906 ap->hsm_task_state = HSM_ST_IDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003907
Albert Leea22e2eb2005-12-05 15:38:02 +08003908 ata_poll_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003909}
3910
3911static void ata_pio_task(void *_data)
3912{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003913 struct ata_queued_cmd *qc = _data;
3914 struct ata_port *ap = qc->ap;
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003915 unsigned long timeout;
3916 int qc_completed;
3917
3918fsm_start:
3919 timeout = 0;
3920 qc_completed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003921
Albert Lee14be71f2005-09-27 17:36:35 +08003922 switch (ap->hsm_task_state) {
3923 case HSM_ST_IDLE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924 return;
3925
Albert Lee14be71f2005-09-27 17:36:35 +08003926 case HSM_ST:
Tejun Heoc91af2c2006-04-02 18:51:53 +09003927 ata_pio_block(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003928 break;
3929
Albert Lee14be71f2005-09-27 17:36:35 +08003930 case HSM_ST_LAST:
Tejun Heoc91af2c2006-04-02 18:51:53 +09003931 qc_completed = ata_pio_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003932 break;
3933
Albert Lee14be71f2005-09-27 17:36:35 +08003934 case HSM_ST_POLL:
3935 case HSM_ST_LAST_POLL:
Tejun Heoc91af2c2006-04-02 18:51:53 +09003936 timeout = ata_pio_poll(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003937 break;
3938
Albert Lee14be71f2005-09-27 17:36:35 +08003939 case HSM_ST_TMOUT:
3940 case HSM_ST_ERR:
Tejun Heoc91af2c2006-04-02 18:51:53 +09003941 ata_pio_error(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003942 return;
3943 }
3944
3945 if (timeout)
Tejun Heoc91af2c2006-04-02 18:51:53 +09003946 ata_port_queue_task(ap, ata_pio_task, qc, timeout);
Jeff Garzik7fb6ec22005-09-16 06:01:48 -04003947 else if (!qc_completed)
3948 goto fsm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949}
3950
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951/**
Tejun Heo8061f5f2006-03-05 15:29:09 +09003952 * atapi_packet_task - Write CDB bytes to hardware
Tejun Heoc91af2c2006-04-02 18:51:53 +09003953 * @_data: qc in progress
Tejun Heo8061f5f2006-03-05 15:29:09 +09003954 *
3955 * When device has indicated its readiness to accept
3956 * a CDB, this function is called. Send the CDB.
3957 * If DMA is to be performed, exit immediately.
3958 * Otherwise, we are in polling mode, so poll
3959 * status under operation succeeds or fails.
3960 *
3961 * LOCKING:
3962 * Kernel thread context (may sleep)
3963 */
Tejun Heo8061f5f2006-03-05 15:29:09 +09003964static void atapi_packet_task(void *_data)
3965{
Tejun Heoc91af2c2006-04-02 18:51:53 +09003966 struct ata_queued_cmd *qc = _data;
3967 struct ata_port *ap = qc->ap;
Tejun Heo8061f5f2006-03-05 15:29:09 +09003968 u8 status;
3969
Tejun Heo8061f5f2006-03-05 15:29:09 +09003970 /* sleep-wait for BSY to clear */
3971 DPRINTK("busy wait\n");
3972 if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB)) {
3973 qc->err_mask |= AC_ERR_TIMEOUT;
3974 goto err_out;
3975 }
3976
3977 /* make sure DRQ is set */
3978 status = ata_chk_status(ap);
3979 if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ) {
3980 qc->err_mask |= AC_ERR_HSM;
3981 goto err_out;
3982 }
3983
3984 /* send SCSI cdb */
3985 DPRINTK("send cdb\n");
3986 WARN_ON(qc->dev->cdb_len < 12);
3987
3988 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA ||
3989 qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3990 unsigned long flags;
3991
3992 /* Once we're done issuing command and kicking bmdma,
3993 * irq handler takes over. To not lose irq, we need
3994 * to clear NOINTR flag before sending cdb, but
3995 * interrupt handler shouldn't be invoked before we're
3996 * finished. Hence, the following locking.
3997 */
3998 spin_lock_irqsave(&ap->host_set->lock, flags);
3999 ap->flags &= ~ATA_FLAG_NOINTR;
4000 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
4001 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
4002 ap->ops->bmdma_start(qc); /* initiate bmdma */
4003 spin_unlock_irqrestore(&ap->host_set->lock, flags);
4004 } else {
4005 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
4006
4007 /* PIO commands are handled by polling */
4008 ap->hsm_task_state = HSM_ST;
Tejun Heoc91af2c2006-04-02 18:51:53 +09004009 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Tejun Heo8061f5f2006-03-05 15:29:09 +09004010 }
4011
4012 return;
4013
4014err_out:
4015 ata_poll_qc_complete(qc);
4016}
4017
4018/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004019 * ata_qc_new - Request an available ATA command, for queueing
4020 * @ap: Port associated with device @dev
4021 * @dev: Device from whom we request an available command structure
4022 *
4023 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004024 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004025 */
4026
4027static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
4028{
4029 struct ata_queued_cmd *qc = NULL;
4030 unsigned int i;
4031
4032 for (i = 0; i < ATA_MAX_QUEUE; i++)
4033 if (!test_and_set_bit(i, &ap->qactive)) {
4034 qc = ata_qc_from_tag(ap, i);
4035 break;
4036 }
4037
4038 if (qc)
4039 qc->tag = i;
4040
4041 return qc;
4042}
4043
4044/**
4045 * ata_qc_new_init - Request an available ATA command, and initialize it
4046 * @ap: Port associated with device @dev
4047 * @dev: Device from whom we request an available command structure
4048 *
4049 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004050 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004051 */
4052
4053struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
4054 struct ata_device *dev)
4055{
4056 struct ata_queued_cmd *qc;
4057
4058 qc = ata_qc_new(ap);
4059 if (qc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004060 qc->scsicmd = NULL;
4061 qc->ap = ap;
4062 qc->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004063
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05004064 ata_qc_reinit(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004065 }
4066
4067 return qc;
4068}
4069
Linus Torvalds1da177e2005-04-16 15:20:36 -07004070/**
4071 * ata_qc_free - free unused ata_queued_cmd
4072 * @qc: Command to complete
4073 *
4074 * Designed to free unused ata_queued_cmd object
4075 * in case something prevents using it.
4076 *
4077 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004078 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004079 */
4080void ata_qc_free(struct ata_queued_cmd *qc)
4081{
Tejun Heo4ba946e2006-01-23 13:09:36 +09004082 struct ata_port *ap = qc->ap;
4083 unsigned int tag;
4084
Tejun Heoa46314742006-02-11 19:11:13 +09004085 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004086
Tejun Heo4ba946e2006-01-23 13:09:36 +09004087 qc->flags = 0;
4088 tag = qc->tag;
4089 if (likely(ata_tag_valid(tag))) {
4090 if (tag == ap->active_tag)
4091 ap->active_tag = ATA_TAG_POISON;
4092 qc->tag = ATA_TAG_POISON;
4093 clear_bit(tag, &ap->qactive);
4094 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004095}
4096
Tejun Heo76014422006-02-11 15:13:49 +09004097void __ata_qc_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004098{
Tejun Heoa46314742006-02-11 19:11:13 +09004099 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4100 WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004101
4102 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4103 ata_sg_clean(qc);
4104
Albert Lee3f3791d2005-08-16 14:25:38 +08004105 /* atapi: mark qc as inactive to prevent the interrupt handler
4106 * from completing the command twice later, before the error handler
4107 * is called. (when rc != 0 and atapi request sense is needed)
4108 */
4109 qc->flags &= ~ATA_QCFLAG_ACTIVE;
4110
Linus Torvalds1da177e2005-04-16 15:20:36 -07004111 /* call completion callback */
Tejun Heo77853bf2006-01-23 13:09:36 +09004112 qc->complete_fn(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004113}
4114
4115static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
4116{
4117 struct ata_port *ap = qc->ap;
4118
4119 switch (qc->tf.protocol) {
4120 case ATA_PROT_DMA:
4121 case ATA_PROT_ATAPI_DMA:
4122 return 1;
4123
4124 case ATA_PROT_ATAPI:
4125 case ATA_PROT_PIO:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004126 if (ap->flags & ATA_FLAG_PIO_DMA)
4127 return 1;
4128
4129 /* fall through */
4130
4131 default:
4132 return 0;
4133 }
4134
4135 /* never reached */
4136}
4137
4138/**
4139 * ata_qc_issue - issue taskfile to device
4140 * @qc: command to issue to device
4141 *
4142 * Prepare an ATA command to submission to device.
4143 * This includes mapping the data into a DMA-able
4144 * area, filling in the S/G table, and finally
4145 * writing the taskfile to hardware, starting the command.
4146 *
4147 * LOCKING:
4148 * spin_lock_irqsave(host_set lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004149 */
Tejun Heo8e0e6942006-03-31 20:41:11 +09004150void ata_qc_issue(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004151{
4152 struct ata_port *ap = qc->ap;
4153
Tejun Heoe4a70e72006-03-31 20:36:47 +09004154 qc->ap->active_tag = qc->tag;
4155 qc->flags |= ATA_QCFLAG_ACTIVE;
4156
Linus Torvalds1da177e2005-04-16 15:20:36 -07004157 if (ata_should_dma_map(qc)) {
4158 if (qc->flags & ATA_QCFLAG_SG) {
4159 if (ata_sg_setup(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004160 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004161 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
4162 if (ata_sg_setup_one(qc))
Tejun Heo8e436af2006-01-23 13:09:36 +09004163 goto sg_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004164 }
4165 } else {
4166 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4167 }
4168
4169 ap->ops->qc_prep(qc);
4170
Tejun Heo8e0e6942006-03-31 20:41:11 +09004171 qc->err_mask |= ap->ops->qc_issue(qc);
4172 if (unlikely(qc->err_mask))
4173 goto err;
4174 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004175
Tejun Heo8e436af2006-01-23 13:09:36 +09004176sg_err:
4177 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Tejun Heo8e0e6942006-03-31 20:41:11 +09004178 qc->err_mask |= AC_ERR_SYSTEM;
4179err:
4180 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004181}
4182
4183/**
4184 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
4185 * @qc: command to issue to device
4186 *
4187 * Using various libata functions and hooks, this function
4188 * starts an ATA command. ATA commands are grouped into
4189 * classes called "protocols", and issuing each type of protocol
4190 * is slightly different.
4191 *
Edward Falk0baab862005-06-02 18:17:13 -04004192 * May be used as the qc_issue() entry in ata_port_operations.
4193 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004194 * LOCKING:
4195 * spin_lock_irqsave(host_set lock)
4196 *
4197 * RETURNS:
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004198 * Zero on success, AC_ERR_* mask on failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004199 */
4200
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004201unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004202{
4203 struct ata_port *ap = qc->ap;
4204
4205 ata_dev_select(ap, qc->dev->devno, 1, 0);
4206
4207 switch (qc->tf.protocol) {
4208 case ATA_PROT_NODATA:
Jeff Garzike5338252005-10-30 21:37:17 -05004209 ata_tf_to_host(ap, &qc->tf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004210 break;
4211
4212 case ATA_PROT_DMA:
4213 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4214 ap->ops->bmdma_setup(qc); /* set up bmdma */
4215 ap->ops->bmdma_start(qc); /* initiate bmdma */
4216 break;
4217
4218 case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
4219 ata_qc_set_polling(qc);
Jeff Garzike5338252005-10-30 21:37:17 -05004220 ata_tf_to_host(ap, &qc->tf);
Albert Lee14be71f2005-09-27 17:36:35 +08004221 ap->hsm_task_state = HSM_ST;
Tejun Heoc91af2c2006-04-02 18:51:53 +09004222 ata_port_queue_task(ap, ata_pio_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004223 break;
4224
4225 case ATA_PROT_ATAPI:
4226 ata_qc_set_polling(qc);
Jeff Garzike5338252005-10-30 21:37:17 -05004227 ata_tf_to_host(ap, &qc->tf);
Tejun Heoc91af2c2006-04-02 18:51:53 +09004228 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004229 break;
4230
4231 case ATA_PROT_ATAPI_NODATA:
Tejun Heoc1389502005-08-22 14:59:24 +09004232 ap->flags |= ATA_FLAG_NOINTR;
Jeff Garzike5338252005-10-30 21:37:17 -05004233 ata_tf_to_host(ap, &qc->tf);
Tejun Heoc91af2c2006-04-02 18:51:53 +09004234 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004235 break;
4236
4237 case ATA_PROT_ATAPI_DMA:
Tejun Heoc1389502005-08-22 14:59:24 +09004238 ap->flags |= ATA_FLAG_NOINTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004239 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4240 ap->ops->bmdma_setup(qc); /* set up bmdma */
Tejun Heoc91af2c2006-04-02 18:51:53 +09004241 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004242 break;
4243
4244 default:
4245 WARN_ON(1);
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09004246 return AC_ERR_SYSTEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004247 }
4248
4249 return 0;
4250}
4251
4252/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004253 * ata_host_intr - Handle host interrupt for given (port, task)
4254 * @ap: Port on which interrupt arrived (possibly...)
4255 * @qc: Taskfile currently active in engine
4256 *
4257 * Handle host interrupt for given queued command. Currently,
4258 * only DMA interrupts are handled. All other commands are
4259 * handled via polling with interrupts disabled (nIEN bit).
4260 *
4261 * LOCKING:
4262 * spin_lock_irqsave(host_set lock)
4263 *
4264 * RETURNS:
4265 * One if interrupt was handled, zero if not (shared irq).
4266 */
4267
4268inline unsigned int ata_host_intr (struct ata_port *ap,
4269 struct ata_queued_cmd *qc)
4270{
4271 u8 status, host_stat;
4272
4273 switch (qc->tf.protocol) {
4274
4275 case ATA_PROT_DMA:
4276 case ATA_PROT_ATAPI_DMA:
4277 case ATA_PROT_ATAPI:
4278 /* check status of DMA engine */
4279 host_stat = ap->ops->bmdma_status(ap);
4280 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
4281
4282 /* if it's not our irq... */
4283 if (!(host_stat & ATA_DMA_INTR))
4284 goto idle_irq;
4285
4286 /* before we do anything else, clear DMA-Start bit */
Alan Coxb73fc892005-08-26 16:03:19 +01004287 ap->ops->bmdma_stop(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004288
4289 /* fall through */
4290
4291 case ATA_PROT_ATAPI_NODATA:
4292 case ATA_PROT_NODATA:
4293 /* check altstatus */
4294 status = ata_altstatus(ap);
4295 if (status & ATA_BUSY)
4296 goto idle_irq;
4297
4298 /* check main status, clearing INTRQ */
4299 status = ata_chk_status(ap);
4300 if (unlikely(status & ATA_BUSY))
4301 goto idle_irq;
4302 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
4303 ap->id, qc->tf.protocol, status);
4304
4305 /* ack bmdma irq events */
4306 ap->ops->irq_clear(ap);
4307
4308 /* complete taskfile transaction */
Albert Leea22e2eb2005-12-05 15:38:02 +08004309 qc->err_mask |= ac_err_mask(status);
4310 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004311 break;
4312
4313 default:
4314 goto idle_irq;
4315 }
4316
4317 return 1; /* irq handled */
4318
4319idle_irq:
4320 ap->stats.idle_irq++;
4321
4322#ifdef ATA_IRQ_TRAP
4323 if ((ap->stats.idle_irq % 1000) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004324 ata_irq_ack(ap, 0); /* debug trap */
4325 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
Alan Cox23cfce82006-03-21 16:06:53 +00004326 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004327 }
4328#endif
4329 return 0; /* irq not handled */
4330}
4331
4332/**
4333 * ata_interrupt - Default ATA host interrupt handler
Jeff Garzik0cba6322005-05-30 19:49:12 -04004334 * @irq: irq line (unused)
4335 * @dev_instance: pointer to our ata_host_set information structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07004336 * @regs: unused
4337 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004338 * Default interrupt handler for PCI IDE devices. Calls
4339 * ata_host_intr() for each port that is not disabled.
4340 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004341 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004342 * Obtains host_set lock during operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004343 *
4344 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004345 * IRQ_NONE or IRQ_HANDLED.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004346 */
4347
4348irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
4349{
4350 struct ata_host_set *host_set = dev_instance;
4351 unsigned int i;
4352 unsigned int handled = 0;
4353 unsigned long flags;
4354
4355 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
4356 spin_lock_irqsave(&host_set->lock, flags);
4357
4358 for (i = 0; i < host_set->n_ports; i++) {
4359 struct ata_port *ap;
4360
4361 ap = host_set->ports[i];
Tejun Heoc1389502005-08-22 14:59:24 +09004362 if (ap &&
Tejun Heo198e0fe2006-04-02 18:51:52 +09004363 !(ap->flags & (ATA_FLAG_DISABLED | ATA_FLAG_NOINTR))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004364 struct ata_queued_cmd *qc;
4365
4366 qc = ata_qc_from_tag(ap, ap->active_tag);
Albert Lee21b1ed72005-04-29 17:34:59 +08004367 if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
4368 (qc->flags & ATA_QCFLAG_ACTIVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004369 handled |= ata_host_intr(ap, qc);
4370 }
4371 }
4372
4373 spin_unlock_irqrestore(&host_set->lock, flags);
4374
4375 return IRQ_RETVAL(handled);
4376}
4377
Edward Falk0baab862005-06-02 18:17:13 -04004378
Jens Axboe9b847542006-01-06 09:28:07 +01004379/*
4380 * Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
4381 * without filling any other registers
4382 */
4383static int ata_do_simple_cmd(struct ata_port *ap, struct ata_device *dev,
4384 u8 cmd)
4385{
4386 struct ata_taskfile tf;
4387 int err;
4388
4389 ata_tf_init(ap, &tf, dev->devno);
4390
4391 tf.command = cmd;
4392 tf.flags |= ATA_TFLAG_DEVICE;
4393 tf.protocol = ATA_PROT_NODATA;
4394
Tejun Heod69cf372006-04-02 18:51:53 +09004395 err = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
Jens Axboe9b847542006-01-06 09:28:07 +01004396 if (err)
4397 printk(KERN_ERR "%s: ata command failed: %d\n",
4398 __FUNCTION__, err);
4399
4400 return err;
4401}
4402
4403static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
4404{
4405 u8 cmd;
4406
4407 if (!ata_try_flush_cache(dev))
4408 return 0;
4409
4410 if (ata_id_has_flush_ext(dev->id))
4411 cmd = ATA_CMD_FLUSH_EXT;
4412 else
4413 cmd = ATA_CMD_FLUSH;
4414
4415 return ata_do_simple_cmd(ap, dev, cmd);
4416}
4417
4418static int ata_standby_drive(struct ata_port *ap, struct ata_device *dev)
4419{
4420 return ata_do_simple_cmd(ap, dev, ATA_CMD_STANDBYNOW1);
4421}
4422
4423static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
4424{
4425 return ata_do_simple_cmd(ap, dev, ATA_CMD_IDLEIMMEDIATE);
4426}
4427
4428/**
4429 * ata_device_resume - wakeup a previously suspended devices
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004430 * @ap: port the device is connected to
4431 * @dev: the device to resume
Jens Axboe9b847542006-01-06 09:28:07 +01004432 *
4433 * Kick the drive back into action, by sending it an idle immediate
4434 * command and making sure its transfer mode matches between drive
4435 * and host.
4436 *
4437 */
4438int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
4439{
4440 if (ap->flags & ATA_FLAG_SUSPENDED) {
Tejun Heoe82cbdb2006-04-01 01:38:18 +09004441 struct ata_device *failed_dev;
Jens Axboe9b847542006-01-06 09:28:07 +01004442 ap->flags &= ~ATA_FLAG_SUSPENDED;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09004443 while (ata_set_mode(ap, &failed_dev))
4444 ata_dev_disable(ap, failed_dev);
Jens Axboe9b847542006-01-06 09:28:07 +01004445 }
Tejun Heoe1211e32006-04-01 01:38:18 +09004446 if (!ata_dev_enabled(dev))
Jens Axboe9b847542006-01-06 09:28:07 +01004447 return 0;
4448 if (dev->class == ATA_DEV_ATA)
4449 ata_start_drive(ap, dev);
4450
4451 return 0;
4452}
4453
4454/**
4455 * ata_device_suspend - prepare a device for suspend
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004456 * @ap: port the device is connected to
4457 * @dev: the device to suspend
Jens Axboe9b847542006-01-06 09:28:07 +01004458 *
4459 * Flush the cache on the drive, if appropriate, then issue a
4460 * standbynow command.
Jens Axboe9b847542006-01-06 09:28:07 +01004461 */
Nigel Cunningham082776e2006-03-23 23:22:16 +10004462int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
Jens Axboe9b847542006-01-06 09:28:07 +01004463{
Tejun Heoe1211e32006-04-01 01:38:18 +09004464 if (!ata_dev_enabled(dev))
Jens Axboe9b847542006-01-06 09:28:07 +01004465 return 0;
4466 if (dev->class == ATA_DEV_ATA)
4467 ata_flush_cache(ap, dev);
4468
Nigel Cunningham082776e2006-03-23 23:22:16 +10004469 if (state.event != PM_EVENT_FREEZE)
4470 ata_standby_drive(ap, dev);
Jens Axboe9b847542006-01-06 09:28:07 +01004471 ap->flags |= ATA_FLAG_SUSPENDED;
4472 return 0;
4473}
4474
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004475/**
4476 * ata_port_start - Set port up for dma.
4477 * @ap: Port to initialize
4478 *
4479 * Called just after data structures for each port are
4480 * initialized. Allocates space for PRD table.
4481 *
4482 * May be used as the port_start() entry in ata_port_operations.
4483 *
4484 * LOCKING:
4485 * Inherited from caller.
4486 */
4487
Linus Torvalds1da177e2005-04-16 15:20:36 -07004488int ata_port_start (struct ata_port *ap)
4489{
Brian King2f1f6102006-03-23 17:30:15 -06004490 struct device *dev = ap->dev;
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004491 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004492
4493 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
4494 if (!ap->prd)
4495 return -ENOMEM;
4496
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004497 rc = ata_pad_alloc(ap, dev);
4498 if (rc) {
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004499 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004500 return rc;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004501 }
4502
Linus Torvalds1da177e2005-04-16 15:20:36 -07004503 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
4504
4505 return 0;
4506}
4507
Edward Falk0baab862005-06-02 18:17:13 -04004508
4509/**
4510 * ata_port_stop - Undo ata_port_start()
4511 * @ap: Port to shut down
4512 *
4513 * Frees the PRD table.
4514 *
4515 * May be used as the port_stop() entry in ata_port_operations.
4516 *
4517 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004518 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04004519 */
4520
Linus Torvalds1da177e2005-04-16 15:20:36 -07004521void ata_port_stop (struct ata_port *ap)
4522{
Brian King2f1f6102006-03-23 17:30:15 -06004523 struct device *dev = ap->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004524
4525 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05004526 ata_pad_free(ap, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004527}
4528
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04004529void ata_host_stop (struct ata_host_set *host_set)
4530{
4531 if (host_set->mmio_base)
4532 iounmap(host_set->mmio_base);
4533}
4534
4535
Linus Torvalds1da177e2005-04-16 15:20:36 -07004536/**
4537 * ata_host_remove - Unregister SCSI host structure with upper layers
4538 * @ap: Port to unregister
4539 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
4540 *
4541 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004542 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004543 */
4544
4545static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
4546{
4547 struct Scsi_Host *sh = ap->host;
4548
4549 DPRINTK("ENTER\n");
4550
4551 if (do_unregister)
4552 scsi_remove_host(sh);
4553
4554 ap->ops->port_stop(ap);
4555}
4556
4557/**
4558 * ata_host_init - Initialize an ata_port structure
4559 * @ap: Structure to initialize
4560 * @host: associated SCSI mid-layer structure
4561 * @host_set: Collection of hosts to which @ap belongs
4562 * @ent: Probe information provided by low-level driver
4563 * @port_no: Port number associated with this ata_port
4564 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004565 * Initialize a new ata_port structure, and its associated
4566 * scsi_host.
4567 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004568 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004569 * Inherited from caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004570 */
4571
4572static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
4573 struct ata_host_set *host_set,
Jeff Garzik057ace52005-10-22 14:27:05 -04004574 const struct ata_probe_ent *ent, unsigned int port_no)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004575{
4576 unsigned int i;
4577
4578 host->max_id = 16;
4579 host->max_lun = 1;
4580 host->max_channel = 1;
4581 host->unique_id = ata_unique_id++;
4582 host->max_cmd_len = 12;
Christoph Hellwig12413192005-06-11 01:05:01 +02004583
Tejun Heo198e0fe2006-04-02 18:51:52 +09004584 ap->flags = ATA_FLAG_DISABLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004585 ap->id = host->unique_id;
4586 ap->host = host;
4587 ap->ctl = ATA_DEVCTL_OBS;
4588 ap->host_set = host_set;
Brian King2f1f6102006-03-23 17:30:15 -06004589 ap->dev = ent->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004590 ap->port_no = port_no;
4591 ap->hard_port_no =
4592 ent->legacy_mode ? ent->hard_port_no : port_no;
4593 ap->pio_mask = ent->pio_mask;
4594 ap->mwdma_mask = ent->mwdma_mask;
4595 ap->udma_mask = ent->udma_mask;
4596 ap->flags |= ent->host_flags;
4597 ap->ops = ent->port_ops;
4598 ap->cbl = ATA_CBL_NONE;
Tejun Heo1c3fae42006-04-02 20:53:28 +09004599 ap->sata_spd_limit = UINT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600 ap->active_tag = ATA_TAG_POISON;
4601 ap->last_ctl = 0xFF;
4602
Tejun Heo86e45b62006-03-05 15:29:09 +09004603 INIT_WORK(&ap->port_task, NULL, NULL);
Tejun Heoa72ec4c2006-01-23 13:09:37 +09004604 INIT_LIST_HEAD(&ap->eh_done_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004605
Tejun Heoacf356b2006-03-24 14:07:50 +09004606 for (i = 0; i < ATA_MAX_DEVICES; i++) {
4607 struct ata_device *dev = &ap->device[i];
4608 dev->devno = i;
4609 dev->pio_mask = UINT_MAX;
4610 dev->mwdma_mask = UINT_MAX;
4611 dev->udma_mask = UINT_MAX;
4612 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004613
4614#ifdef ATA_IRQ_TRAP
4615 ap->stats.unhandled_irq = 1;
4616 ap->stats.idle_irq = 1;
4617#endif
4618
4619 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
4620}
4621
4622/**
4623 * ata_host_add - Attach low-level ATA driver to system
4624 * @ent: Information provided by low-level driver
4625 * @host_set: Collections of ports to which we add
4626 * @port_no: Port number associated with this host
4627 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04004628 * Attach low-level ATA driver to system.
4629 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004630 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004631 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004632 *
4633 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004634 * New ata_port on success, for NULL on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004635 */
4636
Jeff Garzik057ace52005-10-22 14:27:05 -04004637static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004638 struct ata_host_set *host_set,
4639 unsigned int port_no)
4640{
4641 struct Scsi_Host *host;
4642 struct ata_port *ap;
4643 int rc;
4644
4645 DPRINTK("ENTER\n");
Tejun Heoaec5c3c2006-03-25 01:33:34 +09004646
4647 if (!ent->port_ops->probe_reset &&
4648 !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
4649 printk(KERN_ERR "ata%u: no reset mechanism available\n",
4650 port_no);
4651 return NULL;
4652 }
4653
Linus Torvalds1da177e2005-04-16 15:20:36 -07004654 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
4655 if (!host)
4656 return NULL;
4657
Tejun Heo30afc842006-03-18 18:40:14 +09004658 host->transportt = &ata_scsi_transport_template;
4659
Linus Torvalds1da177e2005-04-16 15:20:36 -07004660 ap = (struct ata_port *) &host->hostdata[0];
4661
4662 ata_host_init(ap, host, host_set, ent, port_no);
4663
4664 rc = ap->ops->port_start(ap);
4665 if (rc)
4666 goto err_out;
4667
4668 return ap;
4669
4670err_out:
4671 scsi_host_put(host);
4672 return NULL;
4673}
4674
4675/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04004676 * ata_device_add - Register hardware device with ATA and SCSI layers
4677 * @ent: Probe information describing hardware device to be registered
4678 *
4679 * This function processes the information provided in the probe
4680 * information struct @ent, allocates the necessary ATA and SCSI
4681 * host information structures, initializes them, and registers
4682 * everything with requisite kernel subsystems.
4683 *
4684 * This function requests irqs, probes the ATA bus, and probes
4685 * the SCSI bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004686 *
4687 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004688 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004689 *
4690 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004691 * Number of ports registered. Zero on error (no ports registered).
Linus Torvalds1da177e2005-04-16 15:20:36 -07004692 */
4693
Jeff Garzik057ace52005-10-22 14:27:05 -04004694int ata_device_add(const struct ata_probe_ent *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004695{
4696 unsigned int count = 0, i;
4697 struct device *dev = ent->dev;
4698 struct ata_host_set *host_set;
4699
4700 DPRINTK("ENTER\n");
4701 /* alloc a container for our list of ATA ports (buses) */
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004702 host_set = kzalloc(sizeof(struct ata_host_set) +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004703 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
4704 if (!host_set)
4705 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004706 spin_lock_init(&host_set->lock);
4707
4708 host_set->dev = dev;
4709 host_set->n_ports = ent->n_ports;
4710 host_set->irq = ent->irq;
4711 host_set->mmio_base = ent->mmio_base;
4712 host_set->private_data = ent->private_data;
4713 host_set->ops = ent->port_ops;
Alan Cox5444a6f2006-03-27 18:58:20 +01004714 host_set->flags = ent->host_set_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004715
4716 /* register each port bound to this device */
4717 for (i = 0; i < ent->n_ports; i++) {
4718 struct ata_port *ap;
4719 unsigned long xfer_mode_mask;
4720
4721 ap = ata_host_add(ent, host_set, i);
4722 if (!ap)
4723 goto err_out;
4724
4725 host_set->ports[i] = ap;
4726 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
4727 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
4728 (ap->pio_mask << ATA_SHIFT_PIO);
4729
4730 /* print per-port info to dmesg */
4731 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
4732 "bmdma 0x%lX irq %lu\n",
4733 ap->id,
4734 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
4735 ata_mode_string(xfer_mode_mask),
4736 ap->ioaddr.cmd_addr,
4737 ap->ioaddr.ctl_addr,
4738 ap->ioaddr.bmdma_addr,
4739 ent->irq);
4740
4741 ata_chk_status(ap);
4742 host_set->ops->irq_clear(ap);
4743 count++;
4744 }
4745
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004746 if (!count)
4747 goto err_free_ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004748
4749 /* obtain irq, that is shared between channels */
4750 if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
4751 DRV_NAME, host_set))
4752 goto err_out;
4753
4754 /* perform each probe synchronously */
4755 DPRINTK("probe begin\n");
4756 for (i = 0; i < count; i++) {
4757 struct ata_port *ap;
4758 int rc;
4759
4760 ap = host_set->ports[i];
4761
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004762 DPRINTK("ata%u: bus probe begin\n", ap->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004763 rc = ata_bus_probe(ap);
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004764 DPRINTK("ata%u: bus probe end\n", ap->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004765
4766 if (rc) {
4767 /* FIXME: do something useful here?
4768 * Current libata behavior will
4769 * tear down everything when
4770 * the module is removed
4771 * or the h/w is unplugged.
4772 */
4773 }
4774
4775 rc = scsi_add_host(ap->host, dev);
4776 if (rc) {
4777 printk(KERN_ERR "ata%u: scsi_add_host failed\n",
4778 ap->id);
4779 /* FIXME: do something useful here */
4780 /* FIXME: handle unconditional calls to
4781 * scsi_scan_host and ata_host_remove, below,
4782 * at the very least
4783 */
4784 }
4785 }
4786
4787 /* probes are done, now scan each port's disk(s) */
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004788 DPRINTK("host probe begin\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004789 for (i = 0; i < count; i++) {
4790 struct ata_port *ap = host_set->ports[i];
4791
Jeff Garzik644dd0c2005-10-03 15:55:19 -04004792 ata_scsi_scan_host(ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004793 }
4794
4795 dev_set_drvdata(dev, host_set);
4796
4797 VPRINTK("EXIT, returning %u\n", ent->n_ports);
4798 return ent->n_ports; /* success */
4799
4800err_out:
4801 for (i = 0; i < count; i++) {
4802 ata_host_remove(host_set->ports[i], 1);
4803 scsi_host_put(host_set->ports[i]->host);
4804 }
Randy Dunlap57f3bda2005-10-28 20:37:23 -07004805err_free_ret:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004806 kfree(host_set);
4807 VPRINTK("EXIT, returning 0\n");
4808 return 0;
4809}
4810
4811/**
Alan Cox17b14452005-09-15 15:44:00 +01004812 * ata_host_set_remove - PCI layer callback for device removal
4813 * @host_set: ATA host set that was removed
4814 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05004815 * Unregister all objects associated with this host set. Free those
Alan Cox17b14452005-09-15 15:44:00 +01004816 * objects.
4817 *
4818 * LOCKING:
4819 * Inherited from calling layer (may sleep).
4820 */
4821
Alan Cox17b14452005-09-15 15:44:00 +01004822void ata_host_set_remove(struct ata_host_set *host_set)
4823{
4824 struct ata_port *ap;
4825 unsigned int i;
4826
4827 for (i = 0; i < host_set->n_ports; i++) {
4828 ap = host_set->ports[i];
4829 scsi_remove_host(ap->host);
4830 }
4831
4832 free_irq(host_set->irq, host_set);
4833
4834 for (i = 0; i < host_set->n_ports; i++) {
4835 ap = host_set->ports[i];
4836
4837 ata_scsi_release(ap->host);
4838
4839 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
4840 struct ata_ioports *ioaddr = &ap->ioaddr;
4841
4842 if (ioaddr->cmd_addr == 0x1f0)
4843 release_region(0x1f0, 8);
4844 else if (ioaddr->cmd_addr == 0x170)
4845 release_region(0x170, 8);
4846 }
4847
4848 scsi_host_put(ap->host);
4849 }
4850
4851 if (host_set->ops->host_stop)
4852 host_set->ops->host_stop(host_set);
4853
4854 kfree(host_set);
4855}
4856
4857/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004858 * ata_scsi_release - SCSI layer callback hook for host unload
4859 * @host: libata host to be unloaded
4860 *
4861 * Performs all duties necessary to shut down a libata port...
4862 * Kill port kthread, disable port, and release resources.
4863 *
4864 * LOCKING:
4865 * Inherited from SCSI layer.
4866 *
4867 * RETURNS:
4868 * One.
4869 */
4870
4871int ata_scsi_release(struct Scsi_Host *host)
4872{
4873 struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
Tejun Heod9572b12006-03-01 16:09:35 +09004874 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004875
4876 DPRINTK("ENTER\n");
4877
4878 ap->ops->port_disable(ap);
4879 ata_host_remove(ap, 0);
Tejun Heod9572b12006-03-01 16:09:35 +09004880 for (i = 0; i < ATA_MAX_DEVICES; i++)
4881 kfree(ap->device[i].id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004882
4883 DPRINTK("EXIT\n");
4884 return 1;
4885}
4886
4887/**
4888 * ata_std_ports - initialize ioaddr with standard port offsets.
4889 * @ioaddr: IO address structure to be initialized
Edward Falk0baab862005-06-02 18:17:13 -04004890 *
4891 * Utility function which initializes data_addr, error_addr,
4892 * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
4893 * device_addr, status_addr, and command_addr to standard offsets
4894 * relative to cmd_addr.
4895 *
4896 * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004897 */
Edward Falk0baab862005-06-02 18:17:13 -04004898
Linus Torvalds1da177e2005-04-16 15:20:36 -07004899void ata_std_ports(struct ata_ioports *ioaddr)
4900{
4901 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
4902 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
4903 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
4904 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
4905 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
4906 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
4907 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
4908 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
4909 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
4910 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
4911}
4912
Edward Falk0baab862005-06-02 18:17:13 -04004913
Jeff Garzik374b1872005-08-30 05:42:52 -04004914#ifdef CONFIG_PCI
4915
4916void ata_pci_host_stop (struct ata_host_set *host_set)
4917{
4918 struct pci_dev *pdev = to_pci_dev(host_set->dev);
4919
4920 pci_iounmap(pdev, host_set->mmio_base);
4921}
4922
Edward Falk0baab862005-06-02 18:17:13 -04004923/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004924 * ata_pci_remove_one - PCI layer callback for device removal
4925 * @pdev: PCI device that was removed
4926 *
4927 * PCI layer indicates to libata via this hook that
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004928 * hot-unplug or module unload event has occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004929 * Handle this by unregistering all objects associated
4930 * with this PCI device. Free those objects. Then finally
4931 * release PCI resources and disable device.
4932 *
4933 * LOCKING:
4934 * Inherited from PCI layer (may sleep).
4935 */
4936
4937void ata_pci_remove_one (struct pci_dev *pdev)
4938{
4939 struct device *dev = pci_dev_to_dev(pdev);
4940 struct ata_host_set *host_set = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004941
Alan Cox17b14452005-09-15 15:44:00 +01004942 ata_host_set_remove(host_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004943 pci_release_regions(pdev);
4944 pci_disable_device(pdev);
4945 dev_set_drvdata(dev, NULL);
4946}
4947
4948/* move to PCI subsystem */
Jeff Garzik057ace52005-10-22 14:27:05 -04004949int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004950{
4951 unsigned long tmp = 0;
4952
4953 switch (bits->width) {
4954 case 1: {
4955 u8 tmp8 = 0;
4956 pci_read_config_byte(pdev, bits->reg, &tmp8);
4957 tmp = tmp8;
4958 break;
4959 }
4960 case 2: {
4961 u16 tmp16 = 0;
4962 pci_read_config_word(pdev, bits->reg, &tmp16);
4963 tmp = tmp16;
4964 break;
4965 }
4966 case 4: {
4967 u32 tmp32 = 0;
4968 pci_read_config_dword(pdev, bits->reg, &tmp32);
4969 tmp = tmp32;
4970 break;
4971 }
4972
4973 default:
4974 return -EINVAL;
4975 }
4976
4977 tmp &= bits->mask;
4978
4979 return (tmp == bits->val) ? 1 : 0;
4980}
Jens Axboe9b847542006-01-06 09:28:07 +01004981
4982int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state)
4983{
4984 pci_save_state(pdev);
4985 pci_disable_device(pdev);
4986 pci_set_power_state(pdev, PCI_D3hot);
4987 return 0;
4988}
4989
4990int ata_pci_device_resume(struct pci_dev *pdev)
4991{
4992 pci_set_power_state(pdev, PCI_D0);
4993 pci_restore_state(pdev);
4994 pci_enable_device(pdev);
4995 pci_set_master(pdev);
4996 return 0;
4997}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004998#endif /* CONFIG_PCI */
4999
5000
Linus Torvalds1da177e2005-04-16 15:20:36 -07005001static int __init ata_init(void)
5002{
5003 ata_wq = create_workqueue("ata");
5004 if (!ata_wq)
5005 return -ENOMEM;
5006
5007 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
5008 return 0;
5009}
5010
5011static void __exit ata_exit(void)
5012{
5013 destroy_workqueue(ata_wq);
5014}
5015
5016module_init(ata_init);
5017module_exit(ata_exit);
5018
Jeff Garzik67846b32005-10-05 02:58:32 -04005019static unsigned long ratelimit_time;
5020static spinlock_t ata_ratelimit_lock = SPIN_LOCK_UNLOCKED;
5021
5022int ata_ratelimit(void)
5023{
5024 int rc;
5025 unsigned long flags;
5026
5027 spin_lock_irqsave(&ata_ratelimit_lock, flags);
5028
5029 if (time_after(jiffies, ratelimit_time)) {
5030 rc = 1;
5031 ratelimit_time = jiffies + (HZ/5);
5032 } else
5033 rc = 0;
5034
5035 spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
5036
5037 return rc;
5038}
5039
Linus Torvalds1da177e2005-04-16 15:20:36 -07005040/*
5041 * libata is essentially a library of internal helper functions for
5042 * low-level ATA host controller drivers. As such, the API/ABI is
5043 * likely to change as new drivers are added and updated.
5044 * Do not depend on ABI/API stability.
5045 */
5046
5047EXPORT_SYMBOL_GPL(ata_std_bios_param);
5048EXPORT_SYMBOL_GPL(ata_std_ports);
5049EXPORT_SYMBOL_GPL(ata_device_add);
Alan Cox17b14452005-09-15 15:44:00 +01005050EXPORT_SYMBOL_GPL(ata_host_set_remove);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005051EXPORT_SYMBOL_GPL(ata_sg_init);
5052EXPORT_SYMBOL_GPL(ata_sg_init_one);
Tejun Heo76014422006-02-11 15:13:49 +09005053EXPORT_SYMBOL_GPL(__ata_qc_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005054EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005055EXPORT_SYMBOL_GPL(ata_tf_load);
5056EXPORT_SYMBOL_GPL(ata_tf_read);
5057EXPORT_SYMBOL_GPL(ata_noop_dev_select);
5058EXPORT_SYMBOL_GPL(ata_std_dev_select);
5059EXPORT_SYMBOL_GPL(ata_tf_to_fis);
5060EXPORT_SYMBOL_GPL(ata_tf_from_fis);
5061EXPORT_SYMBOL_GPL(ata_check_status);
5062EXPORT_SYMBOL_GPL(ata_altstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005063EXPORT_SYMBOL_GPL(ata_exec_command);
5064EXPORT_SYMBOL_GPL(ata_port_start);
5065EXPORT_SYMBOL_GPL(ata_port_stop);
Jeff Garzikaa8f0dc2005-05-26 21:54:27 -04005066EXPORT_SYMBOL_GPL(ata_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005067EXPORT_SYMBOL_GPL(ata_interrupt);
5068EXPORT_SYMBOL_GPL(ata_qc_prep);
Brian Kinge46834c2006-03-17 17:04:03 -06005069EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005070EXPORT_SYMBOL_GPL(ata_bmdma_setup);
5071EXPORT_SYMBOL_GPL(ata_bmdma_start);
5072EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
5073EXPORT_SYMBOL_GPL(ata_bmdma_status);
5074EXPORT_SYMBOL_GPL(ata_bmdma_stop);
5075EXPORT_SYMBOL_GPL(ata_port_probe);
5076EXPORT_SYMBOL_GPL(sata_phy_reset);
5077EXPORT_SYMBOL_GPL(__sata_phy_reset);
5078EXPORT_SYMBOL_GPL(ata_bus_reset);
Tejun Heo8a19ac82006-02-02 18:20:00 +09005079EXPORT_SYMBOL_GPL(ata_std_probeinit);
Tejun Heoc2bd5802006-01-24 17:05:22 +09005080EXPORT_SYMBOL_GPL(ata_std_softreset);
5081EXPORT_SYMBOL_GPL(sata_std_hardreset);
5082EXPORT_SYMBOL_GPL(ata_std_postreset);
5083EXPORT_SYMBOL_GPL(ata_std_probe_reset);
Tejun Heoa62c0fc2006-01-24 17:05:22 +09005084EXPORT_SYMBOL_GPL(ata_drive_probe_reset);
Tejun Heo623a3122006-03-05 17:55:58 +09005085EXPORT_SYMBOL_GPL(ata_dev_revalidate);
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05005086EXPORT_SYMBOL_GPL(ata_dev_classify);
5087EXPORT_SYMBOL_GPL(ata_dev_pair);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005088EXPORT_SYMBOL_GPL(ata_port_disable);
Jeff Garzik67846b32005-10-05 02:58:32 -04005089EXPORT_SYMBOL_GPL(ata_ratelimit);
Tejun Heo6f8b9952006-01-24 17:05:21 +09005090EXPORT_SYMBOL_GPL(ata_busy_sleep);
Tejun Heo86e45b62006-03-05 15:29:09 +09005091EXPORT_SYMBOL_GPL(ata_port_queue_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005092EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
5093EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005094EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
5095EXPORT_SYMBOL_GPL(ata_scsi_release);
5096EXPORT_SYMBOL_GPL(ata_host_intr);
Tejun Heo6a62a042006-02-13 10:02:46 +09005097EXPORT_SYMBOL_GPL(ata_id_string);
5098EXPORT_SYMBOL_GPL(ata_id_c_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005099EXPORT_SYMBOL_GPL(ata_scsi_simulate);
5100
Alan Cox1bc4ccf2006-01-09 17:18:14 +00005101EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
Alan Cox452503f2005-10-21 19:01:32 -04005102EXPORT_SYMBOL_GPL(ata_timing_compute);
5103EXPORT_SYMBOL_GPL(ata_timing_merge);
5104
Linus Torvalds1da177e2005-04-16 15:20:36 -07005105#ifdef CONFIG_PCI
5106EXPORT_SYMBOL_GPL(pci_test_config_bits);
Jeff Garzik374b1872005-08-30 05:42:52 -04005107EXPORT_SYMBOL_GPL(ata_pci_host_stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005108EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
5109EXPORT_SYMBOL_GPL(ata_pci_init_one);
5110EXPORT_SYMBOL_GPL(ata_pci_remove_one);
Jens Axboe9b847542006-01-06 09:28:07 +01005111EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
5112EXPORT_SYMBOL_GPL(ata_pci_device_resume);
Alan Cox67951ad2006-03-22 15:55:54 +00005113EXPORT_SYMBOL_GPL(ata_pci_default_filter);
5114EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005115#endif /* CONFIG_PCI */
Jens Axboe9b847542006-01-06 09:28:07 +01005116
5117EXPORT_SYMBOL_GPL(ata_device_suspend);
5118EXPORT_SYMBOL_GPL(ata_device_resume);
5119EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
5120EXPORT_SYMBOL_GPL(ata_scsi_device_resume);
Tejun Heoece1d632006-04-02 18:51:53 +09005121
5122EXPORT_SYMBOL_GPL(ata_scsi_error);
5123EXPORT_SYMBOL_GPL(ata_eng_timeout);
5124EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
5125EXPORT_SYMBOL_GPL(ata_eh_qc_retry);