libata-core.c 191.8 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
 *  libata-core.c - helper library for ATA
 *
 *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
 *    		    Please ALWAYS copy linux-ide@vger.kernel.org
 *		    on emails.
 *
 *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
 *  Copyright 2003-2004 Jeff Garzik
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/DocBook/libata.*
 *
 *  Hardware documentation available from http://www.t13.org/ and
 *  http://www.sata-io.org/
 *
33 34 35 36 37 38 39 40
 *  Standards documents from:
 *	http://www.t13.org (ATA standards, PCI DMA IDE spec)
 *	http://www.t10.org (SCSI MMC - for ATAPI MMC)
 *	http://www.sata-io.org (SATA)
 *	http://www.compactflash.org (CF)
 *	http://www.qic.org (QIC157 - Tape and DSC)
 *	http://www.ce-ata.org (CE-ATA: not supported)
 *
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/spinlock.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/completion.h>
#include <linux/suspend.h>
#include <linux/workqueue.h>
58
#include <linux/jiffies.h>
59
#include <linux/scatterlist.h>
60
#include <linux/io.h>
L
Linus Torvalds 已提交
61
#include <scsi/scsi.h>
62
#include <scsi/scsi_cmnd.h>
L
Linus Torvalds 已提交
63 64 65 66
#include <scsi/scsi_host.h>
#include <linux/libata.h>
#include <asm/semaphore.h>
#include <asm/byteorder.h>
T
Tejun Heo 已提交
67
#include <linux/cdrom.h>
L
Linus Torvalds 已提交
68 69 70

#include "libata.h"

71

72
/* debounce timing parameters in msecs { interval, duration, timeout } */
73 74 75
const unsigned long sata_deb_timing_normal[]		= {   5,  100, 2000 };
const unsigned long sata_deb_timing_hotplug[]		= {  25,  500, 2000 };
const unsigned long sata_deb_timing_long[]		= { 100, 2000, 5000 };
76

T
Tejun Heo 已提交
77 78 79
static unsigned int ata_dev_init_params(struct ata_device *dev,
					u16 heads, u16 sectors);
static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
80 81
static unsigned int ata_dev_set_feature(struct ata_device *dev,
					u8 enable, u8 feature);
T
Tejun Heo 已提交
82
static void ata_dev_xfermask(struct ata_device *dev);
T
Tejun Heo 已提交
83
static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
L
Linus Torvalds 已提交
84

85
unsigned int ata_print_id = 1;
L
Linus Torvalds 已提交
86 87
static struct workqueue_struct *ata_wq;

88 89
struct workqueue_struct *ata_aux_wq;

J
Jeff Garzik 已提交
90
int atapi_enabled = 1;
91 92 93
module_param(atapi_enabled, int, 0444);
MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");

94 95 96 97
int atapi_dmadir = 0;
module_param(atapi_dmadir, int, 0444);
MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");

98 99 100 101
int atapi_passthru16 = 1;
module_param(atapi_passthru16, int, 0444);
MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)");

J
Jeff Garzik 已提交
102 103 104 105
int libata_fua = 0;
module_param_named(fua, libata_fua, int, 0444);
MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");

106
static int ata_ignore_hpa;
A
Alan Cox 已提交
107 108 109
module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");

110 111 112 113
static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
module_param_named(dma, libata_dma_mask, int, 0444);
MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");

A
Andrew Morton 已提交
114 115 116 117
static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ;
module_param(ata_probe_timeout, int, 0444);
MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");

J
Jeff Garzik 已提交
118
int libata_noacpi = 0;
119
module_param_named(noacpi, libata_noacpi, int, 0444);
J
Jeff Garzik 已提交
120
MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set");
121

L
Linus Torvalds 已提交
122 123 124 125 126
MODULE_AUTHOR("Jeff Garzik");
MODULE_DESCRIPTION("Library module for ATA devices");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);

E
Edward Falk 已提交
127

L
Linus Torvalds 已提交
128 129 130 131
/**
 *	ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
 *	@tf: Taskfile to convert
 *	@pmp: Port multiplier port
132 133
 *	@is_cmd: This FIS is for command
 *	@fis: Buffer into which data will output
L
Linus Torvalds 已提交
134 135 136 137 138 139 140
 *
 *	Converts a standard ATA taskfile to a Serial ATA
 *	FIS structure (Register - Host to Device).
 *
 *	LOCKING:
 *	Inherited from caller.
 */
141
void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis)
L
Linus Torvalds 已提交
142
{
143 144 145 146 147
	fis[0] = 0x27;			/* Register - Host to Device FIS */
	fis[1] = pmp & 0xf;		/* Port multiplier number*/
	if (is_cmd)
		fis[1] |= (1 << 7);	/* bit 7 indicates Command FIS */

L
Linus Torvalds 已提交
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
	fis[2] = tf->command;
	fis[3] = tf->feature;

	fis[4] = tf->lbal;
	fis[5] = tf->lbam;
	fis[6] = tf->lbah;
	fis[7] = tf->device;

	fis[8] = tf->hob_lbal;
	fis[9] = tf->hob_lbam;
	fis[10] = tf->hob_lbah;
	fis[11] = tf->hob_feature;

	fis[12] = tf->nsect;
	fis[13] = tf->hob_nsect;
	fis[14] = 0;
	fis[15] = tf->ctl;

	fis[16] = 0;
	fis[17] = 0;
	fis[18] = 0;
	fis[19] = 0;
}

/**
 *	ata_tf_from_fis - Convert SATA FIS to ATA taskfile
 *	@fis: Buffer from which data will be input
 *	@tf: Taskfile to output
 *
177
 *	Converts a serial ATA FIS structure to a standard ATA taskfile.
L
Linus Torvalds 已提交
178 179 180 181 182
 *
 *	LOCKING:
 *	Inherited from caller.
 */

J
Jeff Garzik 已提交
183
void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
L
Linus Torvalds 已提交
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
{
	tf->command	= fis[2];	/* status */
	tf->feature	= fis[3];	/* error */

	tf->lbal	= fis[4];
	tf->lbam	= fis[5];
	tf->lbah	= fis[6];
	tf->device	= fis[7];

	tf->hob_lbal	= fis[8];
	tf->hob_lbam	= fis[9];
	tf->hob_lbah	= fis[10];

	tf->nsect	= fis[12];
	tf->hob_nsect	= fis[13];
}

201 202 203 204 205 206
static const u8 ata_rw_cmds[] = {
	/* pio multi */
	ATA_CMD_READ_MULTI,
	ATA_CMD_WRITE_MULTI,
	ATA_CMD_READ_MULTI_EXT,
	ATA_CMD_WRITE_MULTI_EXT,
T
Tejun Heo 已提交
207 208 209 210
	0,
	0,
	0,
	ATA_CMD_WRITE_MULTI_FUA_EXT,
211 212 213 214 215
	/* pio */
	ATA_CMD_PIO_READ,
	ATA_CMD_PIO_WRITE,
	ATA_CMD_PIO_READ_EXT,
	ATA_CMD_PIO_WRITE_EXT,
T
Tejun Heo 已提交
216 217 218 219
	0,
	0,
	0,
	0,
220 221 222 223
	/* dma */
	ATA_CMD_READ,
	ATA_CMD_WRITE,
	ATA_CMD_READ_EXT,
T
Tejun Heo 已提交
224 225 226 227 228
	ATA_CMD_WRITE_EXT,
	0,
	0,
	0,
	ATA_CMD_WRITE_FUA_EXT
229
};
L
Linus Torvalds 已提交
230 231

/**
232
 *	ata_rwcmd_protocol - set taskfile r/w commands and protocol
233 234
 *	@tf: command to examine and configure
 *	@dev: device tf belongs to
L
Linus Torvalds 已提交
235
 *
236
 *	Examine the device configuration and tf->flags to calculate
237
 *	the proper read/write commands and protocol to use.
L
Linus Torvalds 已提交
238 239 240 241
 *
 *	LOCKING:
 *	caller.
 */
242
static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
L
Linus Torvalds 已提交
243
{
T
Tejun Heo 已提交
244
	u8 cmd;
L
Linus Torvalds 已提交
245

T
Tejun Heo 已提交
246
	int index, fua, lba48, write;
247

T
Tejun Heo 已提交
248
	fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
249 250
	lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
	write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
L
Linus Torvalds 已提交
251

252 253
	if (dev->flags & ATA_DFLAG_PIO) {
		tf->protocol = ATA_PROT_PIO;
T
Tejun Heo 已提交
254
		index = dev->multi_count ? 0 : 8;
T
Tejun Heo 已提交
255
	} else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
256 257
		/* Unable to use DMA due to host limitation */
		tf->protocol = ATA_PROT_PIO;
258
		index = dev->multi_count ? 0 : 8;
259 260
	} else {
		tf->protocol = ATA_PROT_DMA;
T
Tejun Heo 已提交
261
		index = 16;
262
	}
L
Linus Torvalds 已提交
263

T
Tejun Heo 已提交
264 265 266 267 268 269
	cmd = ata_rw_cmds[index + fua + lba48 + write];
	if (cmd) {
		tf->command = cmd;
		return 0;
	}
	return -1;
L
Linus Torvalds 已提交
270 271
}

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
/**
 *	ata_tf_read_block - Read block address from ATA taskfile
 *	@tf: ATA taskfile of interest
 *	@dev: ATA device @tf belongs to
 *
 *	LOCKING:
 *	None.
 *
 *	Read block address from @tf.  This function can handle all
 *	three address formats - LBA, LBA48 and CHS.  tf->protocol and
 *	flags select the address format to use.
 *
 *	RETURNS:
 *	Block address read from @tf.
 */
u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev)
{
	u64 block = 0;

	if (tf->flags & ATA_TFLAG_LBA) {
		if (tf->flags & ATA_TFLAG_LBA48) {
			block |= (u64)tf->hob_lbah << 40;
			block |= (u64)tf->hob_lbam << 32;
			block |= tf->hob_lbal << 24;
		} else
			block |= (tf->device & 0xf) << 24;

		block |= tf->lbah << 16;
		block |= tf->lbam << 8;
		block |= tf->lbal;
	} else {
		u32 cyl, head, sect;

		cyl = tf->lbam | (tf->lbah << 8);
		head = tf->device & 0xf;
		sect = tf->lbal;

		block = (cyl * dev->heads + head) * dev->sectors + sect;
	}

	return block;
}

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
/**
 *	ata_build_rw_tf - Build ATA taskfile for given read/write request
 *	@tf: Target ATA taskfile
 *	@dev: ATA device @tf belongs to
 *	@block: Block address
 *	@n_block: Number of blocks
 *	@tf_flags: RW/FUA etc...
 *	@tag: tag
 *
 *	LOCKING:
 *	None.
 *
 *	Build ATA taskfile @tf for read/write request described by
 *	@block, @n_block, @tf_flags and @tag on @dev.
 *
 *	RETURNS:
 *
 *	0 on success, -ERANGE if the request is too large for @dev,
 *	-EINVAL if the request is invalid.
 */
int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
		    u64 block, u32 n_block, unsigned int tf_flags,
		    unsigned int tag)
{
	tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
	tf->flags |= tf_flags;

342
	if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) {
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
		/* yay, NCQ */
		if (!lba_48_ok(block, n_block))
			return -ERANGE;

		tf->protocol = ATA_PROT_NCQ;
		tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;

		if (tf->flags & ATA_TFLAG_WRITE)
			tf->command = ATA_CMD_FPDMA_WRITE;
		else
			tf->command = ATA_CMD_FPDMA_READ;

		tf->nsect = tag << 3;
		tf->hob_feature = (n_block >> 8) & 0xff;
		tf->feature = n_block & 0xff;

		tf->hob_lbah = (block >> 40) & 0xff;
		tf->hob_lbam = (block >> 32) & 0xff;
		tf->hob_lbal = (block >> 24) & 0xff;
		tf->lbah = (block >> 16) & 0xff;
		tf->lbam = (block >> 8) & 0xff;
		tf->lbal = block & 0xff;

		tf->device = 1 << 6;
		if (tf->flags & ATA_TFLAG_FUA)
			tf->device |= 1 << 7;
	} else if (dev->flags & ATA_DFLAG_LBA) {
		tf->flags |= ATA_TFLAG_LBA;

		if (lba_28_ok(block, n_block)) {
			/* use LBA28 */
			tf->device |= (block >> 24) & 0xf;
		} else if (lba_48_ok(block, n_block)) {
			if (!(dev->flags & ATA_DFLAG_LBA48))
				return -ERANGE;

			/* use LBA48 */
			tf->flags |= ATA_TFLAG_LBA48;

			tf->hob_nsect = (n_block >> 8) & 0xff;

			tf->hob_lbah = (block >> 40) & 0xff;
			tf->hob_lbam = (block >> 32) & 0xff;
			tf->hob_lbal = (block >> 24) & 0xff;
		} else
			/* request too large even for LBA48 */
			return -ERANGE;

		if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
			return -EINVAL;

		tf->nsect = n_block & 0xff;

		tf->lbah = (block >> 16) & 0xff;
		tf->lbam = (block >> 8) & 0xff;
		tf->lbal = block & 0xff;

		tf->device |= ATA_LBA;
	} else {
		/* CHS */
		u32 sect, head, cyl, track;

		/* The request -may- be too large for CHS addressing. */
		if (!lba_28_ok(block, n_block))
			return -ERANGE;

		if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
			return -EINVAL;

		/* Convert LBA to CHS */
		track = (u32)block / dev->sectors;
		cyl   = track / dev->heads;
		head  = track % dev->heads;
		sect  = (u32)block % dev->sectors + 1;

		DPRINTK("block %u track %u cyl %u head %u sect %u\n",
			(u32)block, track, cyl, head, sect);

		/* Check whether the converted CHS can fit.
		   Cylinder: 0-65535
		   Head: 0-15
		   Sector: 1-255*/
		if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
			return -ERANGE;

		tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
		tf->lbal = sect;
		tf->lbam = cyl;
		tf->lbah = cyl >> 8;
		tf->device |= head;
	}

	return 0;
}

438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
/**
 *	ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
 *	@pio_mask: pio_mask
 *	@mwdma_mask: mwdma_mask
 *	@udma_mask: udma_mask
 *
 *	Pack @pio_mask, @mwdma_mask and @udma_mask into a single
 *	unsigned int xfer_mask.
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	Packed xfer_mask.
 */
static unsigned int ata_pack_xfermask(unsigned int pio_mask,
				      unsigned int mwdma_mask,
				      unsigned int udma_mask)
{
	return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
		((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
		((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
}

462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
/**
 *	ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
 *	@xfer_mask: xfer_mask to unpack
 *	@pio_mask: resulting pio_mask
 *	@mwdma_mask: resulting mwdma_mask
 *	@udma_mask: resulting udma_mask
 *
 *	Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
 *	Any NULL distination masks will be ignored.
 */
static void ata_unpack_xfermask(unsigned int xfer_mask,
				unsigned int *pio_mask,
				unsigned int *mwdma_mask,
				unsigned int *udma_mask)
{
	if (pio_mask)
		*pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
	if (mwdma_mask)
		*mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
	if (udma_mask)
		*udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
}

485
static const struct ata_xfer_ent {
486
	int shift, bits;
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
	u8 base;
} ata_xfer_tbl[] = {
	{ ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
	{ ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
	{ ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
	{ -1, },
};

/**
 *	ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
 *	@xfer_mask: xfer_mask of interest
 *
 *	Return matching XFER_* value for @xfer_mask.  Only the highest
 *	bit of @xfer_mask is considered.
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	Matching XFER_* value, 0 if no match found.
 */
static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
{
	int highbit = fls(xfer_mask) - 1;
	const struct ata_xfer_ent *ent;

	for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
		if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
			return ent->base + highbit - ent->shift;
	return 0;
}

/**
 *	ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
 *	@xfer_mode: XFER_* of interest
 *
 *	Return matching xfer_mask for @xfer_mode.
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	Matching xfer_mask, 0 if no match found.
 */
static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
{
	const struct ata_xfer_ent *ent;

	for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
		if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
			return 1 << (ent->shift + xfer_mode - ent->base);
	return 0;
}

/**
 *	ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
 *	@xfer_mode: XFER_* of interest
 *
 *	Return matching xfer_shift for @xfer_mode.
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	Matching xfer_shift, -1 if no match found.
 */
static int ata_xfer_mode2shift(unsigned int xfer_mode)
{
	const struct ata_xfer_ent *ent;

	for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
		if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
			return ent->shift;
	return -1;
}

L
Linus Torvalds 已提交
563
/**
564 565
 *	ata_mode_string - convert xfer_mask to string
 *	@xfer_mask: mask of bits supported; only highest bit counts.
L
Linus Torvalds 已提交
566 567
 *
 *	Determine string which represents the highest speed
568
 *	(highest bit in @modemask).
L
Linus Torvalds 已提交
569 570 571 572 573 574
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	Constant C string representing highest speed listed in
575
 *	@mode_mask, or the constant C string "<n/a>".
L
Linus Torvalds 已提交
576
 */
577
static const char *ata_mode_string(unsigned int xfer_mask)
L
Linus Torvalds 已提交
578
{
579 580 581 582 583 584
	static const char * const xfer_mode_str[] = {
		"PIO0",
		"PIO1",
		"PIO2",
		"PIO3",
		"PIO4",
585 586
		"PIO5",
		"PIO6",
587 588 589
		"MWDMA0",
		"MWDMA1",
		"MWDMA2",
590 591
		"MWDMA3",
		"MWDMA4",
592 593 594 595 596 597 598 599 600
		"UDMA/16",
		"UDMA/25",
		"UDMA/33",
		"UDMA/44",
		"UDMA/66",
		"UDMA/100",
		"UDMA/133",
		"UDMA7",
	};
601
	int highbit;
L
Linus Torvalds 已提交
602

603 604 605
	highbit = fls(xfer_mask) - 1;
	if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
		return xfer_mode_str[highbit];
L
Linus Torvalds 已提交
606 607 608
	return "<n/a>";
}

609 610 611 612 613 614 615 616 617 618 619 620
static const char *sata_spd_string(unsigned int spd)
{
	static const char * const spd_str[] = {
		"1.5 Gbps",
		"3.0 Gbps",
	};

	if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
		return "<unknown>";
	return spd_str[spd - 1];
}

T
Tejun Heo 已提交
621
void ata_dev_disable(struct ata_device *dev)
622
{
T
Tejun Heo 已提交
623
	if (ata_dev_enabled(dev)) {
T
Tejun Heo 已提交
624
		if (ata_msg_drv(dev->link->ap))
T
Tejun Heo 已提交
625
			ata_dev_printk(dev, KERN_WARNING, "disabled\n");
626
		ata_acpi_on_disable(dev);
627 628
		ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |
					     ATA_DNXFER_QUIET);
629 630 631 632
		dev->class++;
	}
}

633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
static int ata_dev_set_dipm(struct ata_device *dev, enum link_pm policy)
{
	struct ata_link *link = dev->link;
	struct ata_port *ap = link->ap;
	u32 scontrol;
	unsigned int err_mask;
	int rc;

	/*
	 * disallow DIPM for drivers which haven't set
	 * ATA_FLAG_IPM.  This is because when DIPM is enabled,
	 * phy ready will be set in the interrupt status on
	 * state changes, which will cause some drivers to
	 * think there are errors - additionally drivers will
	 * need to disable hot plug.
	 */
	if (!(ap->flags & ATA_FLAG_IPM) || !ata_dev_enabled(dev)) {
		ap->pm_policy = NOT_AVAILABLE;
		return -EINVAL;
	}

	/*
	 * For DIPM, we will only enable it for the
	 * min_power setting.
	 *
	 * Why?  Because Disks are too stupid to know that
	 * If the host rejects a request to go to SLUMBER
	 * they should retry at PARTIAL, and instead it
	 * just would give up.  So, for medium_power to
	 * work at all, we need to only allow HIPM.
	 */
	rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
	if (rc)
		return rc;

	switch (policy) {
	case MIN_POWER:
		/* no restrictions on IPM transitions */
		scontrol &= ~(0x3 << 8);
		rc = sata_scr_write(link, SCR_CONTROL, scontrol);
		if (rc)
			return rc;

		/* enable DIPM */
		if (dev->flags & ATA_DFLAG_DIPM)
			err_mask = ata_dev_set_feature(dev,
					SETFEATURES_SATA_ENABLE, SATA_DIPM);
		break;
	case MEDIUM_POWER:
		/* allow IPM to PARTIAL */
		scontrol &= ~(0x1 << 8);
		scontrol |= (0x2 << 8);
		rc = sata_scr_write(link, SCR_CONTROL, scontrol);
		if (rc)
			return rc;

689 690 691 692 693
		/*
		 * we don't have to disable DIPM since IPM flags
		 * disallow transitions to SLUMBER, which effectively
		 * disable DIPM if it does not support PARTIAL
		 */
694 695 696 697 698 699 700 701 702
		break;
	case NOT_AVAILABLE:
	case MAX_PERFORMANCE:
		/* disable all IPM transitions */
		scontrol |= (0x3 << 8);
		rc = sata_scr_write(link, SCR_CONTROL, scontrol);
		if (rc)
			return rc;

703 704 705 706 707
		/*
		 * we don't have to disable DIPM since IPM flags
		 * disallow all transitions which effectively
		 * disable DIPM anyway.
		 */
708 709 710 711 712 713 714 715 716 717 718
		break;
	}

	/* FIXME: handle SET FEATURES failure */
	(void) err_mask;

	return 0;
}

/**
 *	ata_dev_enable_pm - enable SATA interface power management
S
Stephen Hemminger 已提交
719 720
 *	@dev:  device to enable power management
 *	@policy: the link power management policy
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
 *
 *	Enable SATA Interface power management.  This will enable
 *	Device Interface Power Management (DIPM) for min_power
 * 	policy, and then call driver specific callbacks for
 *	enabling Host Initiated Power management.
 *
 *	Locking: Caller.
 *	Returns: -EINVAL if IPM is not supported, 0 otherwise.
 */
void ata_dev_enable_pm(struct ata_device *dev, enum link_pm policy)
{
	int rc = 0;
	struct ata_port *ap = dev->link->ap;

	/* set HIPM first, then DIPM */
	if (ap->ops->enable_pm)
		rc = ap->ops->enable_pm(ap, policy);
	if (rc)
		goto enable_pm_out;
	rc = ata_dev_set_dipm(dev, policy);

enable_pm_out:
	if (rc)
		ap->pm_policy = MAX_PERFORMANCE;
	else
		ap->pm_policy = policy;
	return /* rc */;	/* hopefully we can use 'rc' eventually */
}

S
Stephen Rothwell 已提交
750
#ifdef CONFIG_PM
751 752
/**
 *	ata_dev_disable_pm - disable SATA interface power management
S
Stephen Hemminger 已提交
753
 *	@dev: device to disable power management
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
 *
 *	Disable SATA Interface power management.  This will disable
 *	Device Interface Power Management (DIPM) without changing
 * 	policy,  call driver specific callbacks for disabling Host
 * 	Initiated Power management.
 *
 *	Locking: Caller.
 *	Returns: void
 */
static void ata_dev_disable_pm(struct ata_device *dev)
{
	struct ata_port *ap = dev->link->ap;

	ata_dev_set_dipm(dev, MAX_PERFORMANCE);
	if (ap->ops->disable_pm)
		ap->ops->disable_pm(ap);
}
S
Stephen Rothwell 已提交
771
#endif	/* CONFIG_PM */
772 773 774 775 776 777 778 779 780

void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy)
{
	ap->pm_policy = policy;
	ap->link.eh_info.action |= ATA_EHI_LPM;
	ap->link.eh_info.flags |= ATA_EHI_NO_AUTOPSY;
	ata_port_schedule_eh(ap);
}

S
Stephen Rothwell 已提交
781
#ifdef CONFIG_PM
782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
static void ata_lpm_enable(struct ata_host *host)
{
	struct ata_link *link;
	struct ata_port *ap;
	struct ata_device *dev;
	int i;

	for (i = 0; i < host->n_ports; i++) {
		ap = host->ports[i];
		ata_port_for_each_link(link, ap) {
			ata_link_for_each_dev(dev, link)
				ata_dev_disable_pm(dev);
		}
	}
}

static void ata_lpm_disable(struct ata_host *host)
{
	int i;

	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];
		ata_lpm_schedule(ap, ap->pm_policy);
	}
}
S
Stephen Rothwell 已提交
807
#endif	/* CONFIG_PM */
808 809


L
Linus Torvalds 已提交
810
/**
T
Tejun Heo 已提交
811
 *	ata_devchk - PATA device presence detection
L
Linus Torvalds 已提交
812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
 *	@ap: ATA channel to examine
 *	@device: Device to examine (starting at zero)
 *
 *	This technique was originally described in
 *	Hale Landis's ATADRVR (www.ata-atapi.com), and
 *	later found its way into the ATA/ATAPI spec.
 *
 *	Write a pattern to the ATA shadow registers,
 *	and if a device is present, it will respond by
 *	correctly storing and echoing back the
 *	ATA shadow register contents.
 *
 *	LOCKING:
 *	caller.
 */

T
Tejun Heo 已提交
828
static unsigned int ata_devchk(struct ata_port *ap, unsigned int device)
L
Linus Torvalds 已提交
829 830 831 832 833 834
{
	struct ata_ioports *ioaddr = &ap->ioaddr;
	u8 nsect, lbal;

	ap->ops->dev_select(ap, device);

T
Tejun Heo 已提交
835 836
	iowrite8(0x55, ioaddr->nsect_addr);
	iowrite8(0xaa, ioaddr->lbal_addr);
L
Linus Torvalds 已提交
837

T
Tejun Heo 已提交
838 839
	iowrite8(0xaa, ioaddr->nsect_addr);
	iowrite8(0x55, ioaddr->lbal_addr);
L
Linus Torvalds 已提交
840

T
Tejun Heo 已提交
841 842
	iowrite8(0x55, ioaddr->nsect_addr);
	iowrite8(0xaa, ioaddr->lbal_addr);
L
Linus Torvalds 已提交
843

T
Tejun Heo 已提交
844 845
	nsect = ioread8(ioaddr->nsect_addr);
	lbal = ioread8(ioaddr->lbal_addr);
L
Linus Torvalds 已提交
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864

	if ((nsect == 0x55) && (lbal == 0xaa))
		return 1;	/* we found a device */

	return 0;		/* nothing found */
}

/**
 *	ata_dev_classify - determine device type based on ATA-spec signature
 *	@tf: ATA taskfile register set for device to be identified
 *
 *	Determine from taskfile register contents whether a device is
 *	ATA or ATAPI, as per "Signature and persistence" section
 *	of ATA/PI spec (volume 1, sect 5.14).
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
865 866
 *	Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP or
 *	%ATA_DEV_UNKNOWN the event of failure.
L
Linus Torvalds 已提交
867
 */
J
Jeff Garzik 已提交
868
unsigned int ata_dev_classify(const struct ata_taskfile *tf)
L
Linus Torvalds 已提交
869 870 871 872
{
	/* Apple's open source Darwin code hints that some devices only
	 * put a proper signature into the LBA mid/high registers,
	 * So, we only check those.  It's sufficient for uniqueness.
873 874 875 876 877 878 879 880 881 882 883 884 885 886
	 *
	 * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate
	 * signatures for ATA and ATAPI devices attached on SerialATA,
	 * 0x3c/0xc3 and 0x69/0x96 respectively.  However, SerialATA
	 * spec has never mentioned about using different signatures
	 * for ATA/ATAPI devices.  Then, Serial ATA II: Port
	 * Multiplier specification began to use 0x69/0x96 to identify
	 * port multpliers and 0x3c/0xc3 to identify SEMB device.
	 * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and
	 * 0x69/0x96 shortly and described them as reserved for
	 * SerialATA.
	 *
	 * We follow the current spec and consider that 0x69/0x96
	 * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
L
Linus Torvalds 已提交
887
	 */
888
	if ((tf->lbam == 0) && (tf->lbah == 0)) {
L
Linus Torvalds 已提交
889 890 891 892
		DPRINTK("found ATA device by sig\n");
		return ATA_DEV_ATA;
	}

893
	if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {
L
Linus Torvalds 已提交
894 895 896 897
		DPRINTK("found ATAPI device by sig\n");
		return ATA_DEV_ATAPI;
	}

898 899 900 901 902 903
	if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) {
		DPRINTK("found PMP device by sig\n");
		return ATA_DEV_PMP;
	}

	if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
904
		printk(KERN_INFO "ata: SEMB device ignored\n");
905 906 907
		return ATA_DEV_SEMB_UNSUP; /* not yet */
	}

L
Linus Torvalds 已提交
908 909 910 911 912 913
	DPRINTK("unknown device\n");
	return ATA_DEV_UNKNOWN;
}

/**
 *	ata_dev_try_classify - Parse returned ATA device signature
914 915
 *	@dev: ATA device to classify (starting at zero)
 *	@present: device seems present
916
 *	@r_err: Value of error register on completion
L
Linus Torvalds 已提交
917 918 919 920 921 922 923 924 925 926 927 928
 *
 *	After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
 *	an ATA/ATAPI-defined set of values is placed in the ATA
 *	shadow registers, indicating the results of device detection
 *	and diagnostics.
 *
 *	Select the ATA device, and read the values from the ATA shadow
 *	registers.  Then parse according to the Error register value,
 *	and the spec-defined values examined by ata_dev_classify().
 *
 *	LOCKING:
 *	caller.
929 930 931
 *
 *	RETURNS:
 *	Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
L
Linus Torvalds 已提交
932
 */
933 934
unsigned int ata_dev_try_classify(struct ata_device *dev, int present,
				  u8 *r_err)
L
Linus Torvalds 已提交
935
{
936
	struct ata_port *ap = dev->link->ap;
L
Linus Torvalds 已提交
937 938 939 940
	struct ata_taskfile tf;
	unsigned int class;
	u8 err;

941
	ap->ops->dev_select(ap, dev->devno);
L
Linus Torvalds 已提交
942 943 944 945

	memset(&tf, 0, sizeof(tf));

	ap->ops->tf_read(ap, &tf);
946
	err = tf.feature;
947 948
	if (r_err)
		*r_err = err;
L
Linus Torvalds 已提交
949

950
	/* see if device passed diags: if master then continue and warn later */
951
	if (err == 0 && dev->devno == 0)
952
		/* diagnostic fail : do nothing _YET_ */
953
		dev->horkage |= ATA_HORKAGE_DIAGNOSTIC;
954
	else if (err == 1)
L
Linus Torvalds 已提交
955
		/* do nothing */ ;
956
	else if ((dev->devno == 0) && (err == 0x81))
L
Linus Torvalds 已提交
957 958
		/* do nothing */ ;
	else
959
		return ATA_DEV_NONE;
L
Linus Torvalds 已提交
960

961
	/* determine if device is ATA or ATAPI */
L
Linus Torvalds 已提交
962
	class = ata_dev_classify(&tf);
963

964 965 966 967 968 969 970 971 972 973 974 975 976 977
	if (class == ATA_DEV_UNKNOWN) {
		/* If the device failed diagnostic, it's likely to
		 * have reported incorrect device signature too.
		 * Assume ATA device if the device seems present but
		 * device signature is invalid with diagnostic
		 * failure.
		 */
		if (present && (dev->horkage & ATA_HORKAGE_DIAGNOSTIC))
			class = ATA_DEV_ATA;
		else
			class = ATA_DEV_NONE;
	} else if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
		class = ATA_DEV_NONE;

978
	return class;
L
Linus Torvalds 已提交
979 980 981
}

/**
982
 *	ata_id_string - Convert IDENTIFY DEVICE page into string
L
Linus Torvalds 已提交
983 984 985 986 987 988 989 990 991 992 993 994 995
 *	@id: IDENTIFY DEVICE results we will examine
 *	@s: string into which data is output
 *	@ofs: offset into identify device page
 *	@len: length of string to return. must be an even number.
 *
 *	The strings in the IDENTIFY DEVICE page are broken up into
 *	16-bit chunks.  Run through the string, and output each
 *	8-bit chunk linearly, regardless of platform.
 *
 *	LOCKING:
 *	caller.
 */

996 997
void ata_id_string(const u16 *id, unsigned char *s,
		   unsigned int ofs, unsigned int len)
L
Linus Torvalds 已提交
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
{
	unsigned int c;

	while (len > 0) {
		c = id[ofs] >> 8;
		*s = c;
		s++;

		c = id[ofs] & 0xff;
		*s = c;
		s++;

		ofs++;
		len -= 2;
	}
}

1015
/**
1016
 *	ata_id_c_string - Convert IDENTIFY DEVICE page into C string
1017 1018 1019 1020 1021
 *	@id: IDENTIFY DEVICE results we will examine
 *	@s: string into which data is output
 *	@ofs: offset into identify device page
 *	@len: length of string to return. must be an odd number.
 *
1022
 *	This function is identical to ata_id_string except that it
1023 1024 1025 1026 1027 1028
 *	trims trailing spaces and terminates the resulting string with
 *	null.  @len must be actual maximum length (even number) + 1.
 *
 *	LOCKING:
 *	caller.
 */
1029 1030
void ata_id_c_string(const u16 *id, unsigned char *s,
		     unsigned int ofs, unsigned int len)
1031 1032 1033 1034 1035
{
	unsigned char *p;

	WARN_ON(!(len & 1));

1036
	ata_id_string(id, s, ofs, len - 1);
1037 1038 1039 1040 1041 1042

	p = s + strnlen(s, len - 1);
	while (p > s && p[-1] == ' ')
		p--;
	*p = '\0';
}
E
Edward Falk 已提交
1043

T
Tejun Heo 已提交
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
static u64 ata_id_n_sectors(const u16 *id)
{
	if (ata_id_has_lba(id)) {
		if (ata_id_has_lba48(id))
			return ata_id_u64(id, 100);
		else
			return ata_id_u32(id, 60);
	} else {
		if (ata_id_current_chs_valid(id))
			return ata_id_u32(id, 57);
		else
			return id[1] * id[3] * id[6];
	}
}

A
Alan Cox 已提交
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
static u64 ata_tf_to_lba48(struct ata_taskfile *tf)
{
	u64 sectors = 0;

	sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40;
	sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32;
	sectors |= (tf->hob_lbal & 0xff) << 24;
	sectors |= (tf->lbah & 0xff) << 16;
	sectors |= (tf->lbam & 0xff) << 8;
	sectors |= (tf->lbal & 0xff);

	return ++sectors;
}

static u64 ata_tf_to_lba(struct ata_taskfile *tf)
{
	u64 sectors = 0;

	sectors |= (tf->device & 0x0f) << 24;
	sectors |= (tf->lbah & 0xff) << 16;
	sectors |= (tf->lbam & 0xff) << 8;
	sectors |= (tf->lbal & 0xff);

	return ++sectors;
}

/**
1086 1087 1088
 *	ata_read_native_max_address - Read native max address
 *	@dev: target device
 *	@max_sectors: out parameter for the result native max address
A
Alan Cox 已提交
1089
 *
1090 1091
 *	Perform an LBA48 or LBA28 native size query upon the device in
 *	question.
A
Alan Cox 已提交
1092
 *
1093 1094 1095
 *	RETURNS:
 *	0 on success, -EACCES if command is aborted by the drive.
 *	-EIO on other errors.
A
Alan Cox 已提交
1096
 */
1097
static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
A
Alan Cox 已提交
1098
{
1099
	unsigned int err_mask;
A
Alan Cox 已提交
1100
	struct ata_taskfile tf;
1101
	int lba48 = ata_id_has_lba48(dev->id);
A
Alan Cox 已提交
1102 1103 1104

	ata_tf_init(dev, &tf);

1105
	/* always clear all address registers */
A
Alan Cox 已提交
1106 1107
	tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;

1108 1109 1110 1111 1112
	if (lba48) {
		tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
		tf.flags |= ATA_TFLAG_LBA48;
	} else
		tf.command = ATA_CMD_READ_NATIVE_MAX;
A
Alan Cox 已提交
1113 1114

	tf.protocol |= ATA_PROT_NODATA;
1115 1116
	tf.device |= ATA_LBA;

1117
	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1118 1119 1120 1121 1122 1123 1124
	if (err_mask) {
		ata_dev_printk(dev, KERN_WARNING, "failed to read native "
			       "max address (err_mask=0x%x)\n", err_mask);
		if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
			return -EACCES;
		return -EIO;
	}
A
Alan Cox 已提交
1125

1126 1127 1128 1129
	if (lba48)
		*max_sectors = ata_tf_to_lba48(&tf);
	else
		*max_sectors = ata_tf_to_lba(&tf);
1130
	if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
1131
		(*max_sectors)--;
1132
	return 0;
A
Alan Cox 已提交
1133 1134 1135
}

/**
1136 1137
 *	ata_set_max_sectors - Set max sectors
 *	@dev: target device
R
Randy Dunlap 已提交
1138
 *	@new_sectors: new max sectors value to set for the device
A
Alan Cox 已提交
1139
 *
1140 1141 1142 1143 1144 1145
 *	Set max sectors of @dev to @new_sectors.
 *
 *	RETURNS:
 *	0 on success, -EACCES if command is aborted or denied (due to
 *	previous non-volatile SET_MAX) by the drive.  -EIO on other
 *	errors.
A
Alan Cox 已提交
1146
 */
T
Tejun Heo 已提交
1147
static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
A
Alan Cox 已提交
1148
{
1149
	unsigned int err_mask;
A
Alan Cox 已提交
1150
	struct ata_taskfile tf;
1151
	int lba48 = ata_id_has_lba48(dev->id);
A
Alan Cox 已提交
1152 1153 1154 1155 1156 1157

	new_sectors--;

	ata_tf_init(dev, &tf);

	tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1158 1159 1160 1161 1162 1163 1164 1165

	if (lba48) {
		tf.command = ATA_CMD_SET_MAX_EXT;
		tf.flags |= ATA_TFLAG_LBA48;

		tf.hob_lbal = (new_sectors >> 24) & 0xff;
		tf.hob_lbam = (new_sectors >> 32) & 0xff;
		tf.hob_lbah = (new_sectors >> 40) & 0xff;
T
Tejun Heo 已提交
1166
	} else {
1167 1168
		tf.command = ATA_CMD_SET_MAX;

T
Tejun Heo 已提交
1169 1170 1171
		tf.device |= (new_sectors >> 24) & 0xf;
	}

A
Alan Cox 已提交
1172
	tf.protocol |= ATA_PROT_NODATA;
1173
	tf.device |= ATA_LBA;
A
Alan Cox 已提交
1174 1175 1176 1177 1178

	tf.lbal = (new_sectors >> 0) & 0xff;
	tf.lbam = (new_sectors >> 8) & 0xff;
	tf.lbah = (new_sectors >> 16) & 0xff;

1179
	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
	if (err_mask) {
		ata_dev_printk(dev, KERN_WARNING, "failed to set "
			       "max address (err_mask=0x%x)\n", err_mask);
		if (err_mask == AC_ERR_DEV &&
		    (tf.feature & (ATA_ABORTED | ATA_IDNF)))
			return -EACCES;
		return -EIO;
	}

	return 0;
A
Alan Cox 已提交
1190 1191 1192 1193 1194 1195 1196 1197 1198
}

/**
 *	ata_hpa_resize		-	Resize a device with an HPA set
 *	@dev: Device to resize
 *
 *	Read the size of an LBA28 or LBA48 disk with HPA features and resize
 *	it if required to the full size of the media. The caller must check
 *	the drive has the HPA feature set enabled.
T
Tejun Heo 已提交
1199 1200 1201
 *
 *	RETURNS:
 *	0 on success, -errno on failure.
A
Alan Cox 已提交
1202
 */
T
Tejun Heo 已提交
1203
static int ata_hpa_resize(struct ata_device *dev)
A
Alan Cox 已提交
1204
{
T
Tejun Heo 已提交
1205 1206 1207 1208
	struct ata_eh_context *ehc = &dev->link->eh_context;
	int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
	u64 sectors = ata_id_n_sectors(dev->id);
	u64 native_sectors;
1209
	int rc;
J
Jeff Garzik 已提交
1210

T
Tejun Heo 已提交
1211 1212 1213 1214
	/* do we need to do it? */
	if (dev->class != ATA_DEV_ATA ||
	    !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
	    (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
1215
		return 0;
A
Alan Cox 已提交
1216

T
Tejun Heo 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
	/* read native max address */
	rc = ata_read_native_max_address(dev, &native_sectors);
	if (rc) {
		/* If HPA isn't going to be unlocked, skip HPA
		 * resizing from the next try.
		 */
		if (!ata_ignore_hpa) {
			ata_dev_printk(dev, KERN_WARNING, "HPA support seems "
				       "broken, will skip HPA handling\n");
			dev->horkage |= ATA_HORKAGE_BROKEN_HPA;

			/* we can continue if device aborted the command */
			if (rc == -EACCES)
				rc = 0;
A
Alan Cox 已提交
1231
		}
T
Tejun Heo 已提交
1232

T
Tejun Heo 已提交
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
		return rc;
	}

	/* nothing to do? */
	if (native_sectors <= sectors || !ata_ignore_hpa) {
		if (!print_info || native_sectors == sectors)
			return 0;

		if (native_sectors > sectors)
			ata_dev_printk(dev, KERN_INFO,
				"HPA detected: current %llu, native %llu\n",
				(unsigned long long)sectors,
				(unsigned long long)native_sectors);
		else if (native_sectors < sectors)
			ata_dev_printk(dev, KERN_WARNING,
				"native sectors (%llu) is smaller than "
				"sectors (%llu)\n",
				(unsigned long long)native_sectors,
				(unsigned long long)sectors);
		return 0;
	}

	/* let's unlock HPA */
	rc = ata_set_max_sectors(dev, native_sectors);
	if (rc == -EACCES) {
		/* if device aborted the command, skip HPA resizing */
		ata_dev_printk(dev, KERN_WARNING, "device aborted resize "
			       "(%llu -> %llu), skipping HPA handling\n",
			       (unsigned long long)sectors,
			       (unsigned long long)native_sectors);
		dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
		return 0;
	} else if (rc)
		return rc;

	/* re-read IDENTIFY data */
	rc = ata_dev_reread_id(dev, 0);
	if (rc) {
		ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY "
			       "data after HPA resizing\n");
		return rc;
	}

	if (print_info) {
		u64 new_sectors = ata_id_n_sectors(dev->id);
		ata_dev_printk(dev, KERN_INFO,
			"HPA unlocked: %llu -> %llu, native %llu\n",
			(unsigned long long)sectors,
			(unsigned long long)new_sectors,
			(unsigned long long)native_sectors);
	}

	return 0;
A
Alan Cox 已提交
1286 1287
}

1288 1289 1290
/**
 *	ata_id_to_dma_mode	-	Identify DMA mode from id block
 *	@dev: device to identify
R
Randy Dunlap 已提交
1291
 *	@unknown: mode to assume if we cannot tell
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
 *
 *	Set up the timing values for the device based upon the identify
 *	reported values for the DMA mode. This function is used by drivers
 *	which rely upon firmware configured modes, but wish to report the
 *	mode correctly when possible.
 *
 *	In addition we emit similarly formatted messages to the default
 *	ata_dev_set_mode handler, in order to provide consistency of
 *	presentation.
 */

void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown)
{
	unsigned int mask;
	u8 mode;

	/* Pack the DMA modes */
	mask = ((dev->id[63] >> 8) << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA;
	if (dev->id[53] & 0x04)
		mask |= ((dev->id[88] >> 8) << ATA_SHIFT_UDMA) & ATA_MASK_UDMA;

	/* Select the mode in use */
	mode = ata_xfer_mask2mode(mask);

	if (mode != 0) {
		ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
		       ata_mode_string(mask));
	} else {
		/* SWDMA perhaps ? */
		mode = unknown;
		ata_dev_printk(dev, KERN_INFO, "configured for DMA\n");
	}

	/* Configure the device reporting */
	dev->xfer_mode = mode;
	dev->xfer_shift = ata_xfer_mode2shift(mode);
}

E
Edward Falk 已提交
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
/**
 *	ata_noop_dev_select - Select device 0/1 on ATA bus
 *	@ap: ATA channel to manipulate
 *	@device: ATA device (numbered from zero) to select
 *
 *	This function performs no actual function.
 *
 *	May be used as the dev_select() entry in ata_port_operations.
 *
 *	LOCKING:
 *	caller.
 */
1342
void ata_noop_dev_select(struct ata_port *ap, unsigned int device)
L
Linus Torvalds 已提交
1343 1344 1345
{
}

E
Edward Falk 已提交
1346

L
Linus Torvalds 已提交
1347 1348 1349 1350 1351 1352 1353
/**
 *	ata_std_dev_select - Select device 0/1 on ATA bus
 *	@ap: ATA channel to manipulate
 *	@device: ATA device (numbered from zero) to select
 *
 *	Use the method defined in the ATA specification to
 *	make either device 0, or device 1, active on the
E
Edward Falk 已提交
1354 1355 1356
 *	ATA channel.  Works with both PIO and MMIO.
 *
 *	May be used as the dev_select() entry in ata_port_operations.
L
Linus Torvalds 已提交
1357 1358 1359 1360 1361
 *
 *	LOCKING:
 *	caller.
 */

1362
void ata_std_dev_select(struct ata_port *ap, unsigned int device)
L
Linus Torvalds 已提交
1363 1364 1365 1366 1367 1368 1369 1370
{
	u8 tmp;

	if (device == 0)
		tmp = ATA_DEVICE_OBS;
	else
		tmp = ATA_DEVICE_OBS | ATA_DEV1;

T
Tejun Heo 已提交
1371
	iowrite8(tmp, ap->ioaddr.device_addr);
L
Linus Torvalds 已提交
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
	ata_pause(ap);		/* needed; also flushes, for mmio */
}

/**
 *	ata_dev_select - Select device 0/1 on ATA bus
 *	@ap: ATA channel to manipulate
 *	@device: ATA device (numbered from zero) to select
 *	@wait: non-zero to wait for Status register BSY bit to clear
 *	@can_sleep: non-zero if context allows sleeping
 *
 *	Use the method defined in the ATA specification to
 *	make either device 0, or device 1, active on the
 *	ATA channel.
 *
 *	This is a high-level version of ata_std_dev_select(),
 *	which additionally provides the services of inserting
 *	the proper pauses and status polling, where needed.
 *
 *	LOCKING:
 *	caller.
 */

void ata_dev_select(struct ata_port *ap, unsigned int device,
			   unsigned int wait, unsigned int can_sleep)
{
T
Tejun Heo 已提交
1397
	if (ata_msg_probe(ap))
T
Tejun Heo 已提交
1398 1399
		ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, "
				"device %u, wait %u\n", device, wait);
L
Linus Torvalds 已提交
1400 1401 1402 1403 1404 1405 1406

	if (wait)
		ata_wait_idle(ap);

	ap->ops->dev_select(ap, device);

	if (wait) {
T
Tejun Heo 已提交
1407
		if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI)
L
Linus Torvalds 已提交
1408 1409 1410 1411 1412 1413 1414
			msleep(150);
		ata_wait_idle(ap);
	}
}

/**
 *	ata_dump_id - IDENTIFY DEVICE info debugging output
1415
 *	@id: IDENTIFY DEVICE page to dump
L
Linus Torvalds 已提交
1416
 *
1417 1418
 *	Dump selected 16-bit words from the given IDENTIFY DEVICE
 *	page.
L
Linus Torvalds 已提交
1419 1420 1421 1422 1423
 *
 *	LOCKING:
 *	caller.
 */

1424
static inline void ata_dump_id(const u16 *id)
L
Linus Torvalds 已提交
1425 1426 1427 1428 1429 1430
{
	DPRINTK("49==0x%04x  "
		"53==0x%04x  "
		"63==0x%04x  "
		"64==0x%04x  "
		"75==0x%04x  \n",
1431 1432 1433 1434 1435
		id[49],
		id[53],
		id[63],
		id[64],
		id[75]);
L
Linus Torvalds 已提交
1436 1437 1438 1439 1440
	DPRINTK("80==0x%04x  "
		"81==0x%04x  "
		"82==0x%04x  "
		"83==0x%04x  "
		"84==0x%04x  \n",
1441 1442 1443 1444 1445
		id[80],
		id[81],
		id[82],
		id[83],
		id[84]);
L
Linus Torvalds 已提交
1446 1447
	DPRINTK("88==0x%04x  "
		"93==0x%04x\n",
1448 1449
		id[88],
		id[93]);
L
Linus Torvalds 已提交
1450 1451
}

1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
/**
 *	ata_id_xfermask - Compute xfermask from the given IDENTIFY data
 *	@id: IDENTIFY data to compute xfer mask from
 *
 *	Compute the xfermask for this device. This is not as trivial
 *	as it seems if we must consider early devices correctly.
 *
 *	FIXME: pre IDE drive timing (do we care ?).
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	Computed xfermask
 */
static unsigned int ata_id_xfermask(const u16 *id)
{
	unsigned int pio_mask, mwdma_mask, udma_mask;

	/* Usual case. Word 53 indicates word 64 is valid */
	if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
		pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
		pio_mask <<= 3;
		pio_mask |= 0x7;
	} else {
		/* If word 64 isn't valid then Word 51 high byte holds
		 * the PIO timing number for the maximum. Turn it into
		 * a mask.
		 */
1481
		u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
1482
		if (mode < 5)	/* Valid PIO range */
1483
			pio_mask = (2 << mode) - 1;
1484 1485
		else
			pio_mask = 1;
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495

		/* But wait.. there's more. Design your standards by
		 * committee and you too can get a free iordy field to
		 * process. However its the speeds not the modes that
		 * are supported... Note drivers using the timing API
		 * will get this right anyway
		 */
	}

	mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
1496

1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
	if (ata_id_is_cfa(id)) {
		/*
		 *	Process compact flash extended modes
		 */
		int pio = id[163] & 0x7;
		int dma = (id[163] >> 3) & 7;

		if (pio)
			pio_mask |= (1 << 5);
		if (pio > 1)
			pio_mask |= (1 << 6);
		if (dma)
			mwdma_mask |= (1 << 3);
		if (dma > 1)
			mwdma_mask |= (1 << 4);
	}

1514 1515 1516
	udma_mask = 0;
	if (id[ATA_ID_FIELD_VALID] & (1 << 2))
		udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
1517 1518 1519 1520

	return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
}

T
Tejun Heo 已提交
1521 1522 1523
/**
 *	ata_port_queue_task - Queue port_task
 *	@ap: The ata_port to queue port_task for
1524
 *	@fn: workqueue function to be scheduled
1525
 *	@data: data for @fn to use
1526
 *	@delay: delay time for workqueue function
T
Tejun Heo 已提交
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
 *
 *	Schedule @fn(@data) for execution after @delay jiffies using
 *	port_task.  There is one port_task per port and it's the
 *	user(low level driver)'s responsibility to make sure that only
 *	one task is active at any given time.
 *
 *	libata core layer takes care of synchronization between
 *	port_task and EH.  ata_port_queue_task() may be ignored for EH
 *	synchronization.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
1540
void ata_port_queue_task(struct ata_port *ap, work_func_t fn, void *data,
T
Tejun Heo 已提交
1541 1542
			 unsigned long delay)
{
1543 1544
	PREPARE_DELAYED_WORK(&ap->port_task, fn);
	ap->port_task_data = data;
T
Tejun Heo 已提交
1545

1546 1547
	/* may fail if ata_port_flush_task() in progress */
	queue_delayed_work(ata_wq, &ap->port_task, delay);
T
Tejun Heo 已提交
1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
}

/**
 *	ata_port_flush_task - Flush port_task
 *	@ap: The ata_port to flush port_task for
 *
 *	After this function completes, port_task is guranteed not to
 *	be running or scheduled.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 */
void ata_port_flush_task(struct ata_port *ap)
{
	DPRINTK("ENTER\n");

1564
	cancel_rearming_delayed_work(&ap->port_task);
T
Tejun Heo 已提交
1565

1566 1567
	if (ata_msg_ctl(ap))
		ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __FUNCTION__);
T
Tejun Heo 已提交
1568 1569
}

1570
static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
1571
{
1572
	struct completion *waiting = qc->private_data;
1573 1574 1575 1576 1577

	complete(waiting);
}

/**
1578
 *	ata_exec_internal_sg - execute libata internal command
1579 1580
 *	@dev: Device to which the command is sent
 *	@tf: Taskfile registers for the command and the result
1581
 *	@cdb: CDB for packet command
1582
 *	@dma_dir: Data tranfer direction of the command
R
Randy Dunlap 已提交
1583
 *	@sgl: sg list for the data buffer of the command
1584
 *	@n_elem: Number of sg entries
1585
 *	@timeout: Timeout in msecs (0 for default)
1586 1587 1588 1589 1590 1591 1592 1593 1594
 *
 *	Executes libata internal command with timeout.  @tf contains
 *	command on entry and result on return.  Timeout and error
 *	conditions are reported via return value.  No recovery action
 *	is taken after a command times out.  It's caller's duty to
 *	clean up after timeout.
 *
 *	LOCKING:
 *	None.  Should be called with kernel context, might sleep.
1595 1596 1597
 *
 *	RETURNS:
 *	Zero on success, AC_ERR_* mask on failure
1598
 */
1599 1600
unsigned ata_exec_internal_sg(struct ata_device *dev,
			      struct ata_taskfile *tf, const u8 *cdb,
J
Jens Axboe 已提交
1601
			      int dma_dir, struct scatterlist *sgl,
1602
			      unsigned int n_elem, unsigned long timeout)
1603
{
T
Tejun Heo 已提交
1604 1605
	struct ata_link *link = dev->link;
	struct ata_port *ap = link->ap;
1606 1607
	u8 command = tf->command;
	struct ata_queued_cmd *qc;
1608
	unsigned int tag, preempted_tag;
1609
	u32 preempted_sactive, preempted_qc_active;
1610
	int preempted_nr_active_links;
1611
	DECLARE_COMPLETION_ONSTACK(wait);
1612
	unsigned long flags;
1613
	unsigned int err_mask;
1614
	int rc;
1615

1616
	spin_lock_irqsave(ap->lock, flags);
1617

1618
	/* no internal command while frozen */
1619
	if (ap->pflags & ATA_PFLAG_FROZEN) {
1620
		spin_unlock_irqrestore(ap->lock, flags);
1621 1622 1623
		return AC_ERR_SYSTEM;
	}

1624
	/* initialize internal qc */
1625

1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
	/* XXX: Tag 0 is used for drivers with legacy EH as some
	 * drivers choke if any other tag is given.  This breaks
	 * ata_tag_internal() test for those drivers.  Don't use new
	 * EH stuff without converting to it.
	 */
	if (ap->ops->error_handler)
		tag = ATA_TAG_INTERNAL;
	else
		tag = 0;

1636
	if (test_and_set_bit(tag, &ap->qc_allocated))
1637
		BUG();
1638
	qc = __ata_qc_from_tag(ap, tag);
1639 1640 1641 1642 1643 1644 1645

	qc->tag = tag;
	qc->scsicmd = NULL;
	qc->ap = ap;
	qc->dev = dev;
	ata_qc_reinit(qc);

T
Tejun Heo 已提交
1646 1647
	preempted_tag = link->active_tag;
	preempted_sactive = link->sactive;
1648
	preempted_qc_active = ap->qc_active;
1649
	preempted_nr_active_links = ap->nr_active_links;
T
Tejun Heo 已提交
1650 1651
	link->active_tag = ATA_TAG_POISON;
	link->sactive = 0;
1652
	ap->qc_active = 0;
1653
	ap->nr_active_links = 0;
1654 1655

	/* prepare & issue qc */
1656
	qc->tf = *tf;
1657 1658
	if (cdb)
		memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
1659
	qc->flags |= ATA_QCFLAG_RESULT_TF;
1660 1661
	qc->dma_dir = dma_dir;
	if (dma_dir != DMA_NONE) {
1662
		unsigned int i, buflen = 0;
J
Jens Axboe 已提交
1663
		struct scatterlist *sg;
1664

J
Jens Axboe 已提交
1665 1666
		for_each_sg(sgl, sg, n_elem, i)
			buflen += sg->length;
1667

J
Jens Axboe 已提交
1668
		ata_sg_init(qc, sgl, n_elem);
1669
		qc->nbytes = buflen;
1670 1671
	}

1672
	qc->private_data = &wait;
1673 1674
	qc->complete_fn = ata_qc_complete_internal;

1675
	ata_qc_issue(qc);
1676

1677
	spin_unlock_irqrestore(ap->lock, flags);
1678

1679 1680 1681 1682
	if (!timeout)
		timeout = ata_probe_timeout * 1000 / HZ;

	rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
1683 1684

	ata_port_flush_task(ap);
1685

1686
	if (!rc) {
1687
		spin_lock_irqsave(ap->lock, flags);
1688 1689 1690

		/* We're racing with irq here.  If we lose, the
		 * following test prevents us from completing the qc
1691 1692
		 * twice.  If we win, the port is frozen and will be
		 * cleaned up by ->post_internal_cmd().
1693
		 */
1694
		if (qc->flags & ATA_QCFLAG_ACTIVE) {
1695 1696 1697 1698 1699 1700
			qc->err_mask |= AC_ERR_TIMEOUT;

			if (ap->ops->error_handler)
				ata_port_freeze(ap);
			else
				ata_qc_complete(qc);
1701

1702 1703
			if (ata_msg_warn(ap))
				ata_dev_printk(dev, KERN_WARNING,
T
Tejun Heo 已提交
1704
					"qc timeout (cmd 0x%x)\n", command);
1705 1706
		}

1707
		spin_unlock_irqrestore(ap->lock, flags);
1708 1709
	}

1710 1711 1712 1713
	/* do post_internal_cmd */
	if (ap->ops->post_internal_cmd)
		ap->ops->post_internal_cmd(qc);

1714 1715 1716 1717 1718 1719 1720 1721 1722 1723
	/* perform minimal error analysis */
	if (qc->flags & ATA_QCFLAG_FAILED) {
		if (qc->result_tf.command & (ATA_ERR | ATA_DF))
			qc->err_mask |= AC_ERR_DEV;

		if (!qc->err_mask)
			qc->err_mask |= AC_ERR_OTHER;

		if (qc->err_mask & ~AC_ERR_OTHER)
			qc->err_mask &= ~AC_ERR_OTHER;
1724 1725
	}

1726
	/* finish up */
1727
	spin_lock_irqsave(ap->lock, flags);
1728

1729
	*tf = qc->result_tf;
1730 1731 1732
	err_mask = qc->err_mask;

	ata_qc_free(qc);
T
Tejun Heo 已提交
1733 1734
	link->active_tag = preempted_tag;
	link->sactive = preempted_sactive;
1735
	ap->qc_active = preempted_qc_active;
1736
	ap->nr_active_links = preempted_nr_active_links;
1737

1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
	/* XXX - Some LLDDs (sata_mv) disable port on command failure.
	 * Until those drivers are fixed, we detect the condition
	 * here, fail the command with AC_ERR_SYSTEM and reenable the
	 * port.
	 *
	 * Note that this doesn't change any behavior as internal
	 * command failure results in disabling the device in the
	 * higher layer for LLDDs without new reset/EH callbacks.
	 *
	 * Kill the following code as soon as those drivers are fixed.
	 */
1749
	if (ap->flags & ATA_FLAG_DISABLED) {
1750 1751 1752 1753
		err_mask |= AC_ERR_SYSTEM;
		ata_port_probe(ap);
	}

1754
	spin_unlock_irqrestore(ap->lock, flags);
1755

1756
	return err_mask;
1757 1758
}

1759
/**
1760
 *	ata_exec_internal - execute libata internal command
1761 1762 1763 1764 1765 1766
 *	@dev: Device to which the command is sent
 *	@tf: Taskfile registers for the command and the result
 *	@cdb: CDB for packet command
 *	@dma_dir: Data tranfer direction of the command
 *	@buf: Data buffer of the command
 *	@buflen: Length of data buffer
1767
 *	@timeout: Timeout in msecs (0 for default)
1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
 *
 *	Wrapper around ata_exec_internal_sg() which takes simple
 *	buffer instead of sg list.
 *
 *	LOCKING:
 *	None.  Should be called with kernel context, might sleep.
 *
 *	RETURNS:
 *	Zero on success, AC_ERR_* mask on failure
 */
unsigned ata_exec_internal(struct ata_device *dev,
			   struct ata_taskfile *tf, const u8 *cdb,
1780 1781
			   int dma_dir, void *buf, unsigned int buflen,
			   unsigned long timeout)
1782
{
1783 1784
	struct scatterlist *psg = NULL, sg;
	unsigned int n_elem = 0;
1785

1786 1787 1788 1789 1790 1791
	if (dma_dir != DMA_NONE) {
		WARN_ON(!buf);
		sg_init_one(&sg, buf, buflen);
		psg = &sg;
		n_elem++;
	}
1792

1793 1794
	return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
				    timeout);
1795 1796
}

1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
/**
 *	ata_do_simple_cmd - execute simple internal command
 *	@dev: Device to which the command is sent
 *	@cmd: Opcode to execute
 *
 *	Execute a 'simple' command, that only consists of the opcode
 *	'cmd' itself, without filling any other registers
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 *
 *	RETURNS:
 *	Zero on success, AC_ERR_* mask on failure
1810
 */
1811
unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
1812 1813 1814 1815 1816 1817 1818 1819 1820
{
	struct ata_taskfile tf;

	ata_tf_init(dev, &tf);

	tf.command = cmd;
	tf.flags |= ATA_TFLAG_DEVICE;
	tf.protocol = ATA_PROT_NODATA;

1821
	return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1822 1823
}

1824 1825 1826 1827 1828 1829 1830
/**
 *	ata_pio_need_iordy	-	check if iordy needed
 *	@adev: ATA device
 *
 *	Check if the current speed of the device requires IORDY. Used
 *	by various controllers for chip configuration.
 */
J
Jeff Garzik 已提交
1831

1832 1833
unsigned int ata_pio_need_iordy(const struct ata_device *adev)
{
A
Alan Cox 已提交
1834 1835
	/* Controller doesn't support  IORDY. Probably a pointless check
	   as the caller should know this */
T
Tejun Heo 已提交
1836
	if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
1837
		return 0;
A
Alan Cox 已提交
1838 1839 1840 1841 1842
	/* PIO3 and higher it is mandatory */
	if (adev->pio_mode > XFER_PIO_2)
		return 1;
	/* We turn it on when possible */
	if (ata_id_has_iordy(adev->id))
1843
		return 1;
A
Alan Cox 已提交
1844 1845
	return 0;
}
1846

A
Alan Cox 已提交
1847 1848 1849 1850 1851 1852 1853
/**
 *	ata_pio_mask_no_iordy	-	Return the non IORDY mask
 *	@adev: ATA device
 *
 *	Compute the highest mode possible if we are not using iordy. Return
 *	-1 if no iordy mode is available.
 */
J
Jeff Garzik 已提交
1854

A
Alan Cox 已提交
1855 1856
static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
{
1857 1858
	/* If we have no drive specific rule, then PIO 2 is non IORDY */
	if (adev->id[ATA_ID_FIELD_VALID] & 2) {	/* EIDE */
A
Alan Cox 已提交
1859
		u16 pio = adev->id[ATA_ID_EIDE_PIO];
1860 1861 1862 1863
		/* Is the speed faster than the drive allows non IORDY ? */
		if (pio) {
			/* This is cycle times not frequency - watch the logic! */
			if (pio > 240)	/* PIO2 is 240nS per cycle */
A
Alan Cox 已提交
1864 1865
				return 3 << ATA_SHIFT_PIO;
			return 7 << ATA_SHIFT_PIO;
1866 1867
		}
	}
A
Alan Cox 已提交
1868
	return 3 << ATA_SHIFT_PIO;
1869 1870
}

L
Linus Torvalds 已提交
1871
/**
1872 1873 1874
 *	ata_dev_read_id - Read ID data from the specified device
 *	@dev: target device
 *	@p_class: pointer to class of the target device (may be changed)
1875
 *	@flags: ATA_READID_* flags
1876
 *	@id: buffer to read IDENTIFY data into
L
Linus Torvalds 已提交
1877
 *
1878 1879
 *	Read ID data from the specified device.  ATA_CMD_ID_ATA is
 *	performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
T
Tejun Heo 已提交
1880 1881
 *	devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
 *	for pre-ATA4 drives.
L
Linus Torvalds 已提交
1882
 *
1883
 *	FIXME: ATA_CMD_ID_ATA is optional for early drives and right
1884
 *	now we abort if we hit that case.
1885
 *
L
Linus Torvalds 已提交
1886
 *	LOCKING:
1887 1888 1889 1890
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
L
Linus Torvalds 已提交
1891
 */
1892
int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
1893
		    unsigned int flags, u16 *id)
L
Linus Torvalds 已提交
1894
{
T
Tejun Heo 已提交
1895
	struct ata_port *ap = dev->link->ap;
1896
	unsigned int class = *p_class;
1897
	struct ata_taskfile tf;
1898 1899
	unsigned int err_mask = 0;
	const char *reason;
1900
	int may_fallback = 1, tried_spinup = 0;
1901
	int rc;
L
Linus Torvalds 已提交
1902

1903
	if (ata_msg_ctl(ap))
T
Tejun Heo 已提交
1904
		ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__);
L
Linus Torvalds 已提交
1905

1906 1907
	ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
 retry:
T
Tejun Heo 已提交
1908
	ata_tf_init(dev, &tf);
1909

1910 1911
	switch (class) {
	case ATA_DEV_ATA:
1912
		tf.command = ATA_CMD_ID_ATA;
1913 1914
		break;
	case ATA_DEV_ATAPI:
1915
		tf.command = ATA_CMD_ID_ATAPI;
1916 1917 1918 1919 1920
		break;
	default:
		rc = -ENODEV;
		reason = "unsupported class";
		goto err_out;
L
Linus Torvalds 已提交
1921 1922
	}

1923
	tf.protocol = ATA_PROT_PIO;
T
Tejun Heo 已提交
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933

	/* Some devices choke if TF registers contain garbage.  Make
	 * sure those are properly initialized.
	 */
	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;

	/* Device presence detection is unreliable on some
	 * controllers.  Always poll IDENTIFY if available.
	 */
	tf.flags |= ATA_TFLAG_POLLING;
L
Linus Torvalds 已提交
1934

T
Tejun Heo 已提交
1935
	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
1936
				     id, sizeof(id[0]) * ATA_ID_WORDS, 0);
1937
	if (err_mask) {
1938
		if (err_mask & AC_ERR_NODEV_HINT) {
1939
			DPRINTK("ata%u.%d: NODEV after polling detection\n",
T
Tejun Heo 已提交
1940
				ap->print_id, dev->devno);
1941 1942 1943
			return -ENOENT;
		}

1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
		/* Device or controller might have reported the wrong
		 * device class.  Give a shot at the other IDENTIFY if
		 * the current one is aborted by the device.
		 */
		if (may_fallback &&
		    (err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
			may_fallback = 0;

			if (class == ATA_DEV_ATA)
				class = ATA_DEV_ATAPI;
			else
				class = ATA_DEV_ATA;
			goto retry;
		}

1959 1960
		rc = -EIO;
		reason = "I/O error";
L
Linus Torvalds 已提交
1961 1962 1963
		goto err_out;
	}

1964 1965 1966 1967 1968
	/* Falling back doesn't make sense if ID data was read
	 * successfully at least once.
	 */
	may_fallback = 0;

1969
	swap_buf_le16(id, ATA_ID_WORDS);
L
Linus Torvalds 已提交
1970

1971
	/* sanity check */
1972
	rc = -EINVAL;
A
Alan Cox 已提交
1973
	reason = "device reports invalid type";
1974 1975 1976 1977 1978 1979 1980

	if (class == ATA_DEV_ATA) {
		if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
			goto err_out;
	} else {
		if (ata_id_is_ata(id))
			goto err_out;
1981 1982
	}

1983 1984 1985 1986 1987 1988 1989
	if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) {
		tried_spinup = 1;
		/*
		 * Drive powered-up in standby mode, and requires a specific
		 * SET_FEATURES spin-up subcommand before it will accept
		 * anything other than the original IDENTIFY command.
		 */
1990
		err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0);
1991
		if (err_mask && id[2] != 0x738c) {
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
			rc = -EIO;
			reason = "SPINUP failed";
			goto err_out;
		}
		/*
		 * If the drive initially returned incomplete IDENTIFY info,
		 * we now must reissue the IDENTIFY command.
		 */
		if (id[2] == 0x37c8)
			goto retry;
	}

2004
	if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) {
2005 2006 2007
		/*
		 * The exact sequence expected by certain pre-ATA4 drives is:
		 * SRST RESET
2008 2009
		 * IDENTIFY (optional in early ATA)
		 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
2010 2011
		 * anything else..
		 * Some drives were very specific about that exact sequence.
2012 2013 2014
		 *
		 * Note that ATA4 says lba is mandatory so the second check
		 * shoud never trigger.
2015 2016
		 */
		if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
T
Tejun Heo 已提交
2017
			err_mask = ata_dev_init_params(dev, id[3], id[6]);
2018 2019 2020 2021 2022 2023 2024 2025 2026
			if (err_mask) {
				rc = -EIO;
				reason = "INIT_DEV_PARAMS failed";
				goto err_out;
			}

			/* current CHS translation info (id[53-58]) might be
			 * changed. reread the identify device info.
			 */
2027
			flags &= ~ATA_READID_POSTRESET;
2028 2029 2030 2031 2032
			goto retry;
		}
	}

	*p_class = class;
2033

2034 2035 2036
	return 0;

 err_out:
T
Tejun Heo 已提交
2037
	if (ata_msg_warn(ap))
2038
		ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY "
T
Tejun Heo 已提交
2039
			       "(%s, err_mask=0x%x)\n", reason, err_mask);
2040 2041 2042
	return rc;
}

T
Tejun Heo 已提交
2043
static inline u8 ata_dev_knobble(struct ata_device *dev)
2044
{
T
Tejun Heo 已提交
2045 2046
	struct ata_port *ap = dev->link->ap;
	return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
2047 2048
}

2049 2050 2051
static void ata_dev_config_ncq(struct ata_device *dev,
			       char *desc, size_t desc_sz)
{
T
Tejun Heo 已提交
2052
	struct ata_port *ap = dev->link->ap;
2053 2054 2055 2056 2057 2058
	int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);

	if (!ata_id_has_ncq(dev->id)) {
		desc[0] = '\0';
		return;
	}
T
Tejun Heo 已提交
2059
	if (dev->horkage & ATA_HORKAGE_NONCQ) {
2060 2061 2062
		snprintf(desc, desc_sz, "NCQ (not used)");
		return;
	}
2063
	if (ap->flags & ATA_FLAG_NCQ) {
J
Jeff Garzik 已提交
2064
		hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1);
2065 2066 2067 2068 2069 2070 2071 2072 2073
		dev->flags |= ATA_DFLAG_NCQ;
	}

	if (hdepth >= ddepth)
		snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth);
	else
		snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth);
}

2074
/**
2075 2076 2077 2078 2079
 *	ata_dev_configure - Configure the specified ATA/ATAPI device
 *	@dev: Target device to configure
 *
 *	Configure @dev according to @dev->id.  Generic and low-level
 *	driver specific fixups are also applied.
2080 2081
 *
 *	LOCKING:
2082 2083 2084 2085
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno otherwise
2086
 */
2087
int ata_dev_configure(struct ata_device *dev)
2088
{
T
Tejun Heo 已提交
2089 2090
	struct ata_port *ap = dev->link->ap;
	struct ata_eh_context *ehc = &dev->link->eh_context;
T
Tejun Heo 已提交
2091
	int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
2092
	const u16 *id = dev->id;
2093
	unsigned int xfer_mask;
2094
	char revbuf[7];		/* XYZ-99\0 */
2095 2096
	char fwrevbuf[ATA_ID_FW_REV_LEN+1];
	char modelbuf[ATA_ID_PROD_LEN+1];
2097
	int rc;
2098

2099
	if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
T
Tejun Heo 已提交
2100 2101
		ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n",
			       __FUNCTION__);
2102
		return 0;
2103 2104
	}

2105
	if (ata_msg_probe(ap))
T
Tejun Heo 已提交
2106
		ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__);
L
Linus Torvalds 已提交
2107

T
Tejun Heo 已提交
2108 2109 2110
	/* set horkage */
	dev->horkage |= ata_dev_blacklisted(dev);

T
Tejun Heo 已提交
2111 2112 2113 2114
	/* let ACPI work its magic */
	rc = ata_acpi_on_devcfg(dev);
	if (rc)
		return rc;
2115

T
Tejun Heo 已提交
2116 2117 2118 2119 2120
	/* massage HPA, do it early as it might change IDENTIFY data */
	rc = ata_hpa_resize(dev);
	if (rc)
		return rc;

2121
	/* print device capabilities */
2122
	if (ata_msg_probe(ap))
T
Tejun Heo 已提交
2123 2124 2125
		ata_dev_printk(dev, KERN_DEBUG,
			       "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
			       "85:%04x 86:%04x 87:%04x 88:%04x\n",
2126
			       __FUNCTION__,
2127 2128
			       id[49], id[82], id[83], id[84],
			       id[85], id[86], id[87], id[88]);
2129

2130
	/* initialize to-be-configured parameters */
2131
	dev->flags &= ~ATA_DFLAG_CFG_MASK;
2132 2133 2134 2135 2136 2137 2138
	dev->max_sectors = 0;
	dev->cdb_len = 0;
	dev->n_sectors = 0;
	dev->cylinders = 0;
	dev->heads = 0;
	dev->sectors = 0;

L
Linus Torvalds 已提交
2139 2140 2141 2142
	/*
	 * common ATA, ATAPI feature tests
	 */

2143
	/* find max transfer mode; for printk only */
2144
	xfer_mask = ata_id_xfermask(id);
L
Linus Torvalds 已提交
2145

2146 2147
	if (ata_msg_probe(ap))
		ata_dump_id(id);
L
Linus Torvalds 已提交
2148

2149 2150 2151 2152 2153 2154 2155
	/* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
	ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
			sizeof(fwrevbuf));

	ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
			sizeof(modelbuf));

L
Linus Torvalds 已提交
2156 2157
	/* ATA-specific feature tests */
	if (dev->class == ATA_DEV_ATA) {
2158 2159
		if (ata_id_is_cfa(id)) {
			if (id[162] & 1) /* CPRM may make this media unusable */
T
Tejun Heo 已提交
2160 2161 2162
				ata_dev_printk(dev, KERN_WARNING,
					       "supports DRM functions and may "
					       "not be fully accessable.\n");
2163
			snprintf(revbuf, 7, "CFA");
2164 2165
		} else
			snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
2166

2167
		dev->n_sectors = ata_id_n_sectors(id);
2168

2169 2170 2171
		if (dev->id[59] & 0x100)
			dev->multi_count = dev->id[59] & 0xff;

2172
		if (ata_id_has_lba(id)) {
2173
			const char *lba_desc;
2174
			char ncq_desc[20];
2175

2176 2177
			lba_desc = "LBA";
			dev->flags |= ATA_DFLAG_LBA;
2178
			if (ata_id_has_lba48(id)) {
2179
				dev->flags |= ATA_DFLAG_LBA48;
2180
				lba_desc = "LBA48";
2181 2182 2183 2184

				if (dev->n_sectors >= (1UL << 28) &&
				    ata_id_has_flush_ext(id))
					dev->flags |= ATA_DFLAG_FLUSH_EXT;
2185
			}
2186

2187 2188 2189
			/* config NCQ */
			ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));

2190
			/* print device info to dmesg */
2191 2192 2193 2194 2195 2196 2197
			if (ata_msg_drv(ap) && print_info) {
				ata_dev_printk(dev, KERN_INFO,
					"%s: %s, %s, max %s\n",
					revbuf, modelbuf, fwrevbuf,
					ata_mode_string(xfer_mask));
				ata_dev_printk(dev, KERN_INFO,
					"%Lu sectors, multi %u: %s %s\n",
2198
					(unsigned long long)dev->n_sectors,
2199 2200
					dev->multi_count, lba_desc, ncq_desc);
			}
2201
		} else {
2202 2203 2204
			/* CHS */

			/* Default translation */
2205 2206 2207
			dev->cylinders	= id[1];
			dev->heads	= id[3];
			dev->sectors	= id[6];
2208

2209
			if (ata_id_current_chs_valid(id)) {
2210
				/* Current CHS translation is valid. */
2211 2212 2213
				dev->cylinders = id[54];
				dev->heads     = id[55];
				dev->sectors   = id[56];
2214 2215 2216
			}

			/* print device info to dmesg */
2217
			if (ata_msg_drv(ap) && print_info) {
T
Tejun Heo 已提交
2218
				ata_dev_printk(dev, KERN_INFO,
2219 2220 2221
					"%s: %s, %s, max %s\n",
					revbuf,	modelbuf, fwrevbuf,
					ata_mode_string(xfer_mask));
J
Jeff Garzik 已提交
2222
				ata_dev_printk(dev, KERN_INFO,
2223 2224 2225 2226 2227
					"%Lu sectors, multi %u, CHS %u/%u/%u\n",
					(unsigned long long)dev->n_sectors,
					dev->multi_count, dev->cylinders,
					dev->heads, dev->sectors);
			}
2228 2229
		}

2230
		dev->cdb_len = 16;
L
Linus Torvalds 已提交
2231 2232 2233
	}

	/* ATAPI-specific feature tests */
J
Jeff Garzik 已提交
2234
	else if (dev->class == ATA_DEV_ATAPI) {
T
Tejun Heo 已提交
2235 2236
		const char *cdb_intr_string = "";
		const char *atapi_an_string = "";
2237
		u32 sntf;
2238

2239
		rc = atapi_cdb_len(id);
L
Linus Torvalds 已提交
2240
		if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
2241
			if (ata_msg_warn(ap))
T
Tejun Heo 已提交
2242 2243
				ata_dev_printk(dev, KERN_WARNING,
					       "unsupported CDB len\n");
2244
			rc = -EINVAL;
L
Linus Torvalds 已提交
2245 2246
			goto err_out_nosup;
		}
2247
		dev->cdb_len = (unsigned int) rc;
L
Linus Torvalds 已提交
2248

2249 2250 2251 2252
		/* Enable ATAPI AN if both the host and device have
		 * the support.  If PMP is attached, SNTF is required
		 * to enable ATAPI AN to discern between PHY status
		 * changed notifications and ATAPI ANs.
2253
		 */
2254 2255 2256
		if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
		    (!ap->nr_pmp_links ||
		     sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
T
Tejun Heo 已提交
2257 2258
			unsigned int err_mask;

2259
			/* issue SET feature command to turn this on */
2260 2261
			err_mask = ata_dev_set_feature(dev,
					SETFEATURES_SATA_ENABLE, SATA_AN);
T
Tejun Heo 已提交
2262
			if (err_mask)
2263
				ata_dev_printk(dev, KERN_ERR,
T
Tejun Heo 已提交
2264 2265 2266
					"failed to enable ATAPI AN "
					"(err_mask=0x%x)\n", err_mask);
			else {
2267
				dev->flags |= ATA_DFLAG_AN;
T
Tejun Heo 已提交
2268 2269
				atapi_an_string = ", ATAPI AN";
			}
2270 2271
		}

2272
		if (ata_id_cdb_intr(dev->id)) {
2273
			dev->flags |= ATA_DFLAG_CDB_INTR;
2274 2275
			cdb_intr_string = ", CDB intr";
		}
2276

L
Linus Torvalds 已提交
2277
		/* print device info to dmesg */
2278
		if (ata_msg_drv(ap) && print_info)
2279
			ata_dev_printk(dev, KERN_INFO,
T
Tejun Heo 已提交
2280
				       "ATAPI: %s, %s, max %s%s%s\n",
2281
				       modelbuf, fwrevbuf,
T
Tejun Heo 已提交
2282
				       ata_mode_string(xfer_mask),
T
Tejun Heo 已提交
2283
				       cdb_intr_string, atapi_an_string);
L
Linus Torvalds 已提交
2284 2285
	}

2286 2287 2288 2289 2290
	/* determine max_sectors */
	dev->max_sectors = ATA_MAX_SECTORS;
	if (dev->flags & ATA_DFLAG_LBA48)
		dev->max_sectors = ATA_MAX_SECTORS_LBA48;

2291 2292 2293 2294 2295 2296 2297
	if (!(dev->horkage & ATA_HORKAGE_IPM)) {
		if (ata_id_has_hipm(dev->id))
			dev->flags |= ATA_DFLAG_HIPM;
		if (ata_id_has_dipm(dev->id))
			dev->flags |= ATA_DFLAG_DIPM;
	}

2298 2299 2300 2301
	if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
		/* Let the user know. We don't want to disallow opens for
		   rescue purposes, or in case the vendor is just a blithering
		   idiot */
2302
		if (print_info) {
2303 2304 2305 2306 2307 2308 2309
			ata_dev_printk(dev, KERN_WARNING,
"Drive reports diagnostics failure. This may indicate a drive\n");
			ata_dev_printk(dev, KERN_WARNING,
"fault or invalid emulation. Contact drive vendor for information.\n");
		}
	}

2310
	/* limit bridge transfers to udma5, 200 sectors */
T
Tejun Heo 已提交
2311
	if (ata_dev_knobble(dev)) {
2312
		if (ata_msg_drv(ap) && print_info)
2313 2314
			ata_dev_printk(dev, KERN_INFO,
				       "applying bridge limits\n");
2315
		dev->udma_mask &= ATA_UDMA5;
2316 2317 2318
		dev->max_sectors = ATA_MAX_SECTORS;
	}

2319
	if ((dev->class == ATA_DEV_ATAPI) &&
2320
	    (atapi_command_packet_set(id) == TYPE_TAPE)) {
2321
		dev->max_sectors = ATA_MAX_SECTORS_TAPE;
2322 2323
		dev->horkage |= ATA_HORKAGE_STUCK_ERR;
	}
2324

T
Tejun Heo 已提交
2325
	if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
2326 2327
		dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
					 dev->max_sectors);
2328

2329 2330 2331 2332 2333 2334 2335
	if (ata_dev_blacklisted(dev) & ATA_HORKAGE_IPM) {
		dev->horkage |= ATA_HORKAGE_IPM;

		/* reset link pm_policy for this port to no pm */
		ap->pm_policy = MAX_PERFORMANCE;
	}

2336
	if (ap->ops->dev_config)
2337
		ap->ops->dev_config(dev);
2338

2339 2340 2341
	if (ata_msg_probe(ap))
		ata_dev_printk(dev, KERN_DEBUG, "%s: EXIT, drv_stat = 0x%x\n",
			__FUNCTION__, ata_chk_status(ap));
2342
	return 0;
L
Linus Torvalds 已提交
2343 2344

err_out_nosup:
2345
	if (ata_msg_probe(ap))
T
Tejun Heo 已提交
2346 2347
		ata_dev_printk(dev, KERN_DEBUG,
			       "%s: EXIT, err\n", __FUNCTION__);
2348
	return rc;
L
Linus Torvalds 已提交
2349 2350
}

A
Alan Cox 已提交
2351
/**
2352
 *	ata_cable_40wire	-	return 40 wire cable type
A
Alan Cox 已提交
2353 2354
 *	@ap: port
 *
2355
 *	Helper method for drivers which want to hardwire 40 wire cable
A
Alan Cox 已提交
2356 2357 2358 2359 2360 2361 2362 2363 2364
 *	detection.
 */

int ata_cable_40wire(struct ata_port *ap)
{
	return ATA_CBL_PATA40;
}

/**
2365
 *	ata_cable_80wire	-	return 80 wire cable type
A
Alan Cox 已提交
2366 2367
 *	@ap: port
 *
2368
 *	Helper method for drivers which want to hardwire 80 wire cable
A
Alan Cox 已提交
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400
 *	detection.
 */

int ata_cable_80wire(struct ata_port *ap)
{
	return ATA_CBL_PATA80;
}

/**
 *	ata_cable_unknown	-	return unknown PATA cable.
 *	@ap: port
 *
 *	Helper method for drivers which have no PATA cable detection.
 */

int ata_cable_unknown(struct ata_port *ap)
{
	return ATA_CBL_PATA_UNK;
}

/**
 *	ata_cable_sata	-	return SATA cable type
 *	@ap: port
 *
 *	Helper method for drivers which have SATA cables
 */

int ata_cable_sata(struct ata_port *ap)
{
	return ATA_CBL_SATA;
}

L
Linus Torvalds 已提交
2401 2402 2403 2404
/**
 *	ata_bus_probe - Reset and probe ATA bus
 *	@ap: Bus to probe
 *
J
Jeff Garzik 已提交
2405 2406 2407 2408
 *	Master ATA bus probing function.  Initiates a hardware-dependent
 *	bus reset, then attempts to identify any devices found on
 *	the bus.
 *
L
Linus Torvalds 已提交
2409
 *	LOCKING:
J
Jeff Garzik 已提交
2410
 *	PCI/etc. bus probe sem.
L
Linus Torvalds 已提交
2411 2412
 *
 *	RETURNS:
2413
 *	Zero on success, negative errno otherwise.
L
Linus Torvalds 已提交
2414 2415
 */

2416
int ata_bus_probe(struct ata_port *ap)
L
Linus Torvalds 已提交
2417
{
2418
	unsigned int classes[ATA_MAX_DEVICES];
2419
	int tries[ATA_MAX_DEVICES];
2420
	int rc;
2421
	struct ata_device *dev;
L
Linus Torvalds 已提交
2422

2423
	ata_port_probe(ap);
2424

2425 2426
	ata_link_for_each_dev(dev, &ap->link)
		tries[dev->devno] = ATA_PROBE_MAX_TRIES;
2427 2428

 retry:
T
Tejun Heo 已提交
2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
	ata_link_for_each_dev(dev, &ap->link) {
		/* If we issue an SRST then an ATA drive (not ATAPI)
		 * may change configuration and be in PIO0 timing. If
		 * we do a hard reset (or are coming from power on)
		 * this is true for ATA or ATAPI. Until we've set a
		 * suitable controller mode we should not touch the
		 * bus as we may be talking too fast.
		 */
		dev->pio_mode = XFER_PIO_0;

		/* If the controller has a pio mode setup function
		 * then use it to set the chipset to rights. Don't
		 * touch the DMA setup as that will be dealt with when
		 * configuring devices.
		 */
		if (ap->ops->set_piomode)
			ap->ops->set_piomode(ap, dev);
	}

2448
	/* reset and determine device classes */
2449
	ap->ops->phy_reset(ap);
2450

2451
	ata_link_for_each_dev(dev, &ap->link) {
2452 2453 2454 2455 2456
		if (!(ap->flags & ATA_FLAG_DISABLED) &&
		    dev->class != ATA_DEV_UNKNOWN)
			classes[dev->devno] = dev->class;
		else
			classes[dev->devno] = ATA_DEV_NONE;
2457

2458
		dev->class = ATA_DEV_UNKNOWN;
2459
	}
L
Linus Torvalds 已提交
2460

2461
	ata_port_probe(ap);
2462

2463 2464 2465 2466
	/* read IDENTIFY page and configure devices. We have to do the identify
	   specific sequence bass-ackwards so that PDIAG- is released by
	   the slave device */

2467 2468 2469
	ata_link_for_each_dev(dev, &ap->link) {
		if (tries[dev->devno])
			dev->class = classes[dev->devno];
2470

2471
		if (!ata_dev_enabled(dev))
2472 2473
			continue;

2474 2475
		rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET,
				     dev->id);
2476 2477
		if (rc)
			goto fail;
2478 2479
	}

A
Alan Cox 已提交
2480 2481 2482 2483
	/* Now ask for the cable type as PDIAG- should have been released */
	if (ap->ops->cable_detect)
		ap->cbl = ap->ops->cable_detect(ap);

A
Alan Cox 已提交
2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
	/* We may have SATA bridge glue hiding here irrespective of the
	   reported cable types and sensed types */
	ata_link_for_each_dev(dev, &ap->link) {
		if (!ata_dev_enabled(dev))
			continue;
		/* SATA drives indicate we have a bridge. We don't know which
		   end of the link the bridge is which is a problem */
		if (ata_id_is_sata(dev->id))
			ap->cbl = ATA_CBL_SATA;
	}

2495 2496 2497
	/* After the identify sequence we can now set up the devices. We do
	   this in the normal order so that the user doesn't get confused */

2498
	ata_link_for_each_dev(dev, &ap->link) {
2499 2500
		if (!ata_dev_enabled(dev))
			continue;
2501

T
Tejun Heo 已提交
2502
		ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
2503
		rc = ata_dev_configure(dev);
T
Tejun Heo 已提交
2504
		ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
2505 2506
		if (rc)
			goto fail;
L
Linus Torvalds 已提交
2507 2508
	}

2509
	/* configure transfer mode */
2510
	rc = ata_set_mode(&ap->link, &dev);
2511
	if (rc)
2512
		goto fail;
L
Linus Torvalds 已提交
2513

2514 2515
	ata_link_for_each_dev(dev, &ap->link)
		if (ata_dev_enabled(dev))
2516
			return 0;
L
Linus Torvalds 已提交
2517

2518 2519
	/* no device present, disable port */
	ata_port_disable(ap);
2520
	return -ENODEV;
2521 2522

 fail:
2523 2524
	tries[dev->devno]--;

2525 2526
	switch (rc) {
	case -EINVAL:
2527
		/* eeek, something went very wrong, give up */
2528 2529
		tries[dev->devno] = 0;
		break;
2530 2531 2532 2533

	case -ENODEV:
		/* give it just one more chance */
		tries[dev->devno] = min(tries[dev->devno], 1);
2534
	case -EIO:
2535 2536 2537 2538
		if (tries[dev->devno] == 1) {
			/* This is the last chance, better to slow
			 * down than lose it.
			 */
2539
			sata_down_spd_limit(&ap->link);
2540 2541
			ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
		}
2542 2543
	}

2544
	if (!tries[dev->devno])
T
Tejun Heo 已提交
2545
		ata_dev_disable(dev);
2546

2547
	goto retry;
L
Linus Torvalds 已提交
2548 2549 2550
}

/**
J
Jeff Garzik 已提交
2551 2552
 *	ata_port_probe - Mark port as enabled
 *	@ap: Port for which we indicate enablement
L
Linus Torvalds 已提交
2553
 *
J
Jeff Garzik 已提交
2554 2555 2556
 *	Modify @ap data structure such that the system
 *	thinks that the entire port is enabled.
 *
J
Jeff Garzik 已提交
2557
 *	LOCKING: host lock, or some other form of
J
Jeff Garzik 已提交
2558
 *	serialization.
L
Linus Torvalds 已提交
2559 2560 2561 2562
 */

void ata_port_probe(struct ata_port *ap)
{
2563
	ap->flags &= ~ATA_FLAG_DISABLED;
L
Linus Torvalds 已提交
2564 2565
}

2566 2567
/**
 *	sata_print_link_status - Print SATA link status
2568
 *	@link: SATA link to printk link status about
2569 2570 2571 2572 2573 2574
 *
 *	This function prints link speed and status of a SATA link.
 *
 *	LOCKING:
 *	None.
 */
2575
void sata_print_link_status(struct ata_link *link)
2576
{
2577
	u32 sstatus, scontrol, tmp;
2578

2579
	if (sata_scr_read(link, SCR_STATUS, &sstatus))
2580
		return;
2581
	sata_scr_read(link, SCR_CONTROL, &scontrol);
2582

2583
	if (ata_link_online(link)) {
2584
		tmp = (sstatus >> 4) & 0xf;
2585
		ata_link_printk(link, KERN_INFO,
2586 2587
				"SATA link up %s (SStatus %X SControl %X)\n",
				sata_spd_string(tmp), sstatus, scontrol);
2588
	} else {
2589
		ata_link_printk(link, KERN_INFO,
2590 2591
				"SATA link down (SStatus %X SControl %X)\n",
				sstatus, scontrol);
2592 2593 2594
	}
}

2595 2596 2597 2598 2599 2600 2601
/**
 *	ata_dev_pair		-	return other device on cable
 *	@adev: device
 *
 *	Obtain the other device on the same cable, or if none is
 *	present NULL is returned
 */
2602

T
Tejun Heo 已提交
2603
struct ata_device *ata_dev_pair(struct ata_device *adev)
2604
{
T
Tejun Heo 已提交
2605 2606
	struct ata_link *link = adev->link;
	struct ata_device *pair = &link->device[1 - adev->devno];
2607
	if (!ata_dev_enabled(pair))
2608 2609 2610 2611
		return NULL;
	return pair;
}

L
Linus Torvalds 已提交
2612
/**
J
Jeff Garzik 已提交
2613 2614
 *	ata_port_disable - Disable port.
 *	@ap: Port to be disabled.
L
Linus Torvalds 已提交
2615
 *
J
Jeff Garzik 已提交
2616 2617 2618 2619 2620
 *	Modify @ap data structure such that the system
 *	thinks that the entire port is disabled, and should
 *	never attempt to probe or communicate with devices
 *	on this port.
 *
J
Jeff Garzik 已提交
2621
 *	LOCKING: host lock, or some other form of
J
Jeff Garzik 已提交
2622
 *	serialization.
L
Linus Torvalds 已提交
2623 2624 2625 2626
 */

void ata_port_disable(struct ata_port *ap)
{
T
Tejun Heo 已提交
2627 2628
	ap->link.device[0].class = ATA_DEV_NONE;
	ap->link.device[1].class = ATA_DEV_NONE;
2629
	ap->flags |= ATA_FLAG_DISABLED;
L
Linus Torvalds 已提交
2630 2631
}

2632
/**
2633
 *	sata_down_spd_limit - adjust SATA spd limit downward
2634
 *	@link: Link to adjust SATA spd limit for
2635
 *
2636
 *	Adjust SATA spd limit of @link downward.  Note that this
2637
 *	function only adjusts the limit.  The change must be applied
2638
 *	using sata_set_spd().
2639 2640 2641 2642 2643 2644 2645
 *
 *	LOCKING:
 *	Inherited from caller.
 *
 *	RETURNS:
 *	0 on success, negative errno on failure
 */
2646
int sata_down_spd_limit(struct ata_link *link)
2647
{
2648 2649
	u32 sstatus, spd, mask;
	int rc, highbit;
2650

2651
	if (!sata_scr_valid(link))
2652 2653 2654
		return -EOPNOTSUPP;

	/* If SCR can be read, use it to determine the current SPD.
2655
	 * If not, use cached value in link->sata_spd.
2656
	 */
2657
	rc = sata_scr_read(link, SCR_STATUS, &sstatus);
2658 2659 2660
	if (rc == 0)
		spd = (sstatus >> 4) & 0xf;
	else
2661
		spd = link->sata_spd;
2662

2663
	mask = link->sata_spd_limit;
2664 2665
	if (mask <= 1)
		return -EINVAL;
2666 2667

	/* unconditionally mask off the highest bit */
2668 2669 2670
	highbit = fls(mask) - 1;
	mask &= ~(1 << highbit);

2671 2672 2673 2674 2675 2676 2677 2678 2679
	/* Mask off all speeds higher than or equal to the current
	 * one.  Force 1.5Gbps if current SPD is not available.
	 */
	if (spd > 1)
		mask &= (1 << (spd - 1)) - 1;
	else
		mask &= 1;

	/* were we already at the bottom? */
2680 2681 2682
	if (!mask)
		return -EINVAL;

2683
	link->sata_spd_limit = mask;
2684

2685
	ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n",
2686
			sata_spd_string(fls(mask)));
2687 2688 2689 2690

	return 0;
}

2691
static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
2692
{
2693 2694
	struct ata_link *host_link = &link->ap->link;
	u32 limit, target, spd;
2695

2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706
	limit = link->sata_spd_limit;

	/* Don't configure downstream link faster than upstream link.
	 * It doesn't speed up anything and some PMPs choke on such
	 * configuration.
	 */
	if (!ata_is_host_link(link) && host_link->sata_spd)
		limit &= (1 << host_link->sata_spd) - 1;

	if (limit == UINT_MAX)
		target = 0;
2707
	else
2708
		target = fls(limit);
2709 2710

	spd = (*scontrol >> 4) & 0xf;
2711
	*scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4);
2712

2713
	return spd != target;
2714 2715 2716
}

/**
2717
 *	sata_set_spd_needed - is SATA spd configuration needed
2718
 *	@link: Link in question
2719 2720
 *
 *	Test whether the spd limit in SControl matches
2721
 *	@link->sata_spd_limit.  This function is used to determine
2722 2723 2724 2725 2726 2727 2728 2729 2730
 *	whether hardreset is necessary to apply SATA spd
 *	configuration.
 *
 *	LOCKING:
 *	Inherited from caller.
 *
 *	RETURNS:
 *	1 if SATA spd configuration is needed, 0 otherwise.
 */
2731
int sata_set_spd_needed(struct ata_link *link)
2732 2733 2734
{
	u32 scontrol;

2735
	if (sata_scr_read(link, SCR_CONTROL, &scontrol))
2736
		return 1;
2737

2738
	return __sata_set_spd_needed(link, &scontrol);
2739 2740 2741
}

/**
2742
 *	sata_set_spd - set SATA spd according to spd limit
2743
 *	@link: Link to set SATA spd for
2744
 *
2745
 *	Set SATA spd of @link according to sata_spd_limit.
2746 2747 2748 2749 2750 2751
 *
 *	LOCKING:
 *	Inherited from caller.
 *
 *	RETURNS:
 *	0 if spd doesn't need to be changed, 1 if spd has been
2752
 *	changed.  Negative errno if SCR registers are inaccessible.
2753
 */
2754
int sata_set_spd(struct ata_link *link)
2755 2756
{
	u32 scontrol;
2757
	int rc;
2758

2759
	if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
2760
		return rc;
2761

2762
	if (!__sata_set_spd_needed(link, &scontrol))
2763 2764
		return 0;

2765
	if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
2766 2767
		return rc;

2768 2769 2770
	return 1;
}

A
Alan Cox 已提交
2771 2772 2773 2774 2775
/*
 * This mode timing computation functionality is ported over from
 * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
 */
/*
2776
 * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
A
Alan Cox 已提交
2777
 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
2778 2779 2780
 * for UDMA6, which is currently supported only by Maxtor drives.
 *
 * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0.
A
Alan Cox 已提交
2781 2782 2783 2784 2785 2786 2787 2788 2789
 */

static const struct ata_timing ata_timing[] = {

	{ XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
	{ XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
	{ XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
	{ XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },

2790 2791
	{ XFER_MW_DMA_4,  25,   0,   0,   0,  55,  20,  80,   0 },
	{ XFER_MW_DMA_3,  25,   0,   0,   0,  65,  25, 100,   0 },
A
Alan Cox 已提交
2792 2793 2794 2795 2796
	{ XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
	{ XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
	{ XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },

/*	{ XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
2797

A
Alan Cox 已提交
2798 2799 2800
	{ XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
	{ XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
	{ XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
2801

A
Alan Cox 已提交
2802 2803 2804 2805
	{ XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
	{ XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
	{ XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },

2806 2807
	{ XFER_PIO_6,     10,  55,  20,  80,  55,  20,  80,   0 },
	{ XFER_PIO_5,     15,  65,  25, 100,  65,  25, 100,   0 },
A
Alan Cox 已提交
2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819
	{ XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
	{ XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },

	{ XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
	{ XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
	{ XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },

/*	{ XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */

	{ 0xFF }
};

2820 2821
#define ENOUGH(v, unit)		(((v)-1)/(unit)+1)
#define EZ(v, unit)		((v)?ENOUGH(v, unit):0)
A
Alan Cox 已提交
2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847

static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
{
	q->setup   = EZ(t->setup   * 1000,  T);
	q->act8b   = EZ(t->act8b   * 1000,  T);
	q->rec8b   = EZ(t->rec8b   * 1000,  T);
	q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
	q->active  = EZ(t->active  * 1000,  T);
	q->recover = EZ(t->recover * 1000,  T);
	q->cycle   = EZ(t->cycle   * 1000,  T);
	q->udma    = EZ(t->udma    * 1000, UT);
}

void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
		      struct ata_timing *m, unsigned int what)
{
	if (what & ATA_TIMING_SETUP  ) m->setup   = max(a->setup,   b->setup);
	if (what & ATA_TIMING_ACT8B  ) m->act8b   = max(a->act8b,   b->act8b);
	if (what & ATA_TIMING_REC8B  ) m->rec8b   = max(a->rec8b,   b->rec8b);
	if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
	if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
	if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
	if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
	if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
}

2848
static const struct ata_timing *ata_timing_find_mode(unsigned short speed)
A
Alan Cox 已提交
2849 2850 2851 2852
{
	const struct ata_timing *t;

	for (t = ata_timing; t->mode != speed; t++)
A
Alan Cox 已提交
2853
		if (t->mode == 0xFF)
A
Alan Cox 已提交
2854
			return NULL;
2855
	return t;
A
Alan Cox 已提交
2856 2857 2858 2859 2860 2861 2862 2863 2864
}

int ata_timing_compute(struct ata_device *adev, unsigned short speed,
		       struct ata_timing *t, int T, int UT)
{
	const struct ata_timing *s;
	struct ata_timing p;

	/*
2865
	 * Find the mode.
2866
	 */
A
Alan Cox 已提交
2867 2868 2869 2870

	if (!(s = ata_timing_find_mode(speed)))
		return -EINVAL;

2871 2872
	memcpy(t, s, sizeof(*s));

A
Alan Cox 已提交
2873 2874 2875 2876 2877 2878 2879
	/*
	 * If the drive is an EIDE drive, it can tell us it needs extended
	 * PIO/MW_DMA cycle timing.
	 */

	if (adev->id[ATA_ID_FIELD_VALID] & 2) {	/* EIDE drive */
		memset(&p, 0, sizeof(p));
2880
		if (speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
A
Alan Cox 已提交
2881 2882
			if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
					    else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
2883
		} else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
A
Alan Cox 已提交
2884 2885 2886 2887 2888 2889 2890 2891 2892
			p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
		}
		ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
	}

	/*
	 * Convert the timing to bus clock counts.
	 */

2893
	ata_timing_quantize(t, t, T, UT);
A
Alan Cox 已提交
2894 2895

	/*
2896 2897 2898
	 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
	 * S.M.A.R.T * and some other commands. We have to ensure that the
	 * DMA cycle timing is slower/equal than the fastest PIO timing.
A
Alan Cox 已提交
2899 2900
	 */

2901
	if (speed > XFER_PIO_6) {
A
Alan Cox 已提交
2902 2903 2904 2905 2906
		ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
		ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
	}

	/*
2907
	 * Lengthen active & recovery time so that cycle time is correct.
A
Alan Cox 已提交
2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918
	 */

	if (t->act8b + t->rec8b < t->cyc8b) {
		t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
		t->rec8b = t->cyc8b - t->act8b;
	}

	if (t->active + t->recover < t->cycle) {
		t->active += (t->cycle - (t->active + t->recover)) / 2;
		t->recover = t->cycle - t->active;
	}
J
Jeff Garzik 已提交
2919

2920 2921 2922 2923 2924
	/* In a few cases quantisation may produce enough errors to
	   leave t->cycle too low for the sum of active and recovery
	   if so we must correct this */
	if (t->active + t->recover > t->cycle)
		t->cycle = t->active + t->recover;
A
Alan Cox 已提交
2925 2926 2927 2928

	return 0;
}

2929 2930 2931
/**
 *	ata_down_xfermask_limit - adjust dev xfer masks downward
 *	@dev: Device to adjust xfer masks
2932
 *	@sel: ATA_DNXFER_* selector
2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
 *
 *	Adjust xfer masks of @dev downward.  Note that this function
 *	does not apply the change.  Invoking ata_set_mode() afterwards
 *	will apply the limit.
 *
 *	LOCKING:
 *	Inherited from caller.
 *
 *	RETURNS:
 *	0 on success, negative errno on failure
 */
2944
int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
2945
{
2946 2947 2948 2949
	char buf[32];
	unsigned int orig_mask, xfer_mask;
	unsigned int pio_mask, mwdma_mask, udma_mask;
	int quiet, highbit;
2950

2951 2952
	quiet = !!(sel & ATA_DNXFER_QUIET);
	sel &= ~ATA_DNXFER_QUIET;
2953

2954 2955 2956 2957
	xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
						  dev->mwdma_mask,
						  dev->udma_mask);
	ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
2958

2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010
	switch (sel) {
	case ATA_DNXFER_PIO:
		highbit = fls(pio_mask) - 1;
		pio_mask &= ~(1 << highbit);
		break;

	case ATA_DNXFER_DMA:
		if (udma_mask) {
			highbit = fls(udma_mask) - 1;
			udma_mask &= ~(1 << highbit);
			if (!udma_mask)
				return -ENOENT;
		} else if (mwdma_mask) {
			highbit = fls(mwdma_mask) - 1;
			mwdma_mask &= ~(1 << highbit);
			if (!mwdma_mask)
				return -ENOENT;
		}
		break;

	case ATA_DNXFER_40C:
		udma_mask &= ATA_UDMA_MASK_40C;
		break;

	case ATA_DNXFER_FORCE_PIO0:
		pio_mask &= 1;
	case ATA_DNXFER_FORCE_PIO:
		mwdma_mask = 0;
		udma_mask = 0;
		break;

	default:
		BUG();
	}

	xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);

	if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
		return -ENOENT;

	if (!quiet) {
		if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
			snprintf(buf, sizeof(buf), "%s:%s",
				 ata_mode_string(xfer_mask),
				 ata_mode_string(xfer_mask & ATA_MASK_PIO));
		else
			snprintf(buf, sizeof(buf), "%s",
				 ata_mode_string(xfer_mask));

		ata_dev_printk(dev, KERN_WARNING,
			       "limiting speed to %s\n", buf);
	}
3011 3012 3013 3014 3015 3016 3017

	ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
			    &dev->udma_mask);

	return 0;
}

T
Tejun Heo 已提交
3018
static int ata_dev_set_mode(struct ata_device *dev)
L
Linus Torvalds 已提交
3019
{
T
Tejun Heo 已提交
3020
	struct ata_eh_context *ehc = &dev->link->eh_context;
3021 3022
	unsigned int err_mask;
	int rc;
L
Linus Torvalds 已提交
3023

3024
	dev->flags &= ~ATA_DFLAG_PIO;
L
Linus Torvalds 已提交
3025 3026 3027
	if (dev->xfer_shift == ATA_SHIFT_PIO)
		dev->flags |= ATA_DFLAG_PIO;

T
Tejun Heo 已提交
3028
	err_mask = ata_dev_set_xfermode(dev);
3029

3030 3031
	/* Old CFA may refuse this command, which is just fine */
	if (dev->xfer_shift == ATA_SHIFT_PIO && ata_id_is_cfa(dev->id))
3032 3033
		err_mask &= ~AC_ERR_DEV;

A
Alan Cox 已提交
3034 3035 3036 3037 3038
	/* Some very old devices and some bad newer ones fail any kind of
	   SET_XFERMODE request but support PIO0-2 timings and no IORDY */
	if (dev->xfer_shift == ATA_SHIFT_PIO && !ata_id_has_iordy(dev->id) &&
			dev->pio_mode <= XFER_PIO_2)
		err_mask &= ~AC_ERR_DEV;
3039

3040 3041 3042 3043 3044 3045 3046
	/* Early MWDMA devices do DMA but don't allow DMA mode setting.
	   Don't fail an MWDMA0 set IFF the device indicates it is in MWDMA0 */
	if (dev->xfer_shift == ATA_SHIFT_MWDMA && 
	    dev->dma_mode == XFER_MW_DMA_0 &&
	    (dev->id[63] >> 8) & 1)
		err_mask &= ~AC_ERR_DEV;

3047
	if (err_mask) {
3048 3049
		ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
			       "(err_mask=0x%x)\n", err_mask);
3050 3051
		return -EIO;
	}
L
Linus Torvalds 已提交
3052

3053
	ehc->i.flags |= ATA_EHI_POST_SETMODE;
3054
	rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
3055
	ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
3056
	if (rc)
3057
		return rc;
3058

3059 3060
	DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
		dev->xfer_shift, (int)dev->xfer_mode);
L
Linus Torvalds 已提交
3061

3062 3063
	ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
		       ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
3064
	return 0;
L
Linus Torvalds 已提交
3065 3066 3067
}

/**
3068
 *	ata_do_set_mode - Program timings and issue SET FEATURES - XFER
3069
 *	@link: link on which timings will be programmed
3070
 *	@r_failed_dev: out paramter for failed device
L
Linus Torvalds 已提交
3071
 *
3072 3073 3074
 *	Standard implementation of the function used to tune and set
 *	ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
 *	ata_dev_set_mode() fails, pointer to the failing device is
3075
 *	returned in @r_failed_dev.
J
Jeff Garzik 已提交
3076
 *
L
Linus Torvalds 已提交
3077
 *	LOCKING:
J
Jeff Garzik 已提交
3078
 *	PCI/etc. bus probe sem.
3079 3080 3081
 *
 *	RETURNS:
 *	0 on success, negative errno otherwise
L
Linus Torvalds 已提交
3082
 */
3083

3084
int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
L
Linus Torvalds 已提交
3085
{
3086
	struct ata_port *ap = link->ap;
3087
	struct ata_device *dev;
3088
	int rc = 0, used_dma = 0, found = 0;
3089

3090
	/* step 1: calculate xfer_mask */
3091
	ata_link_for_each_dev(dev, link) {
3092
		unsigned int pio_mask, dma_mask;
3093
		unsigned int mode_mask;
3094

3095
		if (!ata_dev_enabled(dev))
3096 3097
			continue;

3098 3099 3100 3101 3102 3103
		mode_mask = ATA_DMA_MASK_ATA;
		if (dev->class == ATA_DEV_ATAPI)
			mode_mask = ATA_DMA_MASK_ATAPI;
		else if (ata_id_is_cfa(dev->id))
			mode_mask = ATA_DMA_MASK_CFA;

T
Tejun Heo 已提交
3104
		ata_dev_xfermask(dev);
L
Linus Torvalds 已提交
3105

3106 3107
		pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
		dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
3108 3109 3110 3111 3112 3113

		if (libata_dma_mask & mode_mask)
			dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
		else
			dma_mask = 0;

3114 3115
		dev->pio_mode = ata_xfer_mask2mode(pio_mask);
		dev->dma_mode = ata_xfer_mask2mode(dma_mask);
3116

3117
		found = 1;
3118 3119
		if (dev->dma_mode)
			used_dma = 1;
3120
	}
3121
	if (!found)
3122
		goto out;
3123 3124

	/* step 2: always set host PIO timings */
3125
	ata_link_for_each_dev(dev, link) {
3126 3127 3128 3129
		if (!ata_dev_enabled(dev))
			continue;

		if (!dev->pio_mode) {
3130
			ata_dev_printk(dev, KERN_WARNING, "no PIO support\n");
3131
			rc = -EINVAL;
3132
			goto out;
3133 3134 3135 3136 3137 3138 3139
		}

		dev->xfer_mode = dev->pio_mode;
		dev->xfer_shift = ATA_SHIFT_PIO;
		if (ap->ops->set_piomode)
			ap->ops->set_piomode(ap, dev);
	}
L
Linus Torvalds 已提交
3140

3141
	/* step 3: set host DMA timings */
3142
	ata_link_for_each_dev(dev, link) {
3143 3144 3145 3146 3147 3148 3149 3150
		if (!ata_dev_enabled(dev) || !dev->dma_mode)
			continue;

		dev->xfer_mode = dev->dma_mode;
		dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
		if (ap->ops->set_dmamode)
			ap->ops->set_dmamode(ap, dev);
	}
L
Linus Torvalds 已提交
3151 3152

	/* step 4: update devices' xfer mode */
3153
	ata_link_for_each_dev(dev, link) {
A
Alan 已提交
3154
		/* don't update suspended devices' xfer mode */
3155
		if (!ata_dev_enabled(dev))
3156 3157
			continue;

T
Tejun Heo 已提交
3158
		rc = ata_dev_set_mode(dev);
3159
		if (rc)
3160
			goto out;
3161
	}
L
Linus Torvalds 已提交
3162

3163 3164
	/* Record simplex status. If we selected DMA then the other
	 * host channels are not permitted to do so.
3165
	 */
J
Jeff Garzik 已提交
3166
	if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
A
Alan 已提交
3167
		ap->host->simplex_claimed = ap;
3168

3169 3170 3171 3172
 out:
	if (rc)
		*r_failed_dev = dev;
	return rc;
L
Linus Torvalds 已提交
3173 3174
}

3175 3176
/**
 *	ata_set_mode - Program timings and issue SET FEATURES - XFER
3177
 *	@link: link on which timings will be programmed
3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189
 *	@r_failed_dev: out paramter for failed device
 *
 *	Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
 *	ata_set_mode() fails, pointer to the failing device is
 *	returned in @r_failed_dev.
 *
 *	LOCKING:
 *	PCI/etc. bus probe sem.
 *
 *	RETURNS:
 *	0 on success, negative errno otherwise
 */
3190
int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3191
{
3192 3193
	struct ata_port *ap = link->ap;

3194 3195
	/* has private set_mode? */
	if (ap->ops->set_mode)
3196 3197
		return ap->ops->set_mode(link, r_failed_dev);
	return ata_do_set_mode(link, r_failed_dev);
3198 3199
}

3200 3201 3202 3203 3204 3205 3206 3207 3208 3209
/**
 *	ata_tf_to_host - issue ATA taskfile to host controller
 *	@ap: port to which command is being issued
 *	@tf: ATA taskfile register set
 *
 *	Issues ATA taskfile register set to ATA host controller,
 *	with proper synchronization with interrupt handler and
 *	other threads.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
3210
 *	spin_lock_irqsave(host lock)
3211 3212 3213 3214 3215 3216 3217 3218 3219
 */

static inline void ata_tf_to_host(struct ata_port *ap,
				  const struct ata_taskfile *tf)
{
	ap->ops->tf_load(ap, tf);
	ap->ops->exec_command(ap, tf);
}

L
Linus Torvalds 已提交
3220 3221 3222 3223 3224 3225
/**
 *	ata_busy_sleep - sleep until BSY clears, or timeout
 *	@ap: port containing status register to be polled
 *	@tmout_pat: impatience timeout
 *	@tmout: overall timeout
 *
J
Jeff Garzik 已提交
3226 3227 3228
 *	Sleep until ATA Status register bit BSY clears,
 *	or a timeout occurs.
 *
3229 3230 3231 3232 3233
 *	LOCKING:
 *	Kernel thread context (may sleep).
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
L
Linus Torvalds 已提交
3234
 */
3235 3236
int ata_busy_sleep(struct ata_port *ap,
		   unsigned long tmout_pat, unsigned long tmout)
L
Linus Torvalds 已提交
3237 3238 3239 3240 3241 3242 3243
{
	unsigned long timer_start, timeout;
	u8 status;

	status = ata_busy_wait(ap, ATA_BUSY, 300);
	timer_start = jiffies;
	timeout = timer_start + tmout_pat;
3244 3245
	while (status != 0xff && (status & ATA_BUSY) &&
	       time_before(jiffies, timeout)) {
L
Linus Torvalds 已提交
3246 3247 3248 3249
		msleep(50);
		status = ata_busy_wait(ap, ATA_BUSY, 3);
	}

3250
	if (status != 0xff && (status & ATA_BUSY))
3251
		ata_port_printk(ap, KERN_WARNING,
3252 3253
				"port is slow to respond, please be patient "
				"(Status 0x%x)\n", status);
L
Linus Torvalds 已提交
3254 3255

	timeout = timer_start + tmout;
3256 3257
	while (status != 0xff && (status & ATA_BUSY) &&
	       time_before(jiffies, timeout)) {
L
Linus Torvalds 已提交
3258 3259 3260 3261
		msleep(50);
		status = ata_chk_status(ap);
	}

3262 3263 3264
	if (status == 0xff)
		return -ENODEV;

L
Linus Torvalds 已提交
3265
	if (status & ATA_BUSY) {
3266
		ata_port_printk(ap, KERN_ERR, "port failed to respond "
3267 3268
				"(%lu secs, Status 0x%x)\n",
				tmout / HZ, status);
3269
		return -EBUSY;
L
Linus Torvalds 已提交
3270 3271 3272 3273 3274
	}

	return 0;
}

3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312
/**
 *	ata_wait_after_reset - wait before checking status after reset
 *	@ap: port containing status register to be polled
 *	@deadline: deadline jiffies for the operation
 *
 *	After reset, we need to pause a while before reading status.
 *	Also, certain combination of controller and device report 0xff
 *	for some duration (e.g. until SATA PHY is up and running)
 *	which is interpreted as empty port in ATA world.  This
 *	function also waits for such devices to get out of 0xff
 *	status.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 */
void ata_wait_after_reset(struct ata_port *ap, unsigned long deadline)
{
	unsigned long until = jiffies + ATA_TMOUT_FF_WAIT;

	if (time_before(until, deadline))
		deadline = until;

	/* Spec mandates ">= 2ms" before checking status.  We wait
	 * 150ms, because that was the magic delay used for ATAPI
	 * devices in Hale Landis's ATADRVR, for the period of time
	 * between when the ATA command register is written, and then
	 * status is checked.  Because waiting for "a while" before
	 * checking status is fine, post SRST, we perform this magic
	 * delay here as well.
	 *
	 * Old drivers/ide uses the 2mS rule and then waits for ready.
	 */
	msleep(150);

	/* Wait for 0xff to clear.  Some SATA devices take a long time
	 * to clear 0xff after reset.  For example, HHD424020F7SV00
	 * iVDR needs >= 800ms while.  Quantum GoVault needs even more
	 * than that.
3313 3314 3315 3316
	 *
	 * Note that some PATA controllers (pata_ali) explode if
	 * status register is read more than once when there's no
	 * device attached.
3317
	 */
3318 3319 3320
	if (ap->flags & ATA_FLAG_SATA) {
		while (1) {
			u8 status = ata_chk_status(ap);
3321

3322 3323
			if (status != 0xff || time_after(jiffies, deadline))
				return;
3324

3325 3326
			msleep(50);
		}
3327 3328 3329
	}
}

3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354
/**
 *	ata_wait_ready - sleep until BSY clears, or timeout
 *	@ap: port containing status register to be polled
 *	@deadline: deadline jiffies for the operation
 *
 *	Sleep until ATA Status register bit BSY clears, or timeout
 *	occurs.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
 */
int ata_wait_ready(struct ata_port *ap, unsigned long deadline)
{
	unsigned long start = jiffies;
	int warned = 0;

	while (1) {
		u8 status = ata_chk_status(ap);
		unsigned long now = jiffies;

		if (!(status & ATA_BUSY))
			return 0;
3355
		if (!ata_link_online(&ap->link) && status == 0xff)
3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373
			return -ENODEV;
		if (time_after(now, deadline))
			return -EBUSY;

		if (!warned && time_after(now, start + 5 * HZ) &&
		    (deadline - now > 3 * HZ)) {
			ata_port_printk(ap, KERN_WARNING,
				"port is slow to respond, please be patient "
				"(Status 0x%x)\n", status);
			warned = 1;
		}

		msleep(50);
	}
}

static int ata_bus_post_reset(struct ata_port *ap, unsigned int devmask,
			      unsigned long deadline)
L
Linus Torvalds 已提交
3374 3375 3376 3377
{
	struct ata_ioports *ioaddr = &ap->ioaddr;
	unsigned int dev0 = devmask & (1 << 0);
	unsigned int dev1 = devmask & (1 << 1);
T
Tejun Heo 已提交
3378
	int rc, ret = 0;
L
Linus Torvalds 已提交
3379 3380 3381 3382

	/* if device 0 was found in ata_devchk, wait for its
	 * BSY bit to clear
	 */
3383 3384
	if (dev0) {
		rc = ata_wait_ready(ap, deadline);
T
Tejun Heo 已提交
3385 3386 3387 3388 3389
		if (rc) {
			if (rc != -ENODEV)
				return rc;
			ret = rc;
		}
3390
	}
L
Linus Torvalds 已提交
3391

3392 3393
	/* if device 1 was found in ata_devchk, wait for register
	 * access briefly, then wait for BSY to clear.
L
Linus Torvalds 已提交
3394
	 */
3395 3396
	if (dev1) {
		int i;
L
Linus Torvalds 已提交
3397 3398

		ap->ops->dev_select(ap, 1);
3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413

		/* Wait for register access.  Some ATAPI devices fail
		 * to set nsect/lbal after reset, so don't waste too
		 * much time on it.  We're gonna wait for !BSY anyway.
		 */
		for (i = 0; i < 2; i++) {
			u8 nsect, lbal;

			nsect = ioread8(ioaddr->nsect_addr);
			lbal = ioread8(ioaddr->lbal_addr);
			if ((nsect == 1) && (lbal == 1))
				break;
			msleep(50);	/* give drive a breather */
		}

3414
		rc = ata_wait_ready(ap, deadline);
T
Tejun Heo 已提交
3415 3416 3417 3418 3419
		if (rc) {
			if (rc != -ENODEV)
				return rc;
			ret = rc;
		}
3420
	}
L
Linus Torvalds 已提交
3421 3422 3423 3424 3425 3426 3427

	/* is all this really necessary? */
	ap->ops->dev_select(ap, 0);
	if (dev1)
		ap->ops->dev_select(ap, 1);
	if (dev0)
		ap->ops->dev_select(ap, 0);
3428

T
Tejun Heo 已提交
3429
	return ret;
L
Linus Torvalds 已提交
3430 3431
}

3432 3433
static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
			     unsigned long deadline)
L
Linus Torvalds 已提交
3434 3435 3436
{
	struct ata_ioports *ioaddr = &ap->ioaddr;

T
Tejun Heo 已提交
3437
	DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
L
Linus Torvalds 已提交
3438 3439

	/* software reset.  causes dev0 to be selected */
T
Tejun Heo 已提交
3440 3441 3442 3443 3444
	iowrite8(ap->ctl, ioaddr->ctl_addr);
	udelay(20);	/* FIXME: flush */
	iowrite8(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
	udelay(20);	/* FIXME: flush */
	iowrite8(ap->ctl, ioaddr->ctl_addr);
L
Linus Torvalds 已提交
3445

3446 3447
	/* wait a while before checking status */
	ata_wait_after_reset(ap, deadline);
L
Linus Torvalds 已提交
3448

3449
	/* Before we perform post reset processing we want to see if
3450 3451 3452
	 * the bus shows 0xFF because the odd clown forgets the D7
	 * pulldown resistor.
	 */
3453
	if (ata_chk_status(ap) == 0xFF)
T
Tejun Heo 已提交
3454
		return -ENODEV;
3455

3456
	return ata_bus_post_reset(ap, devmask, deadline);
L
Linus Torvalds 已提交
3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471
}

/**
 *	ata_bus_reset - reset host port and associated ATA channel
 *	@ap: port to reset
 *
 *	This is typically the first time we actually start issuing
 *	commands to the ATA channel.  We wait for BSY to clear, then
 *	issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
 *	result.  Determine what devices, if any, are on the channel
 *	by looking at the device 0/1 error register.  Look at the signature
 *	stored in each device's taskfile registers, to determine if
 *	the device is ATA or ATAPI.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
3472
 *	PCI/etc. bus probe sem.
J
Jeff Garzik 已提交
3473
 *	Obtains host lock.
L
Linus Torvalds 已提交
3474 3475
 *
 *	SIDE EFFECTS:
3476
 *	Sets ATA_FLAG_DISABLED if bus reset fails.
L
Linus Torvalds 已提交
3477 3478 3479 3480
 */

void ata_bus_reset(struct ata_port *ap)
{
T
Tejun Heo 已提交
3481
	struct ata_device *device = ap->link.device;
L
Linus Torvalds 已提交
3482 3483 3484
	struct ata_ioports *ioaddr = &ap->ioaddr;
	unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
	u8 err;
T
Tejun Heo 已提交
3485
	unsigned int dev0, dev1 = 0, devmask = 0;
T
Tejun Heo 已提交
3486
	int rc;
L
Linus Torvalds 已提交
3487

T
Tejun Heo 已提交
3488
	DPRINTK("ENTER, host %u, port %u\n", ap->print_id, ap->port_no);
L
Linus Torvalds 已提交
3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507

	/* determine if device 0/1 are present */
	if (ap->flags & ATA_FLAG_SATA_RESET)
		dev0 = 1;
	else {
		dev0 = ata_devchk(ap, 0);
		if (slave_possible)
			dev1 = ata_devchk(ap, 1);
	}

	if (dev0)
		devmask |= (1 << 0);
	if (dev1)
		devmask |= (1 << 1);

	/* select device 0 again */
	ap->ops->dev_select(ap, 0);

	/* issue bus reset */
T
Tejun Heo 已提交
3508 3509 3510
	if (ap->flags & ATA_FLAG_SRST) {
		rc = ata_bus_softreset(ap, devmask, jiffies + 40 * HZ);
		if (rc && rc != -ENODEV)
T
Tejun Heo 已提交
3511
			goto err_out;
T
Tejun Heo 已提交
3512
	}
L
Linus Torvalds 已提交
3513 3514 3515 3516

	/*
	 * determine by signature whether we have ATA or ATAPI devices
	 */
3517
	device[0].class = ata_dev_try_classify(&device[0], dev0, &err);
L
Linus Torvalds 已提交
3518
	if ((slave_possible) && (err != 0x81))
3519
		device[1].class = ata_dev_try_classify(&device[1], dev1, &err);
L
Linus Torvalds 已提交
3520 3521

	/* is double-select really necessary? */
T
Tejun Heo 已提交
3522
	if (device[1].class != ATA_DEV_NONE)
L
Linus Torvalds 已提交
3523
		ap->ops->dev_select(ap, 1);
T
Tejun Heo 已提交
3524
	if (device[0].class != ATA_DEV_NONE)
L
Linus Torvalds 已提交
3525 3526 3527
		ap->ops->dev_select(ap, 0);

	/* if no devices were detected, disable this port */
T
Tejun Heo 已提交
3528 3529
	if ((device[0].class == ATA_DEV_NONE) &&
	    (device[1].class == ATA_DEV_NONE))
L
Linus Torvalds 已提交
3530 3531 3532 3533
		goto err_out;

	if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
		/* set up device control for ATA_FLAG_SATA_RESET */
T
Tejun Heo 已提交
3534
		iowrite8(ap->ctl, ioaddr->ctl_addr);
L
Linus Torvalds 已提交
3535 3536 3537 3538 3539 3540
	}

	DPRINTK("EXIT\n");
	return;

err_out:
3541
	ata_port_printk(ap, KERN_ERR, "disabling port\n");
3542
	ata_port_disable(ap);
L
Linus Torvalds 已提交
3543 3544 3545 3546

	DPRINTK("EXIT\n");
}

3547
/**
3548 3549
 *	sata_link_debounce - debounce SATA phy status
 *	@link: ATA link to debounce SATA phy status for
3550
 *	@params: timing parameters { interval, duratinon, timeout } in msec
3551
 *	@deadline: deadline jiffies for the operation
3552
 *
3553
*	Make sure SStatus of @link reaches stable state, determined by
3554 3555
 *	holding the same value where DET is not 1 for @duration polled
 *	every @interval, before @timeout.  Timeout constraints the
3556 3557
 *	beginning of the stable state.  Because DET gets stuck at 1 on
 *	some controllers after hot unplugging, this functions waits
3558 3559
 *	until timeout then returns 0 if DET is stable at 1.
 *
3560 3561 3562
 *	@timeout is further limited by @deadline.  The sooner of the
 *	two is used.
 *
3563 3564 3565 3566 3567 3568
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno on failure.
 */
3569 3570
int sata_link_debounce(struct ata_link *link, const unsigned long *params,
		       unsigned long deadline)
3571
{
3572
	unsigned long interval_msec = params[0];
3573 3574
	unsigned long duration = msecs_to_jiffies(params[1]);
	unsigned long last_jiffies, t;
3575 3576 3577
	u32 last, cur;
	int rc;

3578 3579 3580 3581
	t = jiffies + msecs_to_jiffies(params[2]);
	if (time_before(t, deadline))
		deadline = t;

3582
	if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
3583 3584 3585 3586 3587 3588 3589 3590
		return rc;
	cur &= 0xf;

	last = cur;
	last_jiffies = jiffies;

	while (1) {
		msleep(interval_msec);
3591
		if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
3592 3593 3594 3595 3596
			return rc;
		cur &= 0xf;

		/* DET stable? */
		if (cur == last) {
3597
			if (cur == 1 && time_before(jiffies, deadline))
3598 3599 3600 3601 3602 3603 3604 3605 3606 3607
				continue;
			if (time_after(jiffies, last_jiffies + duration))
				return 0;
			continue;
		}

		/* unstable, start over */
		last = cur;
		last_jiffies = jiffies;

3608 3609 3610
		/* Check deadline.  If debouncing failed, return
		 * -EPIPE to tell upper layer to lower link speed.
		 */
3611
		if (time_after(jiffies, deadline))
3612
			return -EPIPE;
3613 3614 3615 3616
	}
}

/**
3617 3618
 *	sata_link_resume - resume SATA link
 *	@link: ATA link to resume SATA
3619
 *	@params: timing parameters { interval, duratinon, timeout } in msec
3620
 *	@deadline: deadline jiffies for the operation
3621
 *
3622
 *	Resume SATA phy @link and debounce it.
3623 3624 3625 3626 3627 3628 3629
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno on failure.
 */
3630 3631
int sata_link_resume(struct ata_link *link, const unsigned long *params,
		     unsigned long deadline)
3632 3633
{
	u32 scontrol;
3634 3635
	int rc;

3636
	if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3637
		return rc;
3638

3639
	scontrol = (scontrol & 0x0f0) | 0x300;
3640

3641
	if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
3642
		return rc;
3643

3644 3645 3646 3647
	/* Some PHYs react badly if SStatus is pounded immediately
	 * after resuming.  Delay 200ms before debouncing.
	 */
	msleep(200);
3648

3649
	return sata_link_debounce(link, params, deadline);
3650 3651
}

3652 3653
/**
 *	ata_std_prereset - prepare for reset
T
Tejun Heo 已提交
3654
 *	@link: ATA link to be reset
3655
 *	@deadline: deadline jiffies for the operation
3656
 *
T
Tejun Heo 已提交
3657
 *	@link is about to be reset.  Initialize it.  Failure from
T
Tejun Heo 已提交
3658 3659 3660 3661
 *	prereset makes libata abort whole reset sequence and give up
 *	that port, so prereset should be best-effort.  It does its
 *	best to prepare for reset sequence but if things go wrong, it
 *	should just whine, not fail.
3662 3663 3664 3665 3666 3667 3668
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
 */
T
Tejun Heo 已提交
3669
int ata_std_prereset(struct ata_link *link, unsigned long deadline)
3670
{
T
Tejun Heo 已提交
3671
	struct ata_port *ap = link->ap;
3672
	struct ata_eh_context *ehc = &link->eh_context;
3673
	const unsigned long *timing = sata_ehc_deb_timing(ehc);
3674 3675
	int rc;

T
Tejun Heo 已提交
3676
	/* handle link resume */
3677
	if ((ehc->i.flags & ATA_EHI_RESUME_LINK) &&
3678
	    (link->flags & ATA_LFLAG_HRST_TO_RESUME))
3679 3680
		ehc->i.action |= ATA_EH_HARDRESET;

3681 3682 3683 3684 3685 3686
	/* Some PMPs don't work with only SRST, force hardreset if PMP
	 * is supported.
	 */
	if (ap->flags & ATA_FLAG_PMP)
		ehc->i.action |= ATA_EH_HARDRESET;

3687 3688 3689 3690
	/* if we're about to do hardreset, nothing more to do */
	if (ehc->i.action & ATA_EH_HARDRESET)
		return 0;

3691
	/* if SATA, resume link */
3692
	if (ap->flags & ATA_FLAG_SATA) {
3693
		rc = sata_link_resume(link, timing, deadline);
T
Tejun Heo 已提交
3694 3695
		/* whine about phy resume failure but proceed */
		if (rc && rc != -EOPNOTSUPP)
T
Tejun Heo 已提交
3696
			ata_link_printk(link, KERN_WARNING, "failed to resume "
3697 3698 3699 3700 3701 3702
					"link for reset (errno=%d)\n", rc);
	}

	/* Wait for !BSY if the controller can wait for the first D2H
	 * Reg FIS and we don't know that no device is attached.
	 */
3703
	if (!(link->flags & ATA_LFLAG_SKIP_D2H_BSY) && !ata_link_offline(link)) {
T
Tejun Heo 已提交
3704
		rc = ata_wait_ready(ap, deadline);
3705
		if (rc && rc != -ENODEV) {
T
Tejun Heo 已提交
3706
			ata_link_printk(link, KERN_WARNING, "device not ready "
T
Tejun Heo 已提交
3707 3708 3709 3710
					"(errno=%d), forcing hardreset\n", rc);
			ehc->i.action |= ATA_EH_HARDRESET;
		}
	}
3711 3712 3713 3714

	return 0;
}

3715 3716
/**
 *	ata_std_softreset - reset host port via ATA SRST
T
Tejun Heo 已提交
3717
 *	@link: ATA link to reset
3718
 *	@classes: resulting classes of attached devices
3719
 *	@deadline: deadline jiffies for the operation
3720
 *
3721
 *	Reset host port using ATA SRST.
3722 3723 3724 3725 3726 3727 3728
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
 */
T
Tejun Heo 已提交
3729
int ata_std_softreset(struct ata_link *link, unsigned int *classes,
3730
		      unsigned long deadline)
3731
{
T
Tejun Heo 已提交
3732
	struct ata_port *ap = link->ap;
3733
	unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
3734 3735
	unsigned int devmask = 0;
	int rc;
3736 3737 3738 3739
	u8 err;

	DPRINTK("ENTER\n");

3740
	if (ata_link_offline(link)) {
3741 3742 3743 3744
		classes[0] = ATA_DEV_NONE;
		goto out;
	}

3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755
	/* determine if device 0/1 are present */
	if (ata_devchk(ap, 0))
		devmask |= (1 << 0);
	if (slave_possible && ata_devchk(ap, 1))
		devmask |= (1 << 1);

	/* select device 0 again */
	ap->ops->dev_select(ap, 0);

	/* issue bus reset */
	DPRINTK("about to softreset, devmask=%x\n", devmask);
3756
	rc = ata_bus_softreset(ap, devmask, deadline);
T
Tejun Heo 已提交
3757
	/* if link is occupied, -ENODEV too is an error */
3758
	if (rc && (rc != -ENODEV || sata_scr_valid(link))) {
T
Tejun Heo 已提交
3759
		ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc);
3760
		return rc;
3761 3762 3763
	}

	/* determine by signature whether we have ATA or ATAPI devices */
3764 3765
	classes[0] = ata_dev_try_classify(&link->device[0],
					  devmask & (1 << 0), &err);
3766
	if (slave_possible && err != 0x81)
3767 3768
		classes[1] = ata_dev_try_classify(&link->device[1],
						  devmask & (1 << 1), &err);
3769

3770
 out:
3771 3772 3773 3774 3775
	DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
	return 0;
}

/**
T
Tejun Heo 已提交
3776 3777
 *	sata_link_hardreset - reset link via SATA phy reset
 *	@link: link to reset
3778
 *	@timing: timing parameters { interval, duratinon, timeout } in msec
3779
 *	@deadline: deadline jiffies for the operation
3780
 *
T
Tejun Heo 已提交
3781
 *	SATA phy-reset @link using DET bits of SControl register.
3782 3783 3784 3785 3786 3787 3788
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
 */
T
Tejun Heo 已提交
3789
int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
3790
			unsigned long deadline)
3791
{
3792
	u32 scontrol;
3793
	int rc;
3794

3795 3796
	DPRINTK("ENTER\n");

3797
	if (sata_set_spd_needed(link)) {
3798 3799 3800 3801 3802
		/* SATA spec says nothing about how to reconfigure
		 * spd.  To be on the safe side, turn off phy during
		 * reconfiguration.  This works for at least ICH7 AHCI
		 * and Sil3124.
		 */
3803
		if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3804
			goto out;
3805

3806
		scontrol = (scontrol & 0x0f0) | 0x304;
3807

3808
		if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
3809
			goto out;
3810

3811
		sata_set_spd(link);
3812 3813 3814
	}

	/* issue phy wake/reset */
3815
	if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3816
		goto out;
3817

3818
	scontrol = (scontrol & 0x0f0) | 0x301;
3819

3820
	if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
3821
		goto out;
3822

3823
	/* Couldn't find anything in SATA I/II specs, but AHCI-1.1
3824 3825 3826 3827
	 * 10.4.2 says at least 1 ms.
	 */
	msleep(1);

3828 3829
	/* bring link back */
	rc = sata_link_resume(link, timing, deadline);
3830 3831 3832 3833 3834 3835 3836
 out:
	DPRINTK("EXIT, rc=%d\n", rc);
	return rc;
}

/**
 *	sata_std_hardreset - reset host port via SATA phy reset
T
Tejun Heo 已提交
3837
 *	@link: link to reset
3838
 *	@class: resulting class of attached device
3839
 *	@deadline: deadline jiffies for the operation
3840 3841 3842 3843 3844 3845 3846 3847 3848 3849
 *
 *	SATA phy-reset host port using DET bits of SControl register,
 *	wait for !BSY and classify the attached device.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
 */
T
Tejun Heo 已提交
3850
int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3851
		       unsigned long deadline)
3852
{
T
Tejun Heo 已提交
3853
	struct ata_port *ap = link->ap;
3854
	const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
3855 3856 3857 3858 3859
	int rc;

	DPRINTK("ENTER\n");

	/* do hardreset */
T
Tejun Heo 已提交
3860
	rc = sata_link_hardreset(link, timing, deadline);
3861
	if (rc) {
T
Tejun Heo 已提交
3862
		ata_link_printk(link, KERN_ERR,
3863 3864 3865
				"COMRESET failed (errno=%d)\n", rc);
		return rc;
	}
3866 3867

	/* TODO: phy layer with polling, timeouts, etc. */
3868
	if (ata_link_offline(link)) {
3869 3870 3871 3872 3873
		*class = ATA_DEV_NONE;
		DPRINTK("EXIT, link offline\n");
		return 0;
	}

3874 3875
	/* wait a while before checking status */
	ata_wait_after_reset(ap, deadline);
3876

3877 3878 3879 3880 3881 3882 3883 3884 3885 3886
	/* If PMP is supported, we have to do follow-up SRST.  Note
	 * that some PMPs don't send D2H Reg FIS after hardreset at
	 * all if the first port is empty.  Wait for it just for a
	 * second and request follow-up SRST.
	 */
	if (ap->flags & ATA_FLAG_PMP) {
		ata_wait_ready(ap, jiffies + HZ);
		return -EAGAIN;
	}

3887
	rc = ata_wait_ready(ap, deadline);
T
Tejun Heo 已提交
3888 3889
	/* link occupied, -ENODEV too is an error */
	if (rc) {
T
Tejun Heo 已提交
3890
		ata_link_printk(link, KERN_ERR,
3891 3892
				"COMRESET failed (errno=%d)\n", rc);
		return rc;
3893 3894
	}

3895 3896
	ap->ops->dev_select(ap, 0);	/* probably unnecessary */

3897
	*class = ata_dev_try_classify(link->device, 1, NULL);
3898 3899 3900 3901 3902 3903 3904

	DPRINTK("EXIT, class=%u\n", *class);
	return 0;
}

/**
 *	ata_std_postreset - standard postreset callback
T
Tejun Heo 已提交
3905
 *	@link: the target ata_link
3906 3907 3908 3909 3910 3911 3912 3913 3914
 *	@classes: classes of attached devices
 *
 *	This function is invoked after a successful reset.  Note that
 *	the device might have been reset more than once using
 *	different reset methods before postreset is invoked.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 */
T
Tejun Heo 已提交
3915
void ata_std_postreset(struct ata_link *link, unsigned int *classes)
3916
{
T
Tejun Heo 已提交
3917
	struct ata_port *ap = link->ap;
3918 3919
	u32 serror;

3920 3921 3922
	DPRINTK("ENTER\n");

	/* print link status */
3923
	sata_print_link_status(link);
3924

3925
	/* clear SError */
3926 3927
	if (sata_scr_read(link, SCR_ERROR, &serror) == 0)
		sata_scr_write(link, SCR_ERROR, serror);
3928
	link->eh_info.serror = 0;
3929

3930 3931 3932 3933 3934 3935
	/* is double-select really necessary? */
	if (classes[0] != ATA_DEV_NONE)
		ap->ops->dev_select(ap, 1);
	if (classes[1] != ATA_DEV_NONE)
		ap->ops->dev_select(ap, 0);

3936 3937 3938 3939 3940 3941 3942
	/* bail out if no device is present */
	if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
		DPRINTK("EXIT, no device\n");
		return;
	}

	/* set up device control */
T
Tejun Heo 已提交
3943 3944
	if (ap->ioaddr.ctl_addr)
		iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
3945 3946 3947 3948

	DPRINTK("EXIT\n");
}

3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964
/**
 *	ata_dev_same_device - Determine whether new ID matches configured device
 *	@dev: device to compare against
 *	@new_class: class of the new device
 *	@new_id: IDENTIFY page of the new device
 *
 *	Compare @new_class and @new_id against @dev and determine
 *	whether @dev is the device indicated by @new_class and
 *	@new_id.
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	1 if @dev matches @new_class and @new_id, 0 otherwise.
 */
T
Tejun Heo 已提交
3965 3966
static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
			       const u16 *new_id)
3967 3968
{
	const u16 *old_id = dev->id;
3969 3970
	unsigned char model[2][ATA_ID_PROD_LEN + 1];
	unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
3971 3972

	if (dev->class != new_class) {
3973 3974
		ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n",
			       dev->class, new_class);
3975 3976 3977
		return 0;
	}

3978 3979 3980 3981
	ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
	ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
	ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
	ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
3982 3983

	if (strcmp(model[0], model[1])) {
3984 3985
		ata_dev_printk(dev, KERN_INFO, "model number mismatch "
			       "'%s' != '%s'\n", model[0], model[1]);
3986 3987 3988 3989
		return 0;
	}

	if (strcmp(serial[0], serial[1])) {
3990 3991
		ata_dev_printk(dev, KERN_INFO, "serial number mismatch "
			       "'%s' != '%s'\n", serial[0], serial[1]);
3992 3993 3994 3995 3996 3997 3998
		return 0;
	}

	return 1;
}

/**
3999
 *	ata_dev_reread_id - Re-read IDENTIFY data
H
Henrik Kretzschmar 已提交
4000
 *	@dev: target ATA device
4001
 *	@readid_flags: read ID flags
4002 4003 4004 4005 4006 4007 4008 4009 4010 4011
 *
 *	Re-read IDENTIFY page and make sure @dev is still attached to
 *	the port.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, negative errno otherwise
 */
4012
int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
4013
{
4014
	unsigned int class = dev->class;
T
Tejun Heo 已提交
4015
	u16 *id = (void *)dev->link->ap->sector_buf;
4016 4017
	int rc;

4018
	/* read ID data */
4019
	rc = ata_dev_read_id(dev, &class, readid_flags, id);
4020
	if (rc)
4021
		return rc;
4022 4023

	/* is the device still there? */
4024 4025
	if (!ata_dev_same_device(dev, class, id))
		return -ENODEV;
4026

4027
	memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
4028 4029 4030 4031 4032 4033
	return 0;
}

/**
 *	ata_dev_revalidate - Revalidate ATA device
 *	@dev: device to revalidate
4034
 *	@new_class: new class code
4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045
 *	@readid_flags: read ID flags
 *
 *	Re-read IDENTIFY page, make sure @dev is still attached to the
 *	port and reconfigure it according to the new IDENTIFY page.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, negative errno otherwise
 */
4046 4047
int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
		       unsigned int readid_flags)
4048
{
4049
	u64 n_sectors = dev->n_sectors;
4050 4051 4052 4053 4054
	int rc;

	if (!ata_dev_enabled(dev))
		return -ENODEV;

4055 4056 4057 4058 4059 4060 4061 4062 4063
	/* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
	if (ata_class_enabled(new_class) &&
	    new_class != ATA_DEV_ATA && new_class != ATA_DEV_ATAPI) {
		ata_dev_printk(dev, KERN_INFO, "class mismatch %u != %u\n",
			       dev->class, new_class);
		rc = -ENODEV;
		goto fail;
	}

4064 4065 4066 4067
	/* re-read ID */
	rc = ata_dev_reread_id(dev, readid_flags);
	if (rc)
		goto fail;
4068 4069

	/* configure device according to the new ID */
4070
	rc = ata_dev_configure(dev);
4071 4072 4073 4074
	if (rc)
		goto fail;

	/* verify n_sectors hasn't changed */
4075 4076
	if (dev->class == ATA_DEV_ATA && n_sectors &&
	    dev->n_sectors != n_sectors) {
4077 4078 4079 4080
		ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch "
			       "%llu != %llu\n",
			       (unsigned long long)n_sectors,
			       (unsigned long long)dev->n_sectors);
4081 4082 4083 4084

		/* restore original n_sectors */
		dev->n_sectors = n_sectors;

4085 4086 4087 4088 4089
		rc = -ENODEV;
		goto fail;
	}

	return 0;
4090 4091

 fail:
4092
	ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc);
4093 4094 4095
	return rc;
}

4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131
struct ata_blacklist_entry {
	const char *model_num;
	const char *model_rev;
	unsigned long horkage;
};

static const struct ata_blacklist_entry ata_device_blacklist [] = {
	/* Devices with DMA related problems under Linux */
	{ "WDC AC11000H",	NULL,		ATA_HORKAGE_NODMA },
	{ "WDC AC22100H",	NULL,		ATA_HORKAGE_NODMA },
	{ "WDC AC32500H",	NULL,		ATA_HORKAGE_NODMA },
	{ "WDC AC33100H",	NULL,		ATA_HORKAGE_NODMA },
	{ "WDC AC31600H",	NULL,		ATA_HORKAGE_NODMA },
	{ "WDC AC32100H",	"24.09P07",	ATA_HORKAGE_NODMA },
	{ "WDC AC23200L",	"21.10N21",	ATA_HORKAGE_NODMA },
	{ "Compaq CRD-8241B", 	NULL,		ATA_HORKAGE_NODMA },
	{ "CRD-8400B",		NULL, 		ATA_HORKAGE_NODMA },
	{ "CRD-8480B",		NULL,		ATA_HORKAGE_NODMA },
	{ "CRD-8482B",		NULL,		ATA_HORKAGE_NODMA },
	{ "CRD-84",		NULL,		ATA_HORKAGE_NODMA },
	{ "SanDisk SDP3B",	NULL,		ATA_HORKAGE_NODMA },
	{ "SanDisk SDP3B-64",	NULL,		ATA_HORKAGE_NODMA },
	{ "SANYO CD-ROM CRD",	NULL,		ATA_HORKAGE_NODMA },
	{ "HITACHI CDR-8",	NULL,		ATA_HORKAGE_NODMA },
	{ "HITACHI CDR-8335",	NULL,		ATA_HORKAGE_NODMA },
	{ "HITACHI CDR-8435",	NULL,		ATA_HORKAGE_NODMA },
	{ "Toshiba CD-ROM XM-6202B", NULL,	ATA_HORKAGE_NODMA },
	{ "TOSHIBA CD-ROM XM-1702BC", NULL,	ATA_HORKAGE_NODMA },
	{ "CD-532E-A", 		NULL,		ATA_HORKAGE_NODMA },
	{ "E-IDE CD-ROM CR-840",NULL,		ATA_HORKAGE_NODMA },
	{ "CD-ROM Drive/F5A",	NULL,		ATA_HORKAGE_NODMA },
	{ "WPI CDD-820", 	NULL,		ATA_HORKAGE_NODMA },
	{ "SAMSUNG CD-ROM SC-148C", NULL,	ATA_HORKAGE_NODMA },
	{ "SAMSUNG CD-ROM SC",	NULL,		ATA_HORKAGE_NODMA },
	{ "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
	{ "_NEC DV5800A", 	NULL,		ATA_HORKAGE_NODMA },
4132
	{ "SAMSUNG CD-ROM SN-124", "N001",	ATA_HORKAGE_NODMA },
4133
	{ "Seagate STT20000A", NULL,		ATA_HORKAGE_NODMA },
4134 4135 4136
	/* Odd clown on sil3726/4726 PMPs */
	{ "Config  Disk",	NULL,		ATA_HORKAGE_NODMA |
						ATA_HORKAGE_SKIP_PM },
4137

4138
	/* Weird ATAPI devices */
T
Tejun Heo 已提交
4139
	{ "TORiSAN DVD-ROM DRD-N216", NULL,	ATA_HORKAGE_MAX_SEC_128 },
4140

4141 4142 4143 4144
	/* Devices we expect to fail diagnostics */

	/* Devices where NCQ should be avoided */
	/* NCQ is slow */
4145
	{ "WDC WD740ADFD-00",	NULL,		ATA_HORKAGE_NONCQ },
4146
	{ "WDC WD740ADFD-00NLR1", NULL,		ATA_HORKAGE_NONCQ, },
4147 4148
	/* http://thread.gmane.org/gmane.linux.ide/14907 */
	{ "FUJITSU MHT2060BH",	NULL,		ATA_HORKAGE_NONCQ },
4149
	/* NCQ is broken */
4150
	{ "Maxtor *",		"BANC*",	ATA_HORKAGE_NONCQ },
4151
	{ "Maxtor 7V300F0",	"VA111630",	ATA_HORKAGE_NONCQ },
4152 4153
	{ "HITACHI HDS7250SASUN500G*", NULL,    ATA_HORKAGE_NONCQ },
	{ "HITACHI HDS7225SBSUN250G*", NULL,    ATA_HORKAGE_NONCQ },
4154
	{ "ST380817AS",		"3.42",		ATA_HORKAGE_NONCQ },
4155
	{ "ST3160023AS",	"3.42",		ATA_HORKAGE_NONCQ },
4156

4157 4158 4159 4160 4161
	/* Blacklist entries taken from Silicon Image 3124/3132
	   Windows driver .inf file - also several Linux problem reports */
	{ "HTS541060G9SA00",    "MB3OC60D",     ATA_HORKAGE_NONCQ, },
	{ "HTS541080G9SA00",    "MB4OC60D",     ATA_HORKAGE_NONCQ, },
	{ "HTS541010G9SA00",    "MBZOC60D",     ATA_HORKAGE_NONCQ, },
4162

4163 4164 4165 4166 4167
	/* devices which puke on READ_NATIVE_MAX */
	{ "HDS724040KLSA80",	"KFAOA20N",	ATA_HORKAGE_BROKEN_HPA, },
	{ "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
	{ "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
	{ "MAXTOR 6L080L4",	"A93.0500",	ATA_HORKAGE_BROKEN_HPA },
4168

4169 4170 4171 4172
	/* Devices which report 1 sector over size HPA */
	{ "ST340823A",		NULL,		ATA_HORKAGE_HPA_SIZE, },
	{ "ST320413A",		NULL,		ATA_HORKAGE_HPA_SIZE, },

A
Alan Cox 已提交
4173 4174 4175
	/* Devices which get the IVB wrong */
	{ "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, },
	{ "TSSTcorp CDDVDW SH-S202J", "SB00",	  ATA_HORKAGE_IVB, },
P
Peter Missel 已提交
4176 4177 4178
	{ "TSSTcorp CDDVDW SH-S202J", "SB01",	  ATA_HORKAGE_IVB, },
	{ "TSSTcorp CDDVDW SH-S202N", "SB00",	  ATA_HORKAGE_IVB, },
	{ "TSSTcorp CDDVDW SH-S202N", "SB01",	  ATA_HORKAGE_IVB, },
A
Alan Cox 已提交
4179

4180 4181
	/* End Marker */
	{ }
L
Linus Torvalds 已提交
4182
};
4183

4184
static int strn_pattern_cmp(const char *patt, const char *name, int wildchar)
4185 4186 4187 4188 4189 4190 4191 4192 4193 4194
{
	const char *p;
	int len;

	/*
	 * check for trailing wildcard: *\0
	 */
	p = strchr(patt, wildchar);
	if (p && ((*(p + 1)) == 0))
		len = p - patt;
4195
	else {
4196
		len = strlen(name);
4197 4198 4199 4200 4201 4202
		if (!len) {
			if (!*patt)
				return 0;
			return -1;
		}
	}
4203 4204 4205 4206

	return strncmp(patt, name, len);
}

T
Tejun Heo 已提交
4207
static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
L
Linus Torvalds 已提交
4208
{
T
Tejun Heo 已提交
4209 4210
	unsigned char model_num[ATA_ID_PROD_LEN + 1];
	unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
4211
	const struct ata_blacklist_entry *ad = ata_device_blacklist;
4212

T
Tejun Heo 已提交
4213 4214
	ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
	ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
L
Linus Torvalds 已提交
4215

4216
	while (ad->model_num) {
4217
		if (!strn_pattern_cmp(ad->model_num, model_num, '*')) {
4218 4219
			if (ad->model_rev == NULL)
				return ad->horkage;
4220
			if (!strn_pattern_cmp(ad->model_rev, model_rev, '*'))
4221
				return ad->horkage;
4222
		}
4223
		ad++;
4224
	}
L
Linus Torvalds 已提交
4225 4226 4227
	return 0;
}

4228 4229 4230 4231 4232 4233
static int ata_dma_blacklisted(const struct ata_device *dev)
{
	/* We don't support polling DMA.
	 * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
	 * if the LLDD handles only interrupts in the HSM_ST_LAST state.
	 */
T
Tejun Heo 已提交
4234
	if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
4235 4236
	    (dev->flags & ATA_DFLAG_CDB_INTR))
		return 1;
T
Tejun Heo 已提交
4237
	return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
4238 4239
}

A
Alan Cox 已提交
4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254
/**
 *	ata_is_40wire		-	check drive side detection
 *	@dev: device
 *
 *	Perform drive side detection decoding, allowing for device vendors
 *	who can't follow the documentation.
 */

static int ata_is_40wire(struct ata_device *dev)
{
	if (dev->horkage & ATA_HORKAGE_IVB)
		return ata_drive_40wire_relaxed(dev->id);
	return ata_drive_40wire(dev->id);
}

4255 4256 4257 4258
/**
 *	ata_dev_xfermask - Compute supported xfermask of the given device
 *	@dev: Device to compute xfermask for
 *
4259 4260 4261 4262
 *	Compute supported xfermask of @dev and store it in
 *	dev->*_mask.  This function is responsible for applying all
 *	known limits including host controller limits, device
 *	blacklist, etc...
4263 4264 4265 4266
 *
 *	LOCKING:
 *	None.
 */
T
Tejun Heo 已提交
4267
static void ata_dev_xfermask(struct ata_device *dev)
L
Linus Torvalds 已提交
4268
{
T
Tejun Heo 已提交
4269 4270
	struct ata_link *link = dev->link;
	struct ata_port *ap = link->ap;
J
Jeff Garzik 已提交
4271
	struct ata_host *host = ap->host;
4272
	unsigned long xfer_mask;
L
Linus Torvalds 已提交
4273

4274
	/* controller modes available */
4275 4276 4277
	xfer_mask = ata_pack_xfermask(ap->pio_mask,
				      ap->mwdma_mask, ap->udma_mask);

4278
	/* drive modes available */
4279 4280 4281
	xfer_mask &= ata_pack_xfermask(dev->pio_mask,
				       dev->mwdma_mask, dev->udma_mask);
	xfer_mask &= ata_id_xfermask(dev->id);
4282

4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293
	/*
	 *	CFA Advanced TrueIDE timings are not allowed on a shared
	 *	cable
	 */
	if (ata_dev_pair(dev)) {
		/* No PIO5 or PIO6 */
		xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
		/* No MWDMA3 or MWDMA 4 */
		xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
	}

4294 4295
	if (ata_dma_blacklisted(dev)) {
		xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4296 4297
		ata_dev_printk(dev, KERN_WARNING,
			       "device is on DMA blacklist, disabling DMA\n");
4298
	}
4299

4300
	if ((host->flags & ATA_HOST_SIMPLEX) &&
4301
	    host->simplex_claimed && host->simplex_claimed != ap) {
4302 4303 4304
		xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
		ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by "
			       "other device, disabling DMA\n");
4305
	}
4306

J
Jeff Garzik 已提交
4307 4308 4309
	if (ap->flags & ATA_FLAG_NO_IORDY)
		xfer_mask &= ata_pio_mask_no_iordy(dev);

4310
	if (ap->ops->mode_filter)
4311
		xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
4312

4313 4314 4315 4316 4317 4318 4319 4320 4321 4322
	/* Apply cable rule here.  Don't apply it early because when
	 * we handle hot plug the cable type can itself change.
	 * Check this last so that we know if the transfer rate was
	 * solely limited by the cable.
	 * Unknown or 80 wire cables reported host side are checked
	 * drive side as well. Cases where we know a 40wire cable
	 * is used safely for 80 are not checked here.
	 */
	if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
		/* UDMA/44 or higher would be available */
4323
		if ((ap->cbl == ATA_CBL_PATA40) ||
A
Alan Cox 已提交
4324
		    (ata_is_40wire(dev) &&
4325 4326 4327
		    (ap->cbl == ATA_CBL_PATA_UNK ||
		     ap->cbl == ATA_CBL_PATA80))) {
			ata_dev_printk(dev, KERN_WARNING,
4328 4329 4330 4331
				 "limited to UDMA/33 due to 40-wire cable\n");
			xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
		}

4332 4333
	ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
			    &dev->mwdma_mask, &dev->udma_mask);
L
Linus Torvalds 已提交
4334 4335 4336 4337 4338 4339
}

/**
 *	ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
 *	@dev: Device to which command will be sent
 *
J
Jeff Garzik 已提交
4340 4341 4342
 *	Issue SET FEATURES - XFER MODE command to device @dev
 *	on port @ap.
 *
L
Linus Torvalds 已提交
4343
 *	LOCKING:
J
Jeff Garzik 已提交
4344
 *	PCI/etc. bus probe sem.
4345 4346 4347
 *
 *	RETURNS:
 *	0 on success, AC_ERR_* mask otherwise.
L
Linus Torvalds 已提交
4348 4349
 */

T
Tejun Heo 已提交
4350
static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
L
Linus Torvalds 已提交
4351
{
4352
	struct ata_taskfile tf;
4353
	unsigned int err_mask;
L
Linus Torvalds 已提交
4354 4355 4356 4357

	/* set up set-features taskfile */
	DPRINTK("set features - xfer mode\n");

T
Tejun Heo 已提交
4358 4359 4360
	/* Some controllers and ATAPI devices show flaky interrupt
	 * behavior after setting xfer mode.  Use polling instead.
	 */
T
Tejun Heo 已提交
4361
	ata_tf_init(dev, &tf);
4362 4363
	tf.command = ATA_CMD_SET_FEATURES;
	tf.feature = SETFEATURES_XFER;
T
Tejun Heo 已提交
4364
	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING;
4365 4366
	tf.protocol = ATA_PROT_NODATA;
	tf.nsect = dev->xfer_mode;
L
Linus Torvalds 已提交
4367

4368
	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
4369 4370 4371 4372 4373

	DPRINTK("EXIT, err_mask=%x\n", err_mask);
	return err_mask;
}
/**
4374
 *	ata_dev_set_feature - Issue SET FEATURES - SATA FEATURES
4375 4376
 *	@dev: Device to which command will be sent
 *	@enable: Whether to enable or disable the feature
4377
 *	@feature: The sector count represents the feature to set
4378 4379
 *
 *	Issue SET FEATURES - SATA FEATURES command to device @dev
4380
 *	on port @ap with sector count
4381 4382 4383 4384 4385 4386 4387
 *
 *	LOCKING:
 *	PCI/etc. bus probe sem.
 *
 *	RETURNS:
 *	0 on success, AC_ERR_* mask otherwise.
 */
4388 4389
static unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable,
					u8 feature)
4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401
{
	struct ata_taskfile tf;
	unsigned int err_mask;

	/* set up set-features taskfile */
	DPRINTK("set features - SATA features\n");

	ata_tf_init(dev, &tf);
	tf.command = ATA_CMD_SET_FEATURES;
	tf.feature = enable;
	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
	tf.protocol = ATA_PROT_NODATA;
4402
	tf.nsect = feature;
4403

4404
	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
L
Linus Torvalds 已提交
4405

4406 4407
	DPRINTK("EXIT, err_mask=%x\n", err_mask);
	return err_mask;
L
Linus Torvalds 已提交
4408 4409
}

4410 4411 4412
/**
 *	ata_dev_init_params - Issue INIT DEV PARAMS command
 *	@dev: Device to which command will be sent
4413 4414
 *	@heads: Number of heads (taskfile parameter)
 *	@sectors: Number of sectors (taskfile parameter)
4415 4416
 *
 *	LOCKING:
4417 4418 4419 4420
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, AC_ERR_* mask otherwise.
4421
 */
T
Tejun Heo 已提交
4422 4423
static unsigned int ata_dev_init_params(struct ata_device *dev,
					u16 heads, u16 sectors)
4424
{
4425
	struct ata_taskfile tf;
4426
	unsigned int err_mask;
4427 4428 4429

	/* Number of sectors per track 1-255. Number of heads 1-16 */
	if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
4430
		return AC_ERR_INVALID;
4431 4432 4433 4434

	/* set up init dev params taskfile */
	DPRINTK("init dev params \n");

T
Tejun Heo 已提交
4435
	ata_tf_init(dev, &tf);
4436 4437 4438 4439 4440
	tf.command = ATA_CMD_INIT_DEV_PARAMS;
	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
	tf.protocol = ATA_PROT_NODATA;
	tf.nsect = sectors;
	tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
4441

4442
	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
4443 4444 4445 4446 4447
	/* A clean abort indicates an original or just out of spec drive
	   and we should continue as we issue the setup based on the
	   drive reported working geometry */
	if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
		err_mask = 0;
4448

4449 4450
	DPRINTK("EXIT, err_mask=%x\n", err_mask);
	return err_mask;
4451 4452
}

L
Linus Torvalds 已提交
4453
/**
J
Jeff Garzik 已提交
4454 4455 4456 4457
 *	ata_sg_clean - Unmap DMA memory associated with command
 *	@qc: Command containing DMA memory to be released
 *
 *	Unmap all mapped DMA memory associated with this command.
L
Linus Torvalds 已提交
4458 4459
 *
 *	LOCKING:
J
Jeff Garzik 已提交
4460
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
4461
 */
4462
void ata_sg_clean(struct ata_queued_cmd *qc)
L
Linus Torvalds 已提交
4463 4464
{
	struct ata_port *ap = qc->ap;
4465
	struct scatterlist *sg = qc->__sg;
L
Linus Torvalds 已提交
4466
	int dir = qc->dma_dir;
4467
	void *pad_buf = NULL;
L
Linus Torvalds 已提交
4468

4469 4470
	WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
	WARN_ON(sg == NULL);
L
Linus Torvalds 已提交
4471 4472

	if (qc->flags & ATA_QCFLAG_SINGLE)
J
Jeff Garzik 已提交
4473
		WARN_ON(qc->n_elem > 1);
L
Linus Torvalds 已提交
4474

J
Jeff Garzik 已提交
4475
	VPRINTK("unmapping %u sg elements\n", qc->n_elem);
L
Linus Torvalds 已提交
4476

4477 4478 4479 4480 4481 4482 4483 4484
	/* if we padded the buffer out to 32-bit bound, and data
	 * xfer direction is from-device, we must copy from the
	 * pad buffer back into the supplied buffer
	 */
	if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
		pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);

	if (qc->flags & ATA_QCFLAG_SG) {
4485
		if (qc->n_elem)
4486
			dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
4487
		/* restore last sg */
J
Jens Axboe 已提交
4488
		sg_last(sg, qc->orig_n_elem)->length += qc->pad_len;
4489 4490
		if (pad_buf) {
			struct scatterlist *psg = &qc->pad_sgent;
J
Jens Axboe 已提交
4491
			void *addr = kmap_atomic(sg_page(psg), KM_IRQ0);
4492
			memcpy(addr + psg->offset, pad_buf, qc->pad_len);
4493
			kunmap_atomic(addr, KM_IRQ0);
4494 4495
		}
	} else {
4496
		if (qc->n_elem)
4497
			dma_unmap_single(ap->dev,
4498 4499
				sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
				dir);
4500 4501 4502 4503 4504 4505
		/* restore sg */
		sg->length += qc->pad_len;
		if (pad_buf)
			memcpy(qc->buf_virt + sg->length - qc->pad_len,
			       pad_buf, qc->pad_len);
	}
L
Linus Torvalds 已提交
4506 4507

	qc->flags &= ~ATA_QCFLAG_DMAMAP;
4508
	qc->__sg = NULL;
L
Linus Torvalds 已提交
4509 4510 4511 4512 4513 4514
}

/**
 *	ata_fill_sg - Fill PCI IDE PRD table
 *	@qc: Metadata associated with taskfile to be transferred
 *
J
Jeff Garzik 已提交
4515 4516 4517
 *	Fill PCI IDE PRD (scatter-gather) table with segments
 *	associated with the current disk command.
 *
L
Linus Torvalds 已提交
4518
 *	LOCKING:
J
Jeff Garzik 已提交
4519
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
4520 4521 4522 4523 4524
 *
 */
static void ata_fill_sg(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
4525 4526
	struct scatterlist *sg;
	unsigned int idx;
L
Linus Torvalds 已提交
4527

4528
	WARN_ON(qc->__sg == NULL);
J
Jeff Garzik 已提交
4529
	WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
L
Linus Torvalds 已提交
4530 4531

	idx = 0;
4532
	ata_for_each_sg(sg, qc) {
L
Linus Torvalds 已提交
4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561
		u32 addr, offset;
		u32 sg_len, len;

		/* determine if physical DMA addr spans 64K boundary.
		 * Note h/w doesn't support 64-bit, so we unconditionally
		 * truncate dma_addr_t to u32.
		 */
		addr = (u32) sg_dma_address(sg);
		sg_len = sg_dma_len(sg);

		while (sg_len) {
			offset = addr & 0xffff;
			len = sg_len;
			if ((offset + sg_len) > 0x10000)
				len = 0x10000 - offset;

			ap->prd[idx].addr = cpu_to_le32(addr);
			ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
			VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);

			idx++;
			sg_len -= len;
			addr += len;
		}
	}

	if (idx)
		ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
}
4562

4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589
/**
 *	ata_fill_sg_dumb - Fill PCI IDE PRD table
 *	@qc: Metadata associated with taskfile to be transferred
 *
 *	Fill PCI IDE PRD (scatter-gather) table with segments
 *	associated with the current disk command. Perform the fill
 *	so that we avoid writing any length 64K records for
 *	controllers that don't follow the spec.
 *
 *	LOCKING:
 *	spin_lock_irqsave(host lock)
 *
 */
static void ata_fill_sg_dumb(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	struct scatterlist *sg;
	unsigned int idx;

	WARN_ON(qc->__sg == NULL);
	WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);

	idx = 0;
	ata_for_each_sg(sg, qc) {
		u32 addr, offset;
		u32 sg_len, len, blen;

4590
		/* determine if physical DMA addr spans 64K boundary.
4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624
		 * Note h/w doesn't support 64-bit, so we unconditionally
		 * truncate dma_addr_t to u32.
		 */
		addr = (u32) sg_dma_address(sg);
		sg_len = sg_dma_len(sg);

		while (sg_len) {
			offset = addr & 0xffff;
			len = sg_len;
			if ((offset + sg_len) > 0x10000)
				len = 0x10000 - offset;

			blen = len & 0xffff;
			ap->prd[idx].addr = cpu_to_le32(addr);
			if (blen == 0) {
			   /* Some PATA chipsets like the CS5530 can't
			      cope with 0x0000 meaning 64K as the spec says */
				ap->prd[idx].flags_len = cpu_to_le32(0x8000);
				blen = 0x8000;
				ap->prd[++idx].addr = cpu_to_le32(addr + 0x8000);
			}
			ap->prd[idx].flags_len = cpu_to_le32(blen);
			VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);

			idx++;
			sg_len -= len;
			addr += len;
		}
	}

	if (idx)
		ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
}

L
Linus Torvalds 已提交
4625 4626 4627 4628
/**
 *	ata_check_atapi_dma - Check whether ATAPI DMA can be supported
 *	@qc: Metadata associated with taskfile to check
 *
J
Jeff Garzik 已提交
4629 4630 4631 4632
 *	Allow low-level driver to filter ATA PACKET commands, returning
 *	a status indicating whether or not it is OK to use DMA for the
 *	supplied PACKET command.
 *
L
Linus Torvalds 已提交
4633
 *	LOCKING:
J
Jeff Garzik 已提交
4634
 *	spin_lock_irqsave(host lock)
J
Jeff Garzik 已提交
4635
 *
L
Linus Torvalds 已提交
4636 4637 4638 4639 4640 4641
 *	RETURNS: 0 when ATAPI DMA can be used
 *               nonzero otherwise
 */
int ata_check_atapi_dma(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
4642 4643 4644 4645 4646 4647

	/* Don't allow DMA if it isn't multiple of 16 bytes.  Quite a
	 * few ATAPI devices choke on such DMA requests.
	 */
	if (unlikely(qc->nbytes & 15))
		return 1;
4648

L
Linus Torvalds 已提交
4649
	if (ap->ops->check_atapi_dma)
4650
		return ap->ops->check_atapi_dma(qc);
L
Linus Torvalds 已提交
4651

4652
	return 0;
L
Linus Torvalds 已提交
4653
}
4654

T
Tejun Heo 已提交
4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691
/**
 *	atapi_qc_may_overflow - Check whether data transfer may overflow
 *	@qc: ATA command in question
 *
 *	ATAPI commands which transfer variable length data to host
 *	might overflow due to application error or hardare bug.  This
 *	function checks whether overflow should be drained and ignored
 *	for @qc.
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	1 if @qc may overflow; otherwise, 0.
 */
static int atapi_qc_may_overflow(struct ata_queued_cmd *qc)
{
	if (qc->tf.protocol != ATA_PROT_ATAPI &&
	    qc->tf.protocol != ATA_PROT_ATAPI_DMA)
		return 0;

	if (qc->tf.flags & ATA_TFLAG_WRITE)
		return 0;

	switch (qc->cdb[0]) {
	case READ_10:
	case READ_12:
	case WRITE_10:
	case WRITE_12:
	case GPCMD_READ_CD:
	case GPCMD_READ_CD_MSF:
		return 0;
	}

	return 1;
}

4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721
/**
 *	ata_std_qc_defer - Check whether a qc needs to be deferred
 *	@qc: ATA command in question
 *
 *	Non-NCQ commands cannot run with any other command, NCQ or
 *	not.  As upper layer only knows the queue depth, we are
 *	responsible for maintaining exclusion.  This function checks
 *	whether a new command @qc can be issued.
 *
 *	LOCKING:
 *	spin_lock_irqsave(host lock)
 *
 *	RETURNS:
 *	ATA_DEFER_* if deferring is needed, 0 otherwise.
 */
int ata_std_qc_defer(struct ata_queued_cmd *qc)
{
	struct ata_link *link = qc->dev->link;

	if (qc->tf.protocol == ATA_PROT_NCQ) {
		if (!ata_tag_valid(link->active_tag))
			return 0;
	} else {
		if (!ata_tag_valid(link->active_tag) && !link->sactive)
			return 0;
	}

	return ATA_DEFER_LINK;
}

L
Linus Torvalds 已提交
4722 4723 4724 4725
/**
 *	ata_qc_prep - Prepare taskfile for submission
 *	@qc: Metadata associated with taskfile to be prepared
 *
J
Jeff Garzik 已提交
4726 4727
 *	Prepare ATA taskfile for submission.
 *
L
Linus Torvalds 已提交
4728
 *	LOCKING:
J
Jeff Garzik 已提交
4729
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
4730 4731 4732 4733 4734 4735 4736 4737 4738
 */
void ata_qc_prep(struct ata_queued_cmd *qc)
{
	if (!(qc->flags & ATA_QCFLAG_DMAMAP))
		return;

	ata_fill_sg(qc);
}

4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755
/**
 *	ata_dumb_qc_prep - Prepare taskfile for submission
 *	@qc: Metadata associated with taskfile to be prepared
 *
 *	Prepare ATA taskfile for submission.
 *
 *	LOCKING:
 *	spin_lock_irqsave(host lock)
 */
void ata_dumb_qc_prep(struct ata_queued_cmd *qc)
{
	if (!(qc->flags & ATA_QCFLAG_DMAMAP))
		return;

	ata_fill_sg_dumb(qc);
}

4756 4757
void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }

J
Jeff Garzik 已提交
4758 4759 4760 4761 4762 4763 4764 4765 4766 4767
/**
 *	ata_sg_init_one - Associate command with memory buffer
 *	@qc: Command to be associated
 *	@buf: Memory buffer
 *	@buflen: Length of memory buffer, in bytes.
 *
 *	Initialize the data-related elements of queued_cmd @qc
 *	to point to a single memory buffer, @buf of byte length @buflen.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
4768
 *	spin_lock_irqsave(host lock)
J
Jeff Garzik 已提交
4769 4770
 */

L
Linus Torvalds 已提交
4771 4772 4773 4774
void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
{
	qc->flags |= ATA_QCFLAG_SINGLE;

4775
	qc->__sg = &qc->sgent;
L
Linus Torvalds 已提交
4776
	qc->n_elem = 1;
4777
	qc->orig_n_elem = 1;
L
Linus Torvalds 已提交
4778
	qc->buf_virt = buf;
4779
	qc->nbytes = buflen;
J
Jens Axboe 已提交
4780
	qc->cursg = qc->__sg;
L
Linus Torvalds 已提交
4781

4782
	sg_init_one(&qc->sgent, buf, buflen);
L
Linus Torvalds 已提交
4783 4784
}

J
Jeff Garzik 已提交
4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795
/**
 *	ata_sg_init - Associate command with scatter-gather table.
 *	@qc: Command to be associated
 *	@sg: Scatter-gather table.
 *	@n_elem: Number of elements in s/g table.
 *
 *	Initialize the data-related elements of queued_cmd @qc
 *	to point to a scatter-gather table @sg, containing @n_elem
 *	elements.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
4796
 *	spin_lock_irqsave(host lock)
J
Jeff Garzik 已提交
4797 4798
 */

L
Linus Torvalds 已提交
4799 4800 4801 4802
void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
		 unsigned int n_elem)
{
	qc->flags |= ATA_QCFLAG_SG;
4803
	qc->__sg = sg;
L
Linus Torvalds 已提交
4804
	qc->n_elem = n_elem;
4805
	qc->orig_n_elem = n_elem;
J
Jens Axboe 已提交
4806
	qc->cursg = qc->__sg;
L
Linus Torvalds 已提交
4807 4808 4809
}

/**
J
Jeff Garzik 已提交
4810 4811 4812 4813
 *	ata_sg_setup_one - DMA-map the memory buffer associated with a command.
 *	@qc: Command with memory buffer to be mapped.
 *
 *	DMA-map the memory buffer associated with queued_cmd @qc.
L
Linus Torvalds 已提交
4814 4815
 *
 *	LOCKING:
J
Jeff Garzik 已提交
4816
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
4817 4818
 *
 *	RETURNS:
J
Jeff Garzik 已提交
4819
 *	Zero on success, negative on error.
L
Linus Torvalds 已提交
4820 4821 4822 4823 4824 4825
 */

static int ata_sg_setup_one(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	int dir = qc->dma_dir;
4826
	struct scatterlist *sg = qc->__sg;
L
Linus Torvalds 已提交
4827
	dma_addr_t dma_address;
4828
	int trim_sg = 0;
L
Linus Torvalds 已提交
4829

4830 4831 4832 4833 4834 4835
	/* we must lengthen transfers to end on a 32-bit boundary */
	qc->pad_len = sg->length & 3;
	if (qc->pad_len) {
		void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
		struct scatterlist *psg = &qc->pad_sgent;

4836
		WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847

		memset(pad_buf, 0, ATA_DMA_PAD_SZ);

		if (qc->tf.flags & ATA_TFLAG_WRITE)
			memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
			       qc->pad_len);

		sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
		sg_dma_len(psg) = ATA_DMA_PAD_SZ;
		/* trim sg */
		sg->length -= qc->pad_len;
4848 4849
		if (sg->length == 0)
			trim_sg = 1;
4850 4851 4852 4853 4854

		DPRINTK("padding done, sg->length=%u pad_len=%u\n",
			sg->length, qc->pad_len);
	}

4855 4856
	if (trim_sg) {
		qc->n_elem--;
4857 4858 4859
		goto skip_map;
	}

4860
	dma_address = dma_map_single(ap->dev, qc->buf_virt,
4861
				     sg->length, dir);
4862 4863 4864
	if (dma_mapping_error(dma_address)) {
		/* restore sg */
		sg->length += qc->pad_len;
L
Linus Torvalds 已提交
4865
		return -1;
4866
	}
L
Linus Torvalds 已提交
4867 4868

	sg_dma_address(sg) = dma_address;
4869
	sg_dma_len(sg) = sg->length;
L
Linus Torvalds 已提交
4870

4871
skip_map:
L
Linus Torvalds 已提交
4872 4873 4874 4875 4876 4877 4878
	DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
		qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");

	return 0;
}

/**
J
Jeff Garzik 已提交
4879 4880 4881 4882
 *	ata_sg_setup - DMA-map the scatter-gather table associated with a command.
 *	@qc: Command with scatter-gather table to be mapped.
 *
 *	DMA-map the scatter-gather table associated with queued_cmd @qc.
L
Linus Torvalds 已提交
4883 4884
 *
 *	LOCKING:
J
Jeff Garzik 已提交
4885
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
4886 4887
 *
 *	RETURNS:
J
Jeff Garzik 已提交
4888
 *	Zero on success, negative on error.
L
Linus Torvalds 已提交
4889 4890 4891 4892 4893 4894
 *
 */

static int ata_sg_setup(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
4895
	struct scatterlist *sg = qc->__sg;
J
Jens Axboe 已提交
4896
	struct scatterlist *lsg = sg_last(qc->__sg, qc->n_elem);
4897
	int n_elem, pre_n_elem, dir, trim_sg = 0;
L
Linus Torvalds 已提交
4898

T
Tejun Heo 已提交
4899
	VPRINTK("ENTER, ata%u\n", ap->print_id);
4900
	WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
L
Linus Torvalds 已提交
4901

4902 4903 4904 4905 4906 4907 4908
	/* we must lengthen transfers to end on a 32-bit boundary */
	qc->pad_len = lsg->length & 3;
	if (qc->pad_len) {
		void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
		struct scatterlist *psg = &qc->pad_sgent;
		unsigned int offset;

4909
		WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
4910 4911 4912 4913 4914 4915 4916 4917

		memset(pad_buf, 0, ATA_DMA_PAD_SZ);

		/*
		 * psg->page/offset are used to copy to-be-written
		 * data in this function or read data in ata_sg_clean.
		 */
		offset = lsg->offset + lsg->length - qc->pad_len;
4918
		sg_init_table(psg, 1);
4919 4920
		sg_set_page(psg, nth_page(sg_page(lsg), offset >> PAGE_SHIFT),
				qc->pad_len, offset_in_page(offset));
4921 4922

		if (qc->tf.flags & ATA_TFLAG_WRITE) {
J
Jens Axboe 已提交
4923
			void *addr = kmap_atomic(sg_page(psg), KM_IRQ0);
4924
			memcpy(pad_buf, addr + psg->offset, qc->pad_len);
4925
			kunmap_atomic(addr, KM_IRQ0);
4926 4927 4928 4929 4930 4931
		}

		sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
		sg_dma_len(psg) = ATA_DMA_PAD_SZ;
		/* trim last sg */
		lsg->length -= qc->pad_len;
4932 4933
		if (lsg->length == 0)
			trim_sg = 1;
4934 4935 4936 4937 4938

		DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
			qc->n_elem - 1, lsg->length, qc->pad_len);
	}

4939 4940 4941 4942 4943 4944 4945 4946 4947
	pre_n_elem = qc->n_elem;
	if (trim_sg && pre_n_elem)
		pre_n_elem--;

	if (!pre_n_elem) {
		n_elem = 0;
		goto skip_map;
	}

L
Linus Torvalds 已提交
4948
	dir = qc->dma_dir;
4949
	n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
4950 4951 4952
	if (n_elem < 1) {
		/* restore last sg */
		lsg->length += qc->pad_len;
L
Linus Torvalds 已提交
4953
		return -1;
4954
	}
L
Linus Torvalds 已提交
4955 4956 4957

	DPRINTK("%d sg elements mapped\n", n_elem);

4958
skip_map:
L
Linus Torvalds 已提交
4959 4960 4961 4962 4963
	qc->n_elem = n_elem;

	return 0;
}

E
Edward Falk 已提交
4964
/**
4965
 *	swap_buf_le16 - swap halves of 16-bit words in place
E
Edward Falk 已提交
4966 4967 4968 4969 4970 4971 4972 4973
 *	@buf:  Buffer to swap
 *	@buf_words:  Number of 16-bit words in buffer.
 *
 *	Swap halves of 16-bit words if needed to convert from
 *	little-endian byte order to native cpu byte order, or
 *	vice-versa.
 *
 *	LOCKING:
R
Randy Dunlap 已提交
4974
 *	Inherited from caller.
E
Edward Falk 已提交
4975
 */
L
Linus Torvalds 已提交
4976 4977 4978 4979 4980 4981 4982 4983 4984 4985
void swap_buf_le16(u16 *buf, unsigned int buf_words)
{
#ifdef __BIG_ENDIAN
	unsigned int i;

	for (i = 0; i < buf_words; i++)
		buf[i] = le16_to_cpu(buf[i]);
#endif /* __BIG_ENDIAN */
}

A
Albert Lee 已提交
4986
/**
T
Tejun Heo 已提交
4987
 *	ata_data_xfer - Transfer data by PIO
4988
 *	@adev: device to target
A
Albert Lee 已提交
4989 4990
 *	@buf: data buffer
 *	@buflen: buffer length
4991
 *	@write_data: read/write
A
Albert Lee 已提交
4992 4993 4994 4995 4996 4997
 *
 *	Transfer data from/to the device data register by PIO.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
T
Tejun Heo 已提交
4998 4999
void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
		   unsigned int buflen, int write_data)
L
Linus Torvalds 已提交
5000
{
T
Tejun Heo 已提交
5001
	struct ata_port *ap = adev->link->ap;
A
Albert Lee 已提交
5002
	unsigned int words = buflen >> 1;
L
Linus Torvalds 已提交
5003

A
Albert Lee 已提交
5004
	/* Transfer multiple of 2 bytes */
L
Linus Torvalds 已提交
5005
	if (write_data)
T
Tejun Heo 已提交
5006
		iowrite16_rep(ap->ioaddr.data_addr, buf, words);
L
Linus Torvalds 已提交
5007
	else
T
Tejun Heo 已提交
5008
		ioread16_rep(ap->ioaddr.data_addr, buf, words);
A
Albert Lee 已提交
5009 5010 5011 5012 5013 5014 5015 5016

	/* Transfer trailing 1 byte, if any. */
	if (unlikely(buflen & 0x01)) {
		u16 align_buf[1] = { 0 };
		unsigned char *trailing_buf = buf + buflen - 1;

		if (write_data) {
			memcpy(align_buf, trailing_buf, 1);
T
Tejun Heo 已提交
5017
			iowrite16(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
A
Albert Lee 已提交
5018
		} else {
T
Tejun Heo 已提交
5019
			align_buf[0] = cpu_to_le16(ioread16(ap->ioaddr.data_addr));
A
Albert Lee 已提交
5020 5021 5022
			memcpy(trailing_buf, align_buf, 1);
		}
	}
L
Linus Torvalds 已提交
5023 5024
}

5025
/**
T
Tejun Heo 已提交
5026
 *	ata_data_xfer_noirq - Transfer data by PIO
5027 5028 5029 5030 5031
 *	@adev: device to target
 *	@buf: data buffer
 *	@buflen: buffer length
 *	@write_data: read/write
 *
T
Tejun Heo 已提交
5032
 *	Transfer data from/to the device data register by PIO. Do the
5033 5034 5035 5036 5037
 *	transfer with interrupts disabled.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
T
Tejun Heo 已提交
5038 5039
void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
			 unsigned int buflen, int write_data)
5040 5041 5042
{
	unsigned long flags;
	local_irq_save(flags);
T
Tejun Heo 已提交
5043
	ata_data_xfer(adev, buf, buflen, write_data);
5044 5045 5046 5047
	local_irq_restore(flags);
}


A
Albert Lee 已提交
5048
/**
5049
 *	ata_pio_sector - Transfer a sector of data.
A
Albert Lee 已提交
5050 5051
 *	@qc: Command on going
 *
5052
 *	Transfer qc->sect_size bytes of data from/to the ATA device.
A
Albert Lee 已提交
5053 5054 5055 5056 5057
 *
 *	LOCKING:
 *	Inherited from caller.
 */

L
Linus Torvalds 已提交
5058 5059 5060 5061 5062 5063 5064 5065
static void ata_pio_sector(struct ata_queued_cmd *qc)
{
	int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
	struct ata_port *ap = qc->ap;
	struct page *page;
	unsigned int offset;
	unsigned char *buf;

5066
	if (qc->curbytes == qc->nbytes - qc->sect_size)
A
Albert Lee 已提交
5067
		ap->hsm_task_state = HSM_ST_LAST;
L
Linus Torvalds 已提交
5068

J
Jens Axboe 已提交
5069
	page = sg_page(qc->cursg);
J
Jens Axboe 已提交
5070
	offset = qc->cursg->offset + qc->cursg_ofs;
L
Linus Torvalds 已提交
5071 5072 5073 5074 5075 5076 5077

	/* get the current page and offset */
	page = nth_page(page, (offset >> PAGE_SHIFT));
	offset %= PAGE_SIZE;

	DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");

5078 5079 5080
	if (PageHighMem(page)) {
		unsigned long flags;

5081
		/* FIXME: use a bounce buffer */
5082 5083
		local_irq_save(flags);
		buf = kmap_atomic(page, KM_IRQ0);
5084

5085
		/* do the actual data transfer */
5086
		ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write);
L
Linus Torvalds 已提交
5087

5088 5089 5090 5091
		kunmap_atomic(buf, KM_IRQ0);
		local_irq_restore(flags);
	} else {
		buf = page_address(page);
5092
		ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write);
5093
	}
L
Linus Torvalds 已提交
5094

5095 5096
	qc->curbytes += qc->sect_size;
	qc->cursg_ofs += qc->sect_size;
L
Linus Torvalds 已提交
5097

J
Jens Axboe 已提交
5098 5099
	if (qc->cursg_ofs == qc->cursg->length) {
		qc->cursg = sg_next(qc->cursg);
L
Linus Torvalds 已提交
5100 5101 5102 5103
		qc->cursg_ofs = 0;
	}
}

5104
/**
5105
 *	ata_pio_sectors - Transfer one or many sectors.
5106 5107
 *	@qc: Command on going
 *
5108
 *	Transfer one or many sectors of data from/to the
5109 5110 5111 5112 5113
 *	ATA device for the DRQ request.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
L
Linus Torvalds 已提交
5114

5115 5116 5117 5118 5119 5120
static void ata_pio_sectors(struct ata_queued_cmd *qc)
{
	if (is_multi_taskfile(&qc->tf)) {
		/* READ/WRITE MULTIPLE */
		unsigned int nsect;

J
Jeff Garzik 已提交
5121
		WARN_ON(qc->dev->multi_count == 0);
L
Linus Torvalds 已提交
5122

5123
		nsect = min((qc->nbytes - qc->curbytes) / qc->sect_size,
T
Tejun Heo 已提交
5124
			    qc->dev->multi_count);
5125 5126 5127 5128
		while (nsect--)
			ata_pio_sector(qc);
	} else
		ata_pio_sector(qc);
5129 5130

	ata_altstatus(qc->ap); /* flush */
5131 5132
}

5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148
/**
 *	atapi_send_cdb - Write CDB bytes to hardware
 *	@ap: Port to which ATAPI device is attached.
 *	@qc: Taskfile currently active
 *
 *	When device has indicated its readiness to accept
 *	a CDB, this function is called.  Send the CDB.
 *
 *	LOCKING:
 *	caller.
 */

static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
{
	/* send SCSI cdb */
	DPRINTK("send cdb\n");
5149
	WARN_ON(qc->dev->cdb_len < 12);
5150

5151
	ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1);
5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166
	ata_altstatus(ap); /* flush */

	switch (qc->tf.protocol) {
	case ATA_PROT_ATAPI:
		ap->hsm_task_state = HSM_ST;
		break;
	case ATA_PROT_ATAPI_NODATA:
		ap->hsm_task_state = HSM_ST_LAST;
		break;
	case ATA_PROT_ATAPI_DMA:
		ap->hsm_task_state = HSM_ST_LAST;
		/* initiate bmdma */
		ap->ops->bmdma_start(qc);
		break;
	}
L
Linus Torvalds 已提交
5167 5168
}

A
Albert Lee 已提交
5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179
/**
 *	__atapi_pio_bytes - Transfer data from/to the ATAPI device.
 *	@qc: Command on going
 *	@bytes: number of bytes
 *
 *	Transfer Transfer data from/to the ATAPI device.
 *
 *	LOCKING:
 *	Inherited from caller.
 *
 */
T
Tejun Heo 已提交
5180
static int __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
L
Linus Torvalds 已提交
5181 5182 5183
{
	int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
	struct ata_port *ap = qc->ap;
T
Tejun Heo 已提交
5184 5185
	struct ata_eh_info *ehi = &qc->dev->link->eh_info;
	struct scatterlist *sg;
L
Linus Torvalds 已提交
5186 5187 5188 5189 5190
	struct page *page;
	unsigned char *buf;
	unsigned int offset, count;

next_sg:
T
Tejun Heo 已提交
5191 5192
	sg = qc->cursg;
	if (unlikely(!sg)) {
J
Jeff Garzik 已提交
5193
		/*
5194 5195 5196 5197 5198 5199 5200 5201 5202
		 * The end of qc->sg is reached and the device expects
		 * more data to transfer. In order not to overrun qc->sg
		 * and fulfill length specified in the byte count register,
		 *    - for read case, discard trailing data from the device
		 *    - for write case, padding zero data to the device
		 */
		u16 pad_buf[1] = { 0 };
		unsigned int i;

T
Tejun Heo 已提交
5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214
		if (bytes > qc->curbytes - qc->nbytes + ATAPI_MAX_DRAIN) {
			ata_ehi_push_desc(ehi, "too much trailing data "
					  "buf=%u cur=%u bytes=%u",
					  qc->nbytes, qc->curbytes, bytes);
			return -1;
		}

		 /* overflow is exptected for misc ATAPI commands */
		if (bytes && !atapi_qc_may_overflow(qc))
			ata_dev_printk(qc->dev, KERN_WARNING, "ATAPI %u bytes "
				       "trailing data (cdb=%02x nbytes=%u)\n",
				       bytes, qc->cdb[0], qc->nbytes);
5215

T
Tejun Heo 已提交
5216
		for (i = 0; i < (bytes + 1) / 2; i++)
5217
			ap->ops->data_xfer(qc->dev, (unsigned char *)pad_buf, 2, do_write);
5218

T
Tejun Heo 已提交
5219
		qc->curbytes += bytes;
5220

T
Tejun Heo 已提交
5221 5222
		return 0;
	}
L
Linus Torvalds 已提交
5223

J
Jens Axboe 已提交
5224
	page = sg_page(sg);
L
Linus Torvalds 已提交
5225 5226 5227 5228 5229 5230
	offset = sg->offset + qc->cursg_ofs;

	/* get the current page and offset */
	page = nth_page(page, (offset >> PAGE_SHIFT));
	offset %= PAGE_SIZE;

5231
	/* don't overrun current sg */
5232
	count = min(sg->length - qc->cursg_ofs, bytes);
L
Linus Torvalds 已提交
5233 5234 5235 5236

	/* don't cross page boundaries */
	count = min(count, (unsigned int)PAGE_SIZE - offset);

5237 5238
	DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");

5239 5240 5241
	if (PageHighMem(page)) {
		unsigned long flags;

5242
		/* FIXME: use bounce buffer */
5243 5244
		local_irq_save(flags);
		buf = kmap_atomic(page, KM_IRQ0);
5245

5246
		/* do the actual data transfer */
5247
		ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
5248

5249 5250 5251 5252
		kunmap_atomic(buf, KM_IRQ0);
		local_irq_restore(flags);
	} else {
		buf = page_address(page);
5253
		ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
5254
	}
L
Linus Torvalds 已提交
5255 5256

	bytes -= count;
T
Tejun Heo 已提交
5257 5258
	if ((count & 1) && bytes)
		bytes--;
L
Linus Torvalds 已提交
5259 5260 5261
	qc->curbytes += count;
	qc->cursg_ofs += count;

5262
	if (qc->cursg_ofs == sg->length) {
J
Jens Axboe 已提交
5263
		qc->cursg = sg_next(qc->cursg);
L
Linus Torvalds 已提交
5264 5265 5266
		qc->cursg_ofs = 0;
	}

5267
	if (bytes)
L
Linus Torvalds 已提交
5268
		goto next_sg;
T
Tejun Heo 已提交
5269 5270

	return 0;
L
Linus Torvalds 已提交
5271 5272
}

A
Albert Lee 已提交
5273 5274 5275 5276 5277 5278 5279 5280 5281 5282
/**
 *	atapi_pio_bytes - Transfer data from/to the ATAPI device.
 *	@qc: Command on going
 *
 *	Transfer Transfer data from/to the ATAPI device.
 *
 *	LOCKING:
 *	Inherited from caller.
 */

L
Linus Torvalds 已提交
5283 5284 5285 5286 5287 5288 5289
static void atapi_pio_bytes(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	struct ata_device *dev = qc->dev;
	unsigned int ireason, bc_lo, bc_hi, bytes;
	int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;

5290 5291 5292 5293 5294 5295 5296 5297 5298 5299
	/* Abuse qc->result_tf for temp storage of intermediate TF
	 * here to save some kernel stack usage.
	 * For normal completion, qc->result_tf is not relevant. For
	 * error, qc->result_tf is later overwritten by ata_qc_complete().
	 * So, the correctness of qc->result_tf is not affected.
	 */
	ap->ops->tf_read(ap, &qc->result_tf);
	ireason = qc->result_tf.nsect;
	bc_lo = qc->result_tf.lbam;
	bc_hi = qc->result_tf.lbah;
L
Linus Torvalds 已提交
5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310
	bytes = (bc_hi << 8) | bc_lo;

	/* shall be cleared to zero, indicating xfer of data */
	if (ireason & (1 << 0))
		goto err_out;

	/* make sure transfer direction matches expected */
	i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
	if (do_write != i_write)
		goto err_out;

T
Tejun Heo 已提交
5311
	VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes);
5312

T
Tejun Heo 已提交
5313 5314
	if (__atapi_pio_bytes(qc, bytes))
		goto err_out;
5315
	ata_altstatus(ap); /* flush */
L
Linus Torvalds 已提交
5316 5317 5318 5319

	return;

err_out:
5320
	ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n");
5321
	qc->err_mask |= AC_ERR_HSM;
A
Albert Lee 已提交
5322
	ap->hsm_task_state = HSM_ST_ERR;
L
Linus Torvalds 已提交
5323 5324 5325
}

/**
5326 5327 5328
 *	ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue.
 *	@ap: the target ata_port
 *	@qc: qc on going
L
Linus Torvalds 已提交
5329
 *
5330 5331
 *	RETURNS:
 *	1 if ok in workqueue, 0 otherwise.
L
Linus Torvalds 已提交
5332
 */
5333 5334

static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc)
L
Linus Torvalds 已提交
5335
{
5336 5337
	if (qc->tf.flags & ATA_TFLAG_POLLING)
		return 1;
L
Linus Torvalds 已提交
5338

5339 5340 5341 5342
	if (ap->hsm_task_state == HSM_ST_FIRST) {
		if (qc->tf.protocol == ATA_PROT_PIO &&
		    (qc->tf.flags & ATA_TFLAG_WRITE))
		    return 1;
L
Linus Torvalds 已提交
5343

5344 5345 5346
		if (is_atapi_taskfile(&qc->tf) &&
		    !(qc->dev->flags & ATA_DFLAG_CDB_INTR))
			return 1;
A
Albert Lee 已提交
5347 5348
	}

5349 5350
	return 0;
}
L
Linus Torvalds 已提交
5351

T
Tejun Heo 已提交
5352 5353 5354 5355 5356 5357 5358 5359
/**
 *	ata_hsm_qc_complete - finish a qc running on standard HSM
 *	@qc: Command to complete
 *	@in_wq: 1 if called from workqueue, 0 otherwise
 *
 *	Finish @qc which is running on standard HSM.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
5360
 *	If @in_wq is zero, spin_lock_irqsave(host lock).
T
Tejun Heo 已提交
5361 5362 5363 5364 5365 5366 5367 5368 5369
 *	Otherwise, none on entry and grabs host lock.
 */
static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq)
{
	struct ata_port *ap = qc->ap;
	unsigned long flags;

	if (ap->ops->error_handler) {
		if (in_wq) {
5370
			spin_lock_irqsave(ap->lock, flags);
T
Tejun Heo 已提交
5371

J
Jeff Garzik 已提交
5372 5373
			/* EH might have kicked in while host lock is
			 * released.
T
Tejun Heo 已提交
5374 5375 5376 5377
			 */
			qc = ata_qc_from_tag(ap, qc->tag);
			if (qc) {
				if (likely(!(qc->err_mask & AC_ERR_HSM))) {
5378
					ap->ops->irq_on(ap);
T
Tejun Heo 已提交
5379 5380 5381 5382 5383
					ata_qc_complete(qc);
				} else
					ata_port_freeze(ap);
			}

5384
			spin_unlock_irqrestore(ap->lock, flags);
T
Tejun Heo 已提交
5385 5386 5387 5388 5389 5390 5391 5392
		} else {
			if (likely(!(qc->err_mask & AC_ERR_HSM)))
				ata_qc_complete(qc);
			else
				ata_port_freeze(ap);
		}
	} else {
		if (in_wq) {
5393
			spin_lock_irqsave(ap->lock, flags);
5394
			ap->ops->irq_on(ap);
T
Tejun Heo 已提交
5395
			ata_qc_complete(qc);
5396
			spin_unlock_irqrestore(ap->lock, flags);
T
Tejun Heo 已提交
5397 5398 5399 5400 5401
		} else
			ata_qc_complete(qc);
	}
}

5402 5403 5404 5405 5406 5407 5408 5409 5410 5411
/**
 *	ata_hsm_move - move the HSM to the next state.
 *	@ap: the target ata_port
 *	@qc: qc on going
 *	@status: current device status
 *	@in_wq: 1 if called from workqueue, 0 otherwise
 *
 *	RETURNS:
 *	1 when poll next status needed, 0 otherwise.
 */
5412 5413
int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
		 u8 status, int in_wq)
5414
{
5415 5416 5417
	unsigned long flags = 0;
	int poll_next;

5418 5419
	WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0);

5420 5421 5422 5423
	/* Make sure ata_qc_issue_prot() does not throw things
	 * like DMA polling into the workqueue. Notice that
	 * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING).
	 */
5424
	WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc));
5425

5426
fsm_start:
5427
	DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
T
Tejun Heo 已提交
5428
		ap->print_id, qc->tf.protocol, ap->hsm_task_state, status);
5429

5430 5431
	switch (ap->hsm_task_state) {
	case HSM_ST_FIRST:
5432 5433 5434 5435 5436 5437 5438 5439
		/* Send first data block or PACKET CDB */

		/* If polling, we will stay in the work queue after
		 * sending the data. Otherwise, interrupt handler
		 * takes over after sending the data.
		 */
		poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);

5440
		/* check device status */
5441 5442 5443 5444 5445 5446 5447 5448 5449
		if (unlikely((status & ATA_DRQ) == 0)) {
			/* handle BSY=0, DRQ=0 as error */
			if (likely(status & (ATA_ERR | ATA_DF)))
				/* device stops HSM for abort/error */
				qc->err_mask |= AC_ERR_DEV;
			else
				/* HSM violation. Let EH handle this */
				qc->err_mask |= AC_ERR_HSM;

A
Albert Lee 已提交
5450
			ap->hsm_task_state = HSM_ST_ERR;
5451
			goto fsm_start;
L
Linus Torvalds 已提交
5452 5453
		}

5454 5455
		/* Device should not ask for data transfer (DRQ=1)
		 * when it finds something wrong.
5456 5457 5458
		 * We ignore DRQ here and stop the HSM by
		 * changing hsm_task_state to HSM_ST_ERR and
		 * let the EH abort the command or reset the device.
5459 5460
		 */
		if (unlikely(status & (ATA_ERR | ATA_DF))) {
5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473
			/* Some ATAPI tape drives forget to clear the ERR bit
			 * when doing the next command (mostly request sense).
			 * We ignore ERR here to workaround and proceed sending
			 * the CDB.
			 */
			if (!(qc->dev->horkage & ATA_HORKAGE_STUCK_ERR)) {
				ata_port_printk(ap, KERN_WARNING,
						"DRQ=1 with device error, "
						"dev_stat 0x%X\n", status);
				qc->err_mask |= AC_ERR_HSM;
				ap->hsm_task_state = HSM_ST_ERR;
				goto fsm_start;
			}
5474
		}
L
Linus Torvalds 已提交
5475

5476 5477 5478 5479 5480 5481
		/* Send the CDB (atapi) or the first data block (ata pio out).
		 * During the state transition, interrupt handler shouldn't
		 * be invoked before the data transfer is complete and
		 * hsm_task_state is changed. Hence, the following locking.
		 */
		if (in_wq)
5482
			spin_lock_irqsave(ap->lock, flags);
L
Linus Torvalds 已提交
5483

5484 5485 5486 5487
		if (qc->tf.protocol == ATA_PROT_PIO) {
			/* PIO data out protocol.
			 * send first data block.
			 */
5488

5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499
			/* ata_pio_sectors() might change the state
			 * to HSM_ST_LAST. so, the state is changed here
			 * before ata_pio_sectors().
			 */
			ap->hsm_task_state = HSM_ST;
			ata_pio_sectors(qc);
		} else
			/* send CDB */
			atapi_send_cdb(ap, qc);

		if (in_wq)
5500
			spin_unlock_irqrestore(ap->lock, flags);
5501 5502 5503 5504

		/* if polling, ata_pio_task() handles the rest.
		 * otherwise, interrupt handler takes over from here.
		 */
5505
		break;
5506

5507 5508 5509 5510 5511
	case HSM_ST:
		/* complete command or read/write the data register */
		if (qc->tf.protocol == ATA_PROT_ATAPI) {
			/* ATAPI PIO protocol */
			if ((status & ATA_DRQ) == 0) {
5512 5513 5514
				/* No more data to transfer or device error.
				 * Device error will be tagged in HSM_ST_LAST.
				 */
5515 5516 5517
				ap->hsm_task_state = HSM_ST_LAST;
				goto fsm_start;
			}
L
Linus Torvalds 已提交
5518

5519 5520
			/* Device should not ask for data transfer (DRQ=1)
			 * when it finds something wrong.
5521 5522 5523
			 * We ignore DRQ here and stop the HSM by
			 * changing hsm_task_state to HSM_ST_ERR and
			 * let the EH abort the command or reset the device.
5524 5525
			 */
			if (unlikely(status & (ATA_ERR | ATA_DF))) {
T
Tejun Heo 已提交
5526 5527 5528
				ata_port_printk(ap, KERN_WARNING, "DRQ=1 with "
						"device error, dev_stat 0x%X\n",
						status);
5529
				qc->err_mask |= AC_ERR_HSM;
5530 5531
				ap->hsm_task_state = HSM_ST_ERR;
				goto fsm_start;
5532
			}
L
Linus Torvalds 已提交
5533

5534
			atapi_pio_bytes(qc);
J
Jeff Garzik 已提交
5535

5536 5537 5538
			if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
				/* bad ireason reported by device */
				goto fsm_start;
L
Linus Torvalds 已提交
5539

5540 5541 5542 5543
		} else {
			/* ATA PIO protocol */
			if (unlikely((status & ATA_DRQ) == 0)) {
				/* handle BSY=0, DRQ=0 as error */
5544 5545 5546 5547
				if (likely(status & (ATA_ERR | ATA_DF)))
					/* device stops HSM for abort/error */
					qc->err_mask |= AC_ERR_DEV;
				else
5548 5549 5550 5551 5552 5553
					/* HSM violation. Let EH handle this.
					 * Phantom devices also trigger this
					 * condition.  Mark hint.
					 */
					qc->err_mask |= AC_ERR_HSM |
							AC_ERR_NODEV_HINT;
5554

5555 5556 5557
				ap->hsm_task_state = HSM_ST_ERR;
				goto fsm_start;
			}
L
Linus Torvalds 已提交
5558

5559 5560 5561 5562 5563 5564 5565 5566 5567
			/* For PIO reads, some devices may ask for
			 * data transfer (DRQ=1) alone with ERR=1.
			 * We respect DRQ here and transfer one
			 * block of junk data before changing the
			 * hsm_task_state to HSM_ST_ERR.
			 *
			 * For PIO writes, ERR=1 DRQ=1 doesn't make
			 * sense since the data block has been
			 * transferred to the device.
5568 5569 5570 5571
			 */
			if (unlikely(status & (ATA_ERR | ATA_DF))) {
				/* data might be corrputed */
				qc->err_mask |= AC_ERR_DEV;
5572 5573 5574 5575 5576 5577

				if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
					ata_pio_sectors(qc);
					status = ata_wait_idle(ap);
				}

5578 5579 5580
				if (status & (ATA_BUSY | ATA_DRQ))
					qc->err_mask |= AC_ERR_HSM;

5581 5582 5583 5584 5585 5586
				/* ata_pio_sectors() might change the
				 * state to HSM_ST_LAST. so, the state
				 * is changed after ata_pio_sectors().
				 */
				ap->hsm_task_state = HSM_ST_ERR;
				goto fsm_start;
5587 5588
			}

5589 5590 5591 5592 5593
			ata_pio_sectors(qc);

			if (ap->hsm_task_state == HSM_ST_LAST &&
			    (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
				/* all data read */
5594
				status = ata_wait_idle(ap);
5595 5596 5597 5598
				goto fsm_start;
			}
		}

5599
		poll_next = 1;
L
Linus Torvalds 已提交
5600 5601
		break;

A
Albert Lee 已提交
5602
	case HSM_ST_LAST:
5603 5604
		if (unlikely(!ata_ok(status))) {
			qc->err_mask |= __ac_err_mask(status);
5605 5606 5607 5608 5609
			ap->hsm_task_state = HSM_ST_ERR;
			goto fsm_start;
		}

		/* no more data to transfer */
5610
		DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n",
T
Tejun Heo 已提交
5611
			ap->print_id, qc->dev->devno, status);
5612

5613 5614
		WARN_ON(qc->err_mask);

5615
		ap->hsm_task_state = HSM_ST_IDLE;
L
Linus Torvalds 已提交
5616

5617
		/* complete taskfile transaction */
T
Tejun Heo 已提交
5618
		ata_hsm_qc_complete(qc, in_wq);
5619 5620

		poll_next = 0;
L
Linus Torvalds 已提交
5621 5622
		break;

A
Albert Lee 已提交
5623
	case HSM_ST_ERR:
5624 5625 5626 5627 5628 5629
		/* make sure qc->err_mask is available to
		 * know what's wrong and recover
		 */
		WARN_ON(qc->err_mask == 0);

		ap->hsm_task_state = HSM_ST_IDLE;
5630

5631
		/* complete taskfile transaction */
T
Tejun Heo 已提交
5632
		ata_hsm_qc_complete(qc, in_wq);
5633 5634

		poll_next = 0;
5635 5636
		break;
	default:
5637
		poll_next = 0;
5638
		BUG();
L
Linus Torvalds 已提交
5639 5640
	}

5641
	return poll_next;
L
Linus Torvalds 已提交
5642 5643
}

5644
static void ata_pio_task(struct work_struct *work)
5645
{
5646 5647 5648
	struct ata_port *ap =
		container_of(work, struct ata_port, port_task.work);
	struct ata_queued_cmd *qc = ap->port_task_data;
5649
	u8 status;
5650
	int poll_next;
5651

J
Jeff Garzik 已提交
5652
fsm_start:
5653
	WARN_ON(ap->hsm_task_state == HSM_ST_IDLE);
5654

5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666
	/*
	 * This is purely heuristic.  This is a fast path.
	 * Sometimes when we enter, BSY will be cleared in
	 * a chk-status or two.  If not, the drive is probably seeking
	 * or something.  Snooze for a couple msecs, then
	 * chk-status again.  If still busy, queue delayed work.
	 */
	status = ata_busy_wait(ap, ATA_BUSY, 5);
	if (status & ATA_BUSY) {
		msleep(2);
		status = ata_busy_wait(ap, ATA_BUSY, 10);
		if (status & ATA_BUSY) {
5667
			ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE);
5668 5669
			return;
		}
5670 5671
	}

5672 5673
	/* move the HSM */
	poll_next = ata_hsm_move(ap, qc, status, 1);
5674

5675 5676 5677 5678
	/* another command or interrupt handler
	 * may be running at this point.
	 */
	if (poll_next)
J
Jeff Garzik 已提交
5679
		goto fsm_start;
5680 5681
}

L
Linus Torvalds 已提交
5682 5683 5684 5685 5686 5687
/**
 *	ata_qc_new - Request an available ATA command, for queueing
 *	@ap: Port associated with device @dev
 *	@dev: Device from whom we request an available command structure
 *
 *	LOCKING:
J
Jeff Garzik 已提交
5688
 *	None.
L
Linus Torvalds 已提交
5689 5690 5691 5692 5693 5694 5695
 */

static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
{
	struct ata_queued_cmd *qc = NULL;
	unsigned int i;

5696
	/* no command while frozen */
5697
	if (unlikely(ap->pflags & ATA_PFLAG_FROZEN))
5698 5699
		return NULL;

5700 5701
	/* the last tag is reserved for internal command. */
	for (i = 0; i < ATA_MAX_QUEUE - 1; i++)
5702
		if (!test_and_set_bit(i, &ap->qc_allocated)) {
5703
			qc = __ata_qc_from_tag(ap, i);
L
Linus Torvalds 已提交
5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717
			break;
		}

	if (qc)
		qc->tag = i;

	return qc;
}

/**
 *	ata_qc_new_init - Request an available ATA command, and initialize it
 *	@dev: Device from whom we request an available command structure
 *
 *	LOCKING:
J
Jeff Garzik 已提交
5718
 *	None.
L
Linus Torvalds 已提交
5719 5720
 */

T
Tejun Heo 已提交
5721
struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
L
Linus Torvalds 已提交
5722
{
T
Tejun Heo 已提交
5723
	struct ata_port *ap = dev->link->ap;
L
Linus Torvalds 已提交
5724 5725 5726 5727 5728 5729 5730 5731
	struct ata_queued_cmd *qc;

	qc = ata_qc_new(ap);
	if (qc) {
		qc->scsicmd = NULL;
		qc->ap = ap;
		qc->dev = dev;

J
Jeff Garzik 已提交
5732
		ata_qc_reinit(qc);
L
Linus Torvalds 已提交
5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745
	}

	return qc;
}

/**
 *	ata_qc_free - free unused ata_queued_cmd
 *	@qc: Command to complete
 *
 *	Designed to free unused ata_queued_cmd object
 *	in case something prevents using it.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
5746
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
5747 5748 5749
 */
void ata_qc_free(struct ata_queued_cmd *qc)
{
5750 5751 5752
	struct ata_port *ap = qc->ap;
	unsigned int tag;

5753
	WARN_ON(qc == NULL);	/* ata_qc_from_tag _might_ return NULL */
L
Linus Torvalds 已提交
5754

5755 5756 5757 5758
	qc->flags = 0;
	tag = qc->tag;
	if (likely(ata_tag_valid(tag))) {
		qc->tag = ATA_TAG_POISON;
5759
		clear_bit(tag, &ap->qc_allocated);
5760
	}
L
Linus Torvalds 已提交
5761 5762
}

5763
void __ata_qc_complete(struct ata_queued_cmd *qc)
L
Linus Torvalds 已提交
5764
{
5765
	struct ata_port *ap = qc->ap;
T
Tejun Heo 已提交
5766
	struct ata_link *link = qc->dev->link;
5767

5768 5769
	WARN_ON(qc == NULL);	/* ata_qc_from_tag _might_ return NULL */
	WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
L
Linus Torvalds 已提交
5770 5771 5772 5773

	if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
		ata_sg_clean(qc);

5774
	/* command should be marked inactive atomically with qc completion */
5775
	if (qc->tf.protocol == ATA_PROT_NCQ) {
T
Tejun Heo 已提交
5776
		link->sactive &= ~(1 << qc->tag);
5777 5778 5779
		if (!link->sactive)
			ap->nr_active_links--;
	} else {
T
Tejun Heo 已提交
5780
		link->active_tag = ATA_TAG_POISON;
5781 5782 5783 5784 5785 5786 5787
		ap->nr_active_links--;
	}

	/* clear exclusive status */
	if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
		     ap->excl_link == link))
		ap->excl_link = NULL;
5788

5789 5790 5791 5792 5793
	/* atapi: mark qc as inactive to prevent the interrupt handler
	 * from completing the command twice later, before the error handler
	 * is called. (when rc != 0 and atapi request sense is needed)
	 */
	qc->flags &= ~ATA_QCFLAG_ACTIVE;
5794
	ap->qc_active &= ~(1 << qc->tag);
5795

L
Linus Torvalds 已提交
5796
	/* call completion callback */
5797
	qc->complete_fn(qc);
L
Linus Torvalds 已提交
5798 5799
}

5800 5801 5802 5803 5804
static void fill_result_tf(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;

	qc->result_tf.flags = qc->tf.flags;
5805
	ap->ops->tf_read(ap, &qc->result_tf);
5806 5807
}

5808 5809 5810 5811 5812 5813 5814 5815 5816
/**
 *	ata_qc_complete - Complete an active ATA command
 *	@qc: Command to complete
 *	@err_mask: ATA Status register contents
 *
 *	Indicate to the mid and upper layers that an ATA
 *	command has completed, with either an ok or not-ok status.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
5817
 *	spin_lock_irqsave(host lock)
5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836
 */
void ata_qc_complete(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;

	/* XXX: New EH and old EH use different mechanisms to
	 * synchronize EH with regular execution path.
	 *
	 * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED.
	 * Normal execution path is responsible for not accessing a
	 * failed qc.  libata core enforces the rule by returning NULL
	 * from ata_qc_from_tag() for failed qcs.
	 *
	 * Old EH depends on ata_qc_complete() nullifying completion
	 * requests if ATA_QCFLAG_EH_SCHEDULED is set.  Old EH does
	 * not synchronize with interrupt handler.  Only PIO task is
	 * taken care of.
	 */
	if (ap->ops->error_handler) {
5837 5838 5839
		struct ata_device *dev = qc->dev;
		struct ata_eh_info *ehi = &dev->link->eh_info;

5840
		WARN_ON(ap->pflags & ATA_PFLAG_FROZEN);
5841 5842 5843 5844 5845 5846 5847

		if (unlikely(qc->err_mask))
			qc->flags |= ATA_QCFLAG_FAILED;

		if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
			if (!ata_tag_internal(qc->tag)) {
				/* always fill result TF for failed qc */
5848
				fill_result_tf(qc);
5849 5850 5851 5852 5853 5854 5855
				ata_qc_schedule_eh(qc);
				return;
			}
		}

		/* read result TF if requested */
		if (qc->flags & ATA_QCFLAG_RESULT_TF)
5856
			fill_result_tf(qc);
5857

5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872
		/* Some commands need post-processing after successful
		 * completion.
		 */
		switch (qc->tf.command) {
		case ATA_CMD_SET_FEATURES:
			if (qc->tf.feature != SETFEATURES_WC_ON &&
			    qc->tf.feature != SETFEATURES_WC_OFF)
				break;
			/* fall through */
		case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
		case ATA_CMD_SET_MULTI: /* multi_count changed */
			/* revalidate device */
			ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE;
			ata_port_schedule_eh(ap);
			break;
5873 5874 5875 5876

		case ATA_CMD_SLEEP:
			dev->flags |= ATA_DFLAG_SLEEPING;
			break;
5877 5878
		}

5879 5880 5881 5882 5883 5884 5885
		__ata_qc_complete(qc);
	} else {
		if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
			return;

		/* read result TF if failed or requested */
		if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
5886
			fill_result_tf(qc);
5887 5888 5889 5890 5891

		__ata_qc_complete(qc);
	}
}

5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903
/**
 *	ata_qc_complete_multiple - Complete multiple qcs successfully
 *	@ap: port in question
 *	@qc_active: new qc_active mask
 *	@finish_qc: LLDD callback invoked before completing a qc
 *
 *	Complete in-flight commands.  This functions is meant to be
 *	called from low-level driver's interrupt routine to complete
 *	requests normally.  ap->qc_active and @qc_active is compared
 *	and commands are completed accordingly.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
5904
 *	spin_lock_irqsave(host lock)
5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940
 *
 *	RETURNS:
 *	Number of completed commands on success, -errno otherwise.
 */
int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
			     void (*finish_qc)(struct ata_queued_cmd *))
{
	int nr_done = 0;
	u32 done_mask;
	int i;

	done_mask = ap->qc_active ^ qc_active;

	if (unlikely(done_mask & qc_active)) {
		ata_port_printk(ap, KERN_ERR, "illegal qc_active transition "
				"(%08x->%08x)\n", ap->qc_active, qc_active);
		return -EINVAL;
	}

	for (i = 0; i < ATA_MAX_QUEUE; i++) {
		struct ata_queued_cmd *qc;

		if (!(done_mask & (1 << i)))
			continue;

		if ((qc = ata_qc_from_tag(ap, i))) {
			if (finish_qc)
				finish_qc(qc);
			ata_qc_complete(qc);
			nr_done++;
		}
	}

	return nr_done;
}

L
Linus Torvalds 已提交
5941 5942 5943 5944 5945
static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;

	switch (qc->tf.protocol) {
5946
	case ATA_PROT_NCQ:
L
Linus Torvalds 已提交
5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974
	case ATA_PROT_DMA:
	case ATA_PROT_ATAPI_DMA:
		return 1;

	case ATA_PROT_ATAPI:
	case ATA_PROT_PIO:
		if (ap->flags & ATA_FLAG_PIO_DMA)
			return 1;

		/* fall through */

	default:
		return 0;
	}

	/* never reached */
}

/**
 *	ata_qc_issue - issue taskfile to device
 *	@qc: command to issue to device
 *
 *	Prepare an ATA command to submission to device.
 *	This includes mapping the data into a DMA-able
 *	area, filling in the S/G table, and finally
 *	writing the taskfile to hardware, starting the command.
 *
 *	LOCKING:
J
Jeff Garzik 已提交
5975
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
5976
 */
5977
void ata_qc_issue(struct ata_queued_cmd *qc)
L
Linus Torvalds 已提交
5978 5979
{
	struct ata_port *ap = qc->ap;
T
Tejun Heo 已提交
5980
	struct ata_link *link = qc->dev->link;
L
Linus Torvalds 已提交
5981

5982 5983 5984 5985
	/* Make sure only one non-NCQ command is outstanding.  The
	 * check is skipped for old EH because it reuses active qc to
	 * request ATAPI sense.
	 */
T
Tejun Heo 已提交
5986
	WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag));
5987 5988

	if (qc->tf.protocol == ATA_PROT_NCQ) {
T
Tejun Heo 已提交
5989
		WARN_ON(link->sactive & (1 << qc->tag));
5990 5991 5992

		if (!link->sactive)
			ap->nr_active_links++;
T
Tejun Heo 已提交
5993
		link->sactive |= 1 << qc->tag;
5994
	} else {
T
Tejun Heo 已提交
5995
		WARN_ON(link->sactive);
5996 5997

		ap->nr_active_links++;
T
Tejun Heo 已提交
5998
		link->active_tag = qc->tag;
5999 6000
	}

6001
	qc->flags |= ATA_QCFLAG_ACTIVE;
6002
	ap->qc_active |= 1 << qc->tag;
6003

L
Linus Torvalds 已提交
6004 6005 6006
	if (ata_should_dma_map(qc)) {
		if (qc->flags & ATA_QCFLAG_SG) {
			if (ata_sg_setup(qc))
6007
				goto sg_err;
L
Linus Torvalds 已提交
6008 6009
		} else if (qc->flags & ATA_QCFLAG_SINGLE) {
			if (ata_sg_setup_one(qc))
6010
				goto sg_err;
L
Linus Torvalds 已提交
6011 6012 6013 6014 6015
		}
	} else {
		qc->flags &= ~ATA_QCFLAG_DMAMAP;
	}

6016 6017 6018 6019 6020 6021 6022 6023
	/* if device is sleeping, schedule softreset and abort the link */
	if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) {
		link->eh_info.action |= ATA_EH_SOFTRESET;
		ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
		ata_link_abort(link);
		return;
	}

L
Linus Torvalds 已提交
6024 6025
	ap->ops->qc_prep(qc);

6026 6027 6028 6029
	qc->err_mask |= ap->ops->qc_issue(qc);
	if (unlikely(qc->err_mask))
		goto err;
	return;
L
Linus Torvalds 已提交
6030

6031 6032
sg_err:
	qc->flags &= ~ATA_QCFLAG_DMAMAP;
6033 6034 6035
	qc->err_mask |= AC_ERR_SYSTEM;
err:
	ata_qc_complete(qc);
L
Linus Torvalds 已提交
6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046
}

/**
 *	ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
 *	@qc: command to issue to device
 *
 *	Using various libata functions and hooks, this function
 *	starts an ATA command.  ATA commands are grouped into
 *	classes called "protocols", and issuing each type of protocol
 *	is slightly different.
 *
E
Edward Falk 已提交
6047 6048
 *	May be used as the qc_issue() entry in ata_port_operations.
 *
L
Linus Torvalds 已提交
6049
 *	LOCKING:
J
Jeff Garzik 已提交
6050
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
6051 6052
 *
 *	RETURNS:
6053
 *	Zero on success, AC_ERR_* mask on failure
L
Linus Torvalds 已提交
6054 6055
 */

6056
unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
L
Linus Torvalds 已提交
6057 6058 6059
{
	struct ata_port *ap = qc->ap;

6060 6061 6062 6063 6064 6065
	/* Use polling pio if the LLD doesn't handle
	 * interrupt driven pio and atapi CDB interrupt.
	 */
	if (ap->flags & ATA_FLAG_PIO_POLLING) {
		switch (qc->tf.protocol) {
		case ATA_PROT_PIO:
6066
		case ATA_PROT_NODATA:
6067 6068 6069 6070 6071 6072
		case ATA_PROT_ATAPI:
		case ATA_PROT_ATAPI_NODATA:
			qc->tf.flags |= ATA_TFLAG_POLLING;
			break;
		case ATA_PROT_ATAPI_DMA:
			if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
6073
				/* see ata_dma_blacklisted() */
6074 6075 6076 6077 6078 6079 6080
				BUG();
			break;
		default:
			break;
		}
	}

6081
	/* select the device */
L
Linus Torvalds 已提交
6082 6083
	ata_dev_select(ap, qc->dev->devno, 1, 0);

6084
	/* start the command */
L
Linus Torvalds 已提交
6085 6086
	switch (qc->tf.protocol) {
	case ATA_PROT_NODATA:
6087 6088 6089
		if (qc->tf.flags & ATA_TFLAG_POLLING)
			ata_qc_set_polling(qc);

J
Jeff Garzik 已提交
6090
		ata_tf_to_host(ap, &qc->tf);
6091 6092 6093
		ap->hsm_task_state = HSM_ST_LAST;

		if (qc->tf.flags & ATA_TFLAG_POLLING)
6094
			ata_port_queue_task(ap, ata_pio_task, qc, 0);
6095

L
Linus Torvalds 已提交
6096 6097 6098
		break;

	case ATA_PROT_DMA:
J
Jeff Garzik 已提交
6099
		WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
6100

L
Linus Torvalds 已提交
6101 6102 6103
		ap->ops->tf_load(ap, &qc->tf);	 /* load tf registers */
		ap->ops->bmdma_setup(qc);	    /* set up bmdma */
		ap->ops->bmdma_start(qc);	    /* initiate bmdma */
6104
		ap->hsm_task_state = HSM_ST_LAST;
L
Linus Torvalds 已提交
6105 6106
		break;

6107 6108 6109
	case ATA_PROT_PIO:
		if (qc->tf.flags & ATA_TFLAG_POLLING)
			ata_qc_set_polling(qc);
L
Linus Torvalds 已提交
6110

J
Jeff Garzik 已提交
6111
		ata_tf_to_host(ap, &qc->tf);
6112

6113 6114 6115
		if (qc->tf.flags & ATA_TFLAG_WRITE) {
			/* PIO data out protocol */
			ap->hsm_task_state = HSM_ST_FIRST;
6116
			ata_port_queue_task(ap, ata_pio_task, qc, 0);
6117 6118

			/* always send first data block using
6119
			 * the ata_pio_task() codepath.
6120
			 */
6121
		} else {
6122 6123 6124 6125
			/* PIO data in protocol */
			ap->hsm_task_state = HSM_ST;

			if (qc->tf.flags & ATA_TFLAG_POLLING)
6126
				ata_port_queue_task(ap, ata_pio_task, qc, 0);
6127 6128 6129 6130

			/* if polling, ata_pio_task() handles the rest.
			 * otherwise, interrupt handler takes over from here.
			 */
6131 6132
		}

L
Linus Torvalds 已提交
6133 6134 6135 6136
		break;

	case ATA_PROT_ATAPI:
	case ATA_PROT_ATAPI_NODATA:
6137 6138 6139
		if (qc->tf.flags & ATA_TFLAG_POLLING)
			ata_qc_set_polling(qc);

J
Jeff Garzik 已提交
6140
		ata_tf_to_host(ap, &qc->tf);
J
Jeff Garzik 已提交
6141

6142 6143 6144 6145 6146
		ap->hsm_task_state = HSM_ST_FIRST;

		/* send cdb by polling if no cdb interrupt */
		if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
		    (qc->tf.flags & ATA_TFLAG_POLLING))
6147
			ata_port_queue_task(ap, ata_pio_task, qc, 0);
L
Linus Torvalds 已提交
6148 6149 6150
		break;

	case ATA_PROT_ATAPI_DMA:
J
Jeff Garzik 已提交
6151
		WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
6152

L
Linus Torvalds 已提交
6153 6154
		ap->ops->tf_load(ap, &qc->tf);	 /* load tf registers */
		ap->ops->bmdma_setup(qc);	    /* set up bmdma */
6155 6156 6157 6158
		ap->hsm_task_state = HSM_ST_FIRST;

		/* send cdb by polling if no cdb interrupt */
		if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
6159
			ata_port_queue_task(ap, ata_pio_task, qc, 0);
L
Linus Torvalds 已提交
6160 6161 6162 6163
		break;

	default:
		WARN_ON(1);
6164
		return AC_ERR_SYSTEM;
L
Linus Torvalds 已提交
6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179
	}

	return 0;
}

/**
 *	ata_host_intr - Handle host interrupt for given (port, task)
 *	@ap: Port on which interrupt arrived (possibly...)
 *	@qc: Taskfile currently active in engine
 *
 *	Handle host interrupt for given queued command.  Currently,
 *	only DMA interrupts are handled.  All other commands are
 *	handled via polling with interrupts disabled (nIEN bit).
 *
 *	LOCKING:
J
Jeff Garzik 已提交
6180
 *	spin_lock_irqsave(host lock)
L
Linus Torvalds 已提交
6181 6182 6183 6184 6185
 *
 *	RETURNS:
 *	One if interrupt was handled, zero if not (shared irq).
 */

6186 6187
inline unsigned int ata_host_intr(struct ata_port *ap,
				  struct ata_queued_cmd *qc)
L
Linus Torvalds 已提交
6188
{
T
Tejun Heo 已提交
6189
	struct ata_eh_info *ehi = &ap->link.eh_info;
6190
	u8 status, host_stat = 0;
L
Linus Torvalds 已提交
6191

6192
	VPRINTK("ata%u: protocol %d task_state %d\n",
T
Tejun Heo 已提交
6193
		ap->print_id, qc->tf.protocol, ap->hsm_task_state);
L
Linus Torvalds 已提交
6194

6195 6196 6197
	/* Check whether we are expecting interrupt in this state */
	switch (ap->hsm_task_state) {
	case HSM_ST_FIRST:
6198 6199 6200
		/* Some pre-ATAPI-4 devices assert INTRQ
		 * at this state when ready to receive CDB.
		 */
L
Linus Torvalds 已提交
6201

6202 6203 6204 6205 6206
		/* Check the ATA_DFLAG_CDB_INTR flag is enough here.
		 * The flag was turned on only for atapi devices.
		 * No need to check is_atapi_taskfile(&qc->tf) again.
		 */
		if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
L
Linus Torvalds 已提交
6207 6208
			goto idle_irq;
		break;
6209 6210 6211 6212 6213
	case HSM_ST_LAST:
		if (qc->tf.protocol == ATA_PROT_DMA ||
		    qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
			/* check status of DMA engine */
			host_stat = ap->ops->bmdma_status(ap);
T
Tejun Heo 已提交
6214 6215
			VPRINTK("ata%u: host_stat 0x%X\n",
				ap->print_id, host_stat);
6216 6217 6218 6219 6220 6221 6222

			/* if it's not our irq... */
			if (!(host_stat & ATA_DMA_INTR))
				goto idle_irq;

			/* before we do anything else, clear DMA-Start bit */
			ap->ops->bmdma_stop(qc);
6223 6224 6225 6226 6227 6228

			if (unlikely(host_stat & ATA_DMA_ERR)) {
				/* error when transfering data to/from memory */
				qc->err_mask |= AC_ERR_HOST_BUS;
				ap->hsm_task_state = HSM_ST_ERR;
			}
6229 6230 6231 6232
		}
		break;
	case HSM_ST:
		break;
L
Linus Torvalds 已提交
6233 6234 6235 6236
	default:
		goto idle_irq;
	}

6237 6238 6239 6240
	/* check altstatus */
	status = ata_altstatus(ap);
	if (status & ATA_BUSY)
		goto idle_irq;
L
Linus Torvalds 已提交
6241

6242 6243 6244 6245
	/* check main status, clearing INTRQ */
	status = ata_chk_status(ap);
	if (unlikely(status & ATA_BUSY))
		goto idle_irq;
L
Linus Torvalds 已提交
6246

6247 6248
	/* ack bmdma irq events */
	ap->ops->irq_clear(ap);
L
Linus Torvalds 已提交
6249

6250
	ata_hsm_move(ap, qc, status, 0);
6251 6252 6253 6254 6255

	if (unlikely(qc->err_mask) && (qc->tf.protocol == ATA_PROT_DMA ||
				       qc->tf.protocol == ATA_PROT_ATAPI_DMA))
		ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);

L
Linus Torvalds 已提交
6256 6257 6258 6259 6260 6261 6262
	return 1;	/* irq handled */

idle_irq:
	ap->stats.idle_irq++;

#ifdef ATA_IRQ_TRAP
	if ((ap->stats.idle_irq % 1000) == 0) {
6263 6264
		ata_chk_status(ap);
		ap->ops->irq_clear(ap);
6265
		ata_port_printk(ap, KERN_WARNING, "irq trap\n");
6266
		return 1;
L
Linus Torvalds 已提交
6267 6268 6269 6270 6271 6272 6273
	}
#endif
	return 0;	/* irq not handled */
}

/**
 *	ata_interrupt - Default ATA host interrupt handler
J
Jeff Garzik 已提交
6274
 *	@irq: irq line (unused)
J
Jeff Garzik 已提交
6275
 *	@dev_instance: pointer to our ata_host information structure
L
Linus Torvalds 已提交
6276
 *
J
Jeff Garzik 已提交
6277 6278 6279
 *	Default interrupt handler for PCI IDE devices.  Calls
 *	ata_host_intr() for each port that is not disabled.
 *
L
Linus Torvalds 已提交
6280
 *	LOCKING:
J
Jeff Garzik 已提交
6281
 *	Obtains host lock during operation.
L
Linus Torvalds 已提交
6282 6283
 *
 *	RETURNS:
J
Jeff Garzik 已提交
6284
 *	IRQ_NONE or IRQ_HANDLED.
L
Linus Torvalds 已提交
6285 6286
 */

6287
irqreturn_t ata_interrupt(int irq, void *dev_instance)
L
Linus Torvalds 已提交
6288
{
J
Jeff Garzik 已提交
6289
	struct ata_host *host = dev_instance;
L
Linus Torvalds 已提交
6290 6291 6292 6293 6294
	unsigned int i;
	unsigned int handled = 0;
	unsigned long flags;

	/* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
J
Jeff Garzik 已提交
6295
	spin_lock_irqsave(&host->lock, flags);
L
Linus Torvalds 已提交
6296

J
Jeff Garzik 已提交
6297
	for (i = 0; i < host->n_ports; i++) {
L
Linus Torvalds 已提交
6298 6299
		struct ata_port *ap;

J
Jeff Garzik 已提交
6300
		ap = host->ports[i];
6301
		if (ap &&
J
Jeff Garzik 已提交
6302
		    !(ap->flags & ATA_FLAG_DISABLED)) {
L
Linus Torvalds 已提交
6303 6304
			struct ata_queued_cmd *qc;

T
Tejun Heo 已提交
6305
			qc = ata_qc_from_tag(ap, ap->link.active_tag);
6306
			if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
6307
			    (qc->flags & ATA_QCFLAG_ACTIVE))
L
Linus Torvalds 已提交
6308 6309 6310 6311
				handled |= ata_host_intr(ap, qc);
		}
	}

J
Jeff Garzik 已提交
6312
	spin_unlock_irqrestore(&host->lock, flags);
L
Linus Torvalds 已提交
6313 6314 6315 6316

	return IRQ_RETVAL(handled);
}

6317 6318
/**
 *	sata_scr_valid - test whether SCRs are accessible
6319
 *	@link: ATA link to test SCR accessibility for
6320
 *
6321
 *	Test whether SCRs are accessible for @link.
6322 6323 6324 6325 6326 6327 6328
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	1 if SCRs are accessible, 0 otherwise.
 */
6329
int sata_scr_valid(struct ata_link *link)
6330
{
6331 6332
	struct ata_port *ap = link->ap;

6333
	return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read;
6334 6335 6336 6337
}

/**
 *	sata_scr_read - read SCR register of the specified port
6338
 *	@link: ATA link to read SCR for
6339 6340 6341
 *	@reg: SCR to read
 *	@val: Place to store read value
 *
6342
 *	Read SCR register @reg of @link into *@val.  This function is
6343 6344
 *	guaranteed to succeed if @link is ap->link, the cable type of
 *	the port is SATA and the port implements ->scr_read.
6345 6346
 *
 *	LOCKING:
6347
 *	None if @link is ap->link.  Kernel thread context otherwise.
6348 6349 6350 6351
 *
 *	RETURNS:
 *	0 on success, negative errno on failure.
 */
6352
int sata_scr_read(struct ata_link *link, int reg, u32 *val)
6353
{
6354 6355
	if (ata_is_host_link(link)) {
		struct ata_port *ap = link->ap;
6356

6357 6358 6359 6360 6361 6362
		if (sata_scr_valid(link))
			return ap->ops->scr_read(ap, reg, val);
		return -EOPNOTSUPP;
	}

	return sata_pmp_scr_read(link, reg, val);
6363 6364 6365 6366
}

/**
 *	sata_scr_write - write SCR register of the specified port
6367
 *	@link: ATA link to write SCR for
6368 6369 6370
 *	@reg: SCR to write
 *	@val: value to write
 *
6371
 *	Write @val to SCR register @reg of @link.  This function is
6372 6373
 *	guaranteed to succeed if @link is ap->link, the cable type of
 *	the port is SATA and the port implements ->scr_read.
6374 6375
 *
 *	LOCKING:
6376
 *	None if @link is ap->link.  Kernel thread context otherwise.
6377 6378 6379 6380
 *
 *	RETURNS:
 *	0 on success, negative errno on failure.
 */
6381
int sata_scr_write(struct ata_link *link, int reg, u32 val)
6382
{
6383 6384 6385 6386 6387 6388 6389
	if (ata_is_host_link(link)) {
		struct ata_port *ap = link->ap;

		if (sata_scr_valid(link))
			return ap->ops->scr_write(ap, reg, val);
		return -EOPNOTSUPP;
	}
6390

6391
	return sata_pmp_scr_write(link, reg, val);
6392 6393 6394 6395
}

/**
 *	sata_scr_write_flush - write SCR register of the specified port and flush
6396
 *	@link: ATA link to write SCR for
6397 6398 6399 6400 6401 6402 6403
 *	@reg: SCR to write
 *	@val: value to write
 *
 *	This function is identical to sata_scr_write() except that this
 *	function performs flush after writing to the register.
 *
 *	LOCKING:
6404
 *	None if @link is ap->link.  Kernel thread context otherwise.
6405 6406 6407 6408
 *
 *	RETURNS:
 *	0 on success, negative errno on failure.
 */
6409
int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
6410
{
6411 6412 6413
	if (ata_is_host_link(link)) {
		struct ata_port *ap = link->ap;
		int rc;
6414

6415 6416 6417 6418 6419 6420 6421
		if (sata_scr_valid(link)) {
			rc = ap->ops->scr_write(ap, reg, val);
			if (rc == 0)
				rc = ap->ops->scr_read(ap, reg, &val);
			return rc;
		}
		return -EOPNOTSUPP;
6422
	}
6423 6424

	return sata_pmp_scr_write(link, reg, val);
6425 6426 6427
}

/**
6428 6429
 *	ata_link_online - test whether the given link is online
 *	@link: ATA link to test
6430
 *
6431 6432 6433
 *	Test whether @link is online.  Note that this function returns
 *	0 if online status of @link cannot be obtained, so
 *	ata_link_online(link) != !ata_link_offline(link).
6434 6435 6436 6437 6438 6439 6440
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	1 if the port online status is available and online.
 */
6441
int ata_link_online(struct ata_link *link)
6442 6443 6444
{
	u32 sstatus;

6445 6446
	if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
	    (sstatus & 0xf) == 0x3)
6447 6448 6449 6450 6451
		return 1;
	return 0;
}

/**
6452 6453
 *	ata_link_offline - test whether the given link is offline
 *	@link: ATA link to test
6454
 *
6455 6456 6457
 *	Test whether @link is offline.  Note that this function
 *	returns 0 if offline status of @link cannot be obtained, so
 *	ata_link_online(link) != !ata_link_offline(link).
6458 6459 6460 6461 6462 6463 6464
 *
 *	LOCKING:
 *	None.
 *
 *	RETURNS:
 *	1 if the port offline status is available and offline.
 */
6465
int ata_link_offline(struct ata_link *link)
6466 6467 6468
{
	u32 sstatus;

6469 6470
	if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
	    (sstatus & 0xf) != 0x3)
6471 6472 6473
		return 1;
	return 0;
}
E
Edward Falk 已提交
6474

6475
int ata_flush_cache(struct ata_device *dev)
J
Jens Axboe 已提交
6476
{
6477
	unsigned int err_mask;
J
Jens Axboe 已提交
6478 6479 6480 6481 6482
	u8 cmd;

	if (!ata_try_flush_cache(dev))
		return 0;

6483
	if (dev->flags & ATA_DFLAG_FLUSH_EXT)
J
Jens Axboe 已提交
6484 6485 6486 6487
		cmd = ATA_CMD_FLUSH_EXT;
	else
		cmd = ATA_CMD_FLUSH;

6488 6489
	/* This is wrong. On a failed flush we get back the LBA of the lost
	   sector and we should (assuming it wasn't aborted as unknown) issue
6490
	   a further flush command to continue the writeback until it
6491
	   does not error */
6492 6493 6494 6495 6496 6497 6498
	err_mask = ata_do_simple_cmd(dev, cmd);
	if (err_mask) {
		ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n");
		return -EIO;
	}

	return 0;
J
Jens Axboe 已提交
6499 6500
}

6501
#ifdef CONFIG_PM
J
Jeff Garzik 已提交
6502 6503 6504
static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg,
			       unsigned int action, unsigned int ehi_flags,
			       int wait)
6505 6506 6507 6508
{
	unsigned long flags;
	int i, rc;

J
Jeff Garzik 已提交
6509 6510
	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];
6511
		struct ata_link *link;
6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530

		/* Previous resume operation might still be in
		 * progress.  Wait for PM_PENDING to clear.
		 */
		if (ap->pflags & ATA_PFLAG_PM_PENDING) {
			ata_port_wait_eh(ap);
			WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
		}

		/* request PM ops to EH */
		spin_lock_irqsave(ap->lock, flags);

		ap->pm_mesg = mesg;
		if (wait) {
			rc = 0;
			ap->pm_result = &rc;
		}

		ap->pflags |= ATA_PFLAG_PM_PENDING;
6531 6532 6533 6534
		__ata_port_for_each_link(link, ap) {
			link->eh_info.action |= action;
			link->eh_info.flags |= ehi_flags;
		}
6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552

		ata_port_schedule_eh(ap);

		spin_unlock_irqrestore(ap->lock, flags);

		/* wait and check result */
		if (wait) {
			ata_port_wait_eh(ap);
			WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
			if (rc)
				return rc;
		}
	}

	return 0;
}

/**
J
Jeff Garzik 已提交
6553 6554
 *	ata_host_suspend - suspend host
 *	@host: host to suspend
6555 6556
 *	@mesg: PM message
 *
J
Jeff Garzik 已提交
6557
 *	Suspend @host.  Actual operation is performed by EH.  This
6558 6559 6560 6561 6562 6563 6564 6565 6566
 *	function requests EH to perform PM operations and waits for EH
 *	to finish.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 *
 *	RETURNS:
 *	0 on success, -errno on failure.
 */
J
Jeff Garzik 已提交
6567
int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
6568
{
6569
	int rc;
6570

6571 6572 6573 6574 6575 6576
	/*
	 * disable link pm on all ports before requesting
	 * any pm activity
	 */
	ata_lpm_enable(host);

J
Jeff Garzik 已提交
6577
	rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1);
6578 6579
	if (rc == 0)
		host->dev->power.power_state = mesg;
6580 6581 6582 6583
	return rc;
}

/**
J
Jeff Garzik 已提交
6584 6585
 *	ata_host_resume - resume host
 *	@host: host to resume
6586
 *
J
Jeff Garzik 已提交
6587
 *	Resume @host.  Actual operation is performed by EH.  This
6588 6589 6590 6591 6592 6593
 *	function requests EH to perform PM operations and returns.
 *	Note that all resume operations are performed parallely.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 */
J
Jeff Garzik 已提交
6594
void ata_host_resume(struct ata_host *host)
6595
{
J
Jeff Garzik 已提交
6596 6597 6598
	ata_host_request_pm(host, PMSG_ON, ATA_EH_SOFTRESET,
			    ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0);
	host->dev->power.power_state = PMSG_ON;
6599 6600 6601

	/* reenable link pm */
	ata_lpm_disable(host);
6602
}
6603
#endif
6604

6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616
/**
 *	ata_port_start - Set port up for dma.
 *	@ap: Port to initialize
 *
 *	Called just after data structures for each port are
 *	initialized.  Allocates space for PRD table.
 *
 *	May be used as the port_start() entry in ata_port_operations.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
6617
int ata_port_start(struct ata_port *ap)
L
Linus Torvalds 已提交
6618
{
6619
	struct device *dev = ap->dev;
6620
	int rc;
L
Linus Torvalds 已提交
6621

6622 6623
	ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma,
				      GFP_KERNEL);
L
Linus Torvalds 已提交
6624 6625 6626
	if (!ap->prd)
		return -ENOMEM;

6627
	rc = ata_pad_alloc(ap, dev);
6628
	if (rc)
6629
		return rc;
L
Linus Torvalds 已提交
6630

6631 6632
	DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd,
		(unsigned long long)ap->prd_dma);
L
Linus Torvalds 已提交
6633 6634 6635
	return 0;
}

6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646
/**
 *	ata_dev_init - Initialize an ata_device structure
 *	@dev: Device structure to initialize
 *
 *	Initialize @dev in preparation for probing.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
void ata_dev_init(struct ata_device *dev)
{
T
Tejun Heo 已提交
6647 6648
	struct ata_link *link = dev->link;
	struct ata_port *ap = link->ap;
6649 6650
	unsigned long flags;

6651
	/* SATA spd limit is bound to the first device */
T
Tejun Heo 已提交
6652 6653
	link->sata_spd_limit = link->hw_sata_spd_limit;
	link->sata_spd = 0;
6654

6655 6656
	/* High bits of dev->flags are used to record warm plug
	 * requests which occur asynchronously.  Synchronize using
J
Jeff Garzik 已提交
6657
	 * host lock.
6658
	 */
6659
	spin_lock_irqsave(ap->lock, flags);
6660
	dev->flags &= ~ATA_DFLAG_INIT_MASK;
6661
	dev->horkage = 0;
6662
	spin_unlock_irqrestore(ap->lock, flags);
6663

6664 6665
	memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0,
	       sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET);
6666 6667 6668 6669 6670
	dev->pio_mask = UINT_MAX;
	dev->mwdma_mask = UINT_MAX;
	dev->udma_mask = UINT_MAX;
}

6671 6672 6673 6674
/**
 *	ata_link_init - Initialize an ata_link structure
 *	@ap: ATA port link is attached to
 *	@link: Link structure to initialize
T
Tejun Heo 已提交
6675
 *	@pmp: Port multiplier port number
6676 6677 6678 6679 6680 6681
 *
 *	Initialize @link.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 */
6682
void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
6683 6684 6685 6686 6687 6688 6689
{
	int i;

	/* clear everything except for devices */
	memset(link, 0, offsetof(struct ata_link, device[0]));

	link->ap = ap;
T
Tejun Heo 已提交
6690
	link->pmp = pmp;
6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716
	link->active_tag = ATA_TAG_POISON;
	link->hw_sata_spd_limit = UINT_MAX;

	/* can't use iterator, ap isn't initialized yet */
	for (i = 0; i < ATA_MAX_DEVICES; i++) {
		struct ata_device *dev = &link->device[i];

		dev->link = link;
		dev->devno = dev - link->device;
		ata_dev_init(dev);
	}
}

/**
 *	sata_link_init_spd - Initialize link->sata_spd_limit
 *	@link: Link to configure sata_spd_limit for
 *
 *	Initialize @link->[hw_]sata_spd_limit to the currently
 *	configured value.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 *
 *	RETURNS:
 *	0 on success, -errno on failure.
 */
6717
int sata_link_init_spd(struct ata_link *link)
6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734
{
	u32 scontrol, spd;
	int rc;

	rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
	if (rc)
		return rc;

	spd = (scontrol >> 4) & 0xf;
	if (spd)
		link->hw_sata_spd_limit &= (1 << spd) - 1;

	link->sata_spd_limit = link->hw_sata_spd_limit;

	return 0;
}

L
Linus Torvalds 已提交
6735
/**
6736 6737
 *	ata_port_alloc - allocate and initialize basic ATA port resources
 *	@host: ATA host this allocated port belongs to
L
Linus Torvalds 已提交
6738
 *
6739 6740 6741 6742
 *	Allocate and initialize basic ATA port resources.
 *
 *	RETURNS:
 *	Allocate ATA port on success, NULL on failure.
J
Jeff Garzik 已提交
6743
 *
L
Linus Torvalds 已提交
6744
 *	LOCKING:
6745
 *	Inherited from calling layer (may sleep).
L
Linus Torvalds 已提交
6746
 */
6747
struct ata_port *ata_port_alloc(struct ata_host *host)
L
Linus Torvalds 已提交
6748
{
6749
	struct ata_port *ap;
L
Linus Torvalds 已提交
6750

6751 6752 6753 6754 6755 6756
	DPRINTK("ENTER\n");

	ap = kzalloc(sizeof(*ap), GFP_KERNEL);
	if (!ap)
		return NULL;

6757
	ap->pflags |= ATA_PFLAG_INITIALIZING;
J
Jeff Garzik 已提交
6758
	ap->lock = &host->lock;
6759
	ap->flags = ATA_FLAG_DISABLED;
6760
	ap->print_id = -1;
L
Linus Torvalds 已提交
6761
	ap->ctl = ATA_DEVCTL_OBS;
J
Jeff Garzik 已提交
6762
	ap->host = host;
6763
	ap->dev = host->dev;
L
Linus Torvalds 已提交
6764
	ap->last_ctl = 0xFF;
6765 6766 6767 6768 6769 6770

#if defined(ATA_VERBOSE_DEBUG)
	/* turn on all debugging levels */
	ap->msg_enable = 0x00FF;
#elif defined(ATA_DEBUG)
	ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
T
Tejun Heo 已提交
6771
#else
6772
	ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN;
6773
#endif
L
Linus Torvalds 已提交
6774

6775 6776 6777
	INIT_DELAYED_WORK(&ap->port_task, NULL);
	INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
	INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
6778
	INIT_LIST_HEAD(&ap->eh_done_q);
6779
	init_waitqueue_head(&ap->eh_wait_q);
T
Tejun Heo 已提交
6780 6781 6782
	init_timer_deferrable(&ap->fastdrain_timer);
	ap->fastdrain_timer.function = ata_eh_fastdrain_timerfn;
	ap->fastdrain_timer.data = (unsigned long)ap;
L
Linus Torvalds 已提交
6783

6784 6785
	ap->cbl = ATA_CBL_NONE;

T
Tejun Heo 已提交
6786
	ata_link_init(ap, &ap->link, 0);
L
Linus Torvalds 已提交
6787 6788 6789 6790 6791 6792 6793 6794

#ifdef ATA_IRQ_TRAP
	ap->stats.unhandled_irq = 1;
	ap->stats.idle_irq = 1;
#endif
	return ap;
}

6795 6796 6797 6798 6799
static void ata_host_release(struct device *gendev, void *res)
{
	struct ata_host *host = dev_get_drvdata(gendev);
	int i;

6800 6801 6802
	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

6803 6804 6805 6806
		if (!ap)
			continue;

		if (ap->scsi_host)
6807 6808
			scsi_host_put(ap->scsi_host);

6809
		kfree(ap->pmp_link);
6810
		kfree(ap);
6811 6812 6813
		host->ports[i] = NULL;
	}

6814
	dev_set_drvdata(gendev, NULL);
6815 6816
}

6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881
/**
 *	ata_host_alloc - allocate and init basic ATA host resources
 *	@dev: generic device this host is associated with
 *	@max_ports: maximum number of ATA ports associated with this host
 *
 *	Allocate and initialize basic ATA host resources.  LLD calls
 *	this function to allocate a host, initializes it fully and
 *	attaches it using ata_host_register().
 *
 *	@max_ports ports are allocated and host->n_ports is
 *	initialized to @max_ports.  The caller is allowed to decrease
 *	host->n_ports before calling ata_host_register().  The unused
 *	ports will be automatically freed on registration.
 *
 *	RETURNS:
 *	Allocate ATA host on success, NULL on failure.
 *
 *	LOCKING:
 *	Inherited from calling layer (may sleep).
 */
struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
{
	struct ata_host *host;
	size_t sz;
	int i;

	DPRINTK("ENTER\n");

	if (!devres_open_group(dev, NULL, GFP_KERNEL))
		return NULL;

	/* alloc a container for our list of ATA ports (buses) */
	sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *);
	/* alloc a container for our list of ATA ports (buses) */
	host = devres_alloc(ata_host_release, sz, GFP_KERNEL);
	if (!host)
		goto err_out;

	devres_add(dev, host);
	dev_set_drvdata(dev, host);

	spin_lock_init(&host->lock);
	host->dev = dev;
	host->n_ports = max_ports;

	/* allocate ports bound to this host */
	for (i = 0; i < max_ports; i++) {
		struct ata_port *ap;

		ap = ata_port_alloc(host);
		if (!ap)
			goto err_out;

		ap->port_no = i;
		host->ports[i] = ap;
	}

	devres_remove_group(dev, NULL);
	return host;

 err_out:
	devres_release_group(dev, NULL);
	return NULL;
}

6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919
/**
 *	ata_host_alloc_pinfo - alloc host and init with port_info array
 *	@dev: generic device this host is associated with
 *	@ppi: array of ATA port_info to initialize host with
 *	@n_ports: number of ATA ports attached to this host
 *
 *	Allocate ATA host and initialize with info from @ppi.  If NULL
 *	terminated, @ppi may contain fewer entries than @n_ports.  The
 *	last entry will be used for the remaining ports.
 *
 *	RETURNS:
 *	Allocate ATA host on success, NULL on failure.
 *
 *	LOCKING:
 *	Inherited from calling layer (may sleep).
 */
struct ata_host *ata_host_alloc_pinfo(struct device *dev,
				      const struct ata_port_info * const * ppi,
				      int n_ports)
{
	const struct ata_port_info *pi;
	struct ata_host *host;
	int i, j;

	host = ata_host_alloc(dev, n_ports);
	if (!host)
		return NULL;

	for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

		if (ppi[j])
			pi = ppi[j++];

		ap->pio_mask = pi->pio_mask;
		ap->mwdma_mask = pi->mwdma_mask;
		ap->udma_mask = pi->udma_mask;
		ap->flags |= pi->flags;
6920
		ap->link.flags |= pi->link_flags;
6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931
		ap->ops = pi->port_ops;

		if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
			host->ops = pi->port_ops;
		if (!host->private_data && pi->private_data)
			host->private_data = pi->private_data;
	}

	return host;
}

6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949
static void ata_host_stop(struct device *gendev, void *res)
{
	struct ata_host *host = dev_get_drvdata(gendev);
	int i;

	WARN_ON(!(host->flags & ATA_HOST_STARTED));

	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

		if (ap->ops->port_stop)
			ap->ops->port_stop(ap);
	}

	if (host->ops->host_stop)
		host->ops->host_stop(host);
}

6950 6951 6952 6953 6954 6955 6956
/**
 *	ata_host_start - start and freeze ports of an ATA host
 *	@host: ATA host to start ports for
 *
 *	Start and then freeze ports of @host.  Started status is
 *	recorded in host->flags, so this function can be called
 *	multiple times.  Ports are guaranteed to get started only
6957 6958
 *	once.  If host->ops isn't initialized yet, its set to the
 *	first non-dummy port ops.
6959 6960 6961 6962 6963 6964 6965 6966 6967
 *
 *	LOCKING:
 *	Inherited from calling layer (may sleep).
 *
 *	RETURNS:
 *	0 if all ports are started successfully, -errno otherwise.
 */
int ata_host_start(struct ata_host *host)
{
6968 6969
	int have_stop = 0;
	void *start_dr = NULL;
6970 6971 6972 6973 6974 6975 6976 6977
	int i, rc;

	if (host->flags & ATA_HOST_STARTED)
		return 0;

	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

6978 6979 6980
		if (!host->ops && !ata_port_is_dummy(ap))
			host->ops = ap->ops;

6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996
		if (ap->ops->port_stop)
			have_stop = 1;
	}

	if (host->ops->host_stop)
		have_stop = 1;

	if (have_stop) {
		start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL);
		if (!start_dr)
			return -ENOMEM;
	}

	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

6997 6998 6999
		if (ap->ops->port_start) {
			rc = ap->ops->port_start(ap);
			if (rc) {
7000 7001
				if (rc != -ENODEV)
					dev_printk(KERN_ERR, host->dev, "failed to start port %d (errno=%d)\n", i, rc);
7002 7003 7004 7005 7006 7007
				goto err_out;
			}
		}
		ata_eh_freeze_port(ap);
	}

7008 7009
	if (start_dr)
		devres_add(host->dev, start_dr);
7010 7011 7012 7013 7014 7015 7016 7017 7018 7019
	host->flags |= ATA_HOST_STARTED;
	return 0;

 err_out:
	while (--i >= 0) {
		struct ata_port *ap = host->ports[i];

		if (ap->ops->port_stop)
			ap->ops->port_stop(ap);
	}
7020
	devres_free(start_dr);
7021 7022 7023
	return rc;
}

7024
/**
J
Jeff Garzik 已提交
7025 7026 7027 7028 7029
 *	ata_sas_host_init - Initialize a host struct
 *	@host:	host to initialize
 *	@dev:	device host is attached to
 *	@flags:	host flags
 *	@ops:	port_ops
7030 7031 7032 7033 7034
 *
 *	LOCKING:
 *	PCI/etc. bus probe sem.
 *
 */
7035
/* KILLME - the only user left is ipr */
J
Jeff Garzik 已提交
7036 7037
void ata_host_init(struct ata_host *host, struct device *dev,
		   unsigned long flags, const struct ata_port_operations *ops)
7038
{
J
Jeff Garzik 已提交
7039 7040 7041 7042
	spin_lock_init(&host->lock);
	host->dev = dev;
	host->flags = flags;
	host->ops = ops;
7043 7044
}

7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087
/**
 *	ata_host_register - register initialized ATA host
 *	@host: ATA host to register
 *	@sht: template for SCSI host
 *
 *	Register initialized ATA host.  @host is allocated using
 *	ata_host_alloc() and fully initialized by LLD.  This function
 *	starts ports, registers @host with ATA and SCSI layers and
 *	probe registered devices.
 *
 *	LOCKING:
 *	Inherited from calling layer (may sleep).
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
 */
int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
{
	int i, rc;

	/* host must have been started */
	if (!(host->flags & ATA_HOST_STARTED)) {
		dev_printk(KERN_ERR, host->dev,
			   "BUG: trying to register unstarted host\n");
		WARN_ON(1);
		return -EINVAL;
	}

	/* Blow away unused ports.  This happens when LLD can't
	 * determine the exact number of ports to allocate at
	 * allocation time.
	 */
	for (i = host->n_ports; host->ports[i]; i++)
		kfree(host->ports[i]);

	/* give ports names and add SCSI hosts */
	for (i = 0; i < host->n_ports; i++)
		host->ports[i]->print_id = ata_print_id++;

	rc = ata_scsi_add_hosts(host, sht);
	if (rc)
		return rc;

7088 7089 7090
	/* associate with ACPI nodes */
	ata_acpi_associate(host);

7091 7092 7093 7094 7095 7096 7097 7098 7099 7100
	/* set cable, sata_spd_limit and report */
	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];
		unsigned long xfer_mask;

		/* set SATA cable type if still unset */
		if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
			ap->cbl = ATA_CBL_SATA;

		/* init sata_spd_limit to the current value */
7101
		sata_link_init_spd(&ap->link);
7102

7103
		/* print per-port info to dmesg */
7104 7105 7106
		xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
					      ap->udma_mask);

7107
		if (!ata_port_is_dummy(ap)) {
7108 7109
			ata_port_printk(ap, KERN_INFO,
					"%cATA max %s %s\n",
7110
					(ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
7111
					ata_mode_string(xfer_mask),
7112
					ap->link.eh_info.desc);
7113 7114
			ata_ehi_clear_desc(&ap->link.eh_info);
		} else
7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125
			ata_port_printk(ap, KERN_INFO, "DUMMY\n");
	}

	/* perform each probe synchronously */
	DPRINTK("probe begin\n");
	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];
		int rc;

		/* probe */
		if (ap->ops->error_handler) {
T
Tejun Heo 已提交
7126
			struct ata_eh_info *ehi = &ap->link.eh_info;
7127 7128 7129 7130 7131 7132 7133
			unsigned long flags;

			ata_port_probe(ap);

			/* kick EH for boot probing */
			spin_lock_irqsave(ap->lock, flags);

7134 7135
			ehi->probe_mask =
				(1 << ata_link_max_devices(&ap->link)) - 1;
7136 7137 7138
			ehi->action |= ATA_EH_SOFTRESET;
			ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;

7139
			ap->pflags &= ~ATA_PFLAG_INITIALIZING;
7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167
			ap->pflags |= ATA_PFLAG_LOADING;
			ata_port_schedule_eh(ap);

			spin_unlock_irqrestore(ap->lock, flags);

			/* wait for EH to finish */
			ata_port_wait_eh(ap);
		} else {
			DPRINTK("ata%u: bus probe begin\n", ap->print_id);
			rc = ata_bus_probe(ap);
			DPRINTK("ata%u: bus probe end\n", ap->print_id);

			if (rc) {
				/* FIXME: do something useful here?
				 * Current libata behavior will
				 * tear down everything when
				 * the module is removed
				 * or the h/w is unplugged.
				 */
			}
		}
	}

	/* probes are done, now scan each port's disk(s) */
	DPRINTK("host probe begin\n");
	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

7168
		ata_scsi_scan_host(ap, 1);
7169
		ata_lpm_schedule(ap, ap->pm_policy);
7170 7171 7172 7173 7174
	}

	return 0;
}

7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187
/**
 *	ata_host_activate - start host, request IRQ and register it
 *	@host: target ATA host
 *	@irq: IRQ to request
 *	@irq_handler: irq_handler used when requesting IRQ
 *	@irq_flags: irq_flags used when requesting IRQ
 *	@sht: scsi_host_template to use when registering the host
 *
 *	After allocating an ATA host and initializing it, most libata
 *	LLDs perform three steps to activate the host - start host,
 *	request IRQ and register it.  This helper takes necessasry
 *	arguments and performs the three steps in one go.
 *
7188 7189 7190 7191
 *	An invalid IRQ skips the IRQ registration and expects the host to
 *	have set polling mode on the port. In this case, @irq_handler
 *	should be NULL.
 *
7192 7193 7194 7195 7196 7197 7198 7199 7200 7201
 *	LOCKING:
 *	Inherited from calling layer (may sleep).
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
 */
int ata_host_activate(struct ata_host *host, int irq,
		      irq_handler_t irq_handler, unsigned long irq_flags,
		      struct scsi_host_template *sht)
{
7202
	int i, rc;
7203 7204 7205 7206 7207

	rc = ata_host_start(host);
	if (rc)
		return rc;

7208 7209 7210 7211 7212 7213
	/* Special case for polling mode */
	if (!irq) {
		WARN_ON(irq_handler);
		return ata_host_register(host, sht);
	}

7214 7215 7216 7217 7218
	rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags,
			      dev_driver_string(host->dev), host);
	if (rc)
		return rc;

7219 7220
	for (i = 0; i < host->n_ports; i++)
		ata_port_desc(host->ports[i], "irq %d", irq);
T
Tejun Heo 已提交
7221

7222 7223 7224 7225 7226 7227 7228 7229
	rc = ata_host_register(host, sht);
	/* if failed, just free the IRQ and leave ports alone */
	if (rc)
		devm_free_irq(host->dev, irq, host);

	return rc;
}

7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240
/**
 *	ata_port_detach - Detach ATA port in prepration of device removal
 *	@ap: ATA port to be detached
 *
 *	Detach all ATA devices and the associated SCSI devices of @ap;
 *	then, remove the associated SCSI host.  @ap is guaranteed to
 *	be quiescent on return from this function.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 */
7241
static void ata_port_detach(struct ata_port *ap)
7242 7243
{
	unsigned long flags;
7244
	struct ata_link *link;
7245
	struct ata_device *dev;
7246 7247

	if (!ap->ops->error_handler)
7248
		goto skip_eh;
7249 7250

	/* tell EH we're leaving & flush EH */
7251
	spin_lock_irqsave(ap->lock, flags);
7252
	ap->pflags |= ATA_PFLAG_UNLOADING;
7253
	spin_unlock_irqrestore(ap->lock, flags);
7254 7255 7256

	ata_port_wait_eh(ap);

7257 7258
	/* EH is now guaranteed to see UNLOADING - EH context belongs
	 * to us.  Disable all existing devices.
7259
	 */
7260 7261 7262 7263
	ata_port_for_each_link(link, ap) {
		ata_link_for_each_dev(dev, link)
			ata_dev_disable(dev);
	}
7264 7265 7266 7267 7268

	/* Final freeze & EH.  All in-flight commands are aborted.  EH
	 * will be skipped and retrials will be terminated with bad
	 * target.
	 */
7269
	spin_lock_irqsave(ap->lock, flags);
7270
	ata_port_freeze(ap);	/* won't be thawed */
7271
	spin_unlock_irqrestore(ap->lock, flags);
7272 7273

	ata_port_wait_eh(ap);
7274
	cancel_rearming_delayed_work(&ap->hotplug_task);
7275

7276
 skip_eh:
7277
	/* remove the associated SCSI host */
J
Jeff Garzik 已提交
7278
	scsi_remove_host(ap->scsi_host);
7279 7280
}

T
Tejun Heo 已提交
7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295
/**
 *	ata_host_detach - Detach all ports of an ATA host
 *	@host: Host to detach
 *
 *	Detach all ports of @host.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 */
void ata_host_detach(struct ata_host *host)
{
	int i;

	for (i = 0; i < host->n_ports; i++)
		ata_port_detach(host->ports[i]);
7296 7297 7298

	/* the host is dead now, dissociate ACPI */
	ata_acpi_dissociate(host);
T
Tejun Heo 已提交
7299 7300
}

L
Linus Torvalds 已提交
7301 7302 7303
/**
 *	ata_std_ports - initialize ioaddr with standard port offsets.
 *	@ioaddr: IO address structure to be initialized
E
Edward Falk 已提交
7304 7305 7306 7307 7308 7309 7310
 *
 *	Utility function which initializes data_addr, error_addr,
 *	feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
 *	device_addr, status_addr, and command_addr to standard offsets
 *	relative to cmd_addr.
 *
 *	Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
L
Linus Torvalds 已提交
7311
 */
E
Edward Falk 已提交
7312

L
Linus Torvalds 已提交
7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326
void ata_std_ports(struct ata_ioports *ioaddr)
{
	ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
	ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
	ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
	ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
	ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
	ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
	ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
	ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
	ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
	ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
}

E
Edward Falk 已提交
7327

7328 7329
#ifdef CONFIG_PCI

L
Linus Torvalds 已提交
7330 7331 7332 7333
/**
 *	ata_pci_remove_one - PCI layer callback for device removal
 *	@pdev: PCI device that was removed
 *
T
Tejun Heo 已提交
7334 7335 7336
 *	PCI layer indicates to libata via this hook that hot-unplug or
 *	module unload event has occurred.  Detach all ports.  Resource
 *	release is handled via devres.
L
Linus Torvalds 已提交
7337 7338 7339 7340
 *
 *	LOCKING:
 *	Inherited from PCI layer (may sleep).
 */
7341
void ata_pci_remove_one(struct pci_dev *pdev)
L
Linus Torvalds 已提交
7342
{
7343
	struct device *dev = &pdev->dev;
J
Jeff Garzik 已提交
7344
	struct ata_host *host = dev_get_drvdata(dev);
L
Linus Torvalds 已提交
7345

T
Tejun Heo 已提交
7346
	ata_host_detach(host);
L
Linus Torvalds 已提交
7347 7348 7349
}

/* move to PCI subsystem */
J
Jeff Garzik 已提交
7350
int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
L
Linus Torvalds 已提交
7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381
{
	unsigned long tmp = 0;

	switch (bits->width) {
	case 1: {
		u8 tmp8 = 0;
		pci_read_config_byte(pdev, bits->reg, &tmp8);
		tmp = tmp8;
		break;
	}
	case 2: {
		u16 tmp16 = 0;
		pci_read_config_word(pdev, bits->reg, &tmp16);
		tmp = tmp16;
		break;
	}
	case 4: {
		u32 tmp32 = 0;
		pci_read_config_dword(pdev, bits->reg, &tmp32);
		tmp = tmp32;
		break;
	}

	default:
		return -EINVAL;
	}

	tmp &= bits->mask;

	return (tmp == bits->val) ? 1 : 0;
}
J
Jens Axboe 已提交
7382

7383
#ifdef CONFIG_PM
7384
void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
J
Jens Axboe 已提交
7385 7386
{
	pci_save_state(pdev);
7387
	pci_disable_device(pdev);
7388

7389
	if (mesg.event == PM_EVENT_SUSPEND)
7390
		pci_set_power_state(pdev, PCI_D3hot);
J
Jens Axboe 已提交
7391 7392
}

7393
int ata_pci_device_do_resume(struct pci_dev *pdev)
J
Jens Axboe 已提交
7394
{
7395 7396
	int rc;

J
Jens Axboe 已提交
7397 7398
	pci_set_power_state(pdev, PCI_D0);
	pci_restore_state(pdev);
7399

T
Tejun Heo 已提交
7400
	rc = pcim_enable_device(pdev);
7401 7402 7403 7404 7405 7406
	if (rc) {
		dev_printk(KERN_ERR, &pdev->dev,
			   "failed to enable device after resume (%d)\n", rc);
		return rc;
	}

J
Jens Axboe 已提交
7407
	pci_set_master(pdev);
7408
	return 0;
7409 7410
}

7411
int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
7412
{
J
Jeff Garzik 已提交
7413
	struct ata_host *host = dev_get_drvdata(&pdev->dev);
7414 7415
	int rc = 0;

J
Jeff Garzik 已提交
7416
	rc = ata_host_suspend(host, mesg);
7417 7418 7419
	if (rc)
		return rc;

7420
	ata_pci_device_do_suspend(pdev, mesg);
7421 7422 7423 7424 7425 7426

	return 0;
}

int ata_pci_device_resume(struct pci_dev *pdev)
{
J
Jeff Garzik 已提交
7427
	struct ata_host *host = dev_get_drvdata(&pdev->dev);
7428
	int rc;
7429

7430 7431 7432 7433
	rc = ata_pci_device_do_resume(pdev);
	if (rc == 0)
		ata_host_resume(host);
	return rc;
J
Jens Axboe 已提交
7434
}
7435 7436
#endif /* CONFIG_PM */

L
Linus Torvalds 已提交
7437 7438 7439 7440 7441
#endif /* CONFIG_PCI */


static int __init ata_init(void)
{
A
Andrew Morton 已提交
7442
	ata_probe_timeout *= HZ;
L
Linus Torvalds 已提交
7443 7444 7445 7446
	ata_wq = create_workqueue("ata");
	if (!ata_wq)
		return -ENOMEM;

7447 7448 7449 7450 7451 7452
	ata_aux_wq = create_singlethread_workqueue("ata_aux");
	if (!ata_aux_wq) {
		destroy_workqueue(ata_wq);
		return -ENOMEM;
	}

L
Linus Torvalds 已提交
7453 7454 7455 7456 7457 7458 7459
	printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
	return 0;
}

static void __exit ata_exit(void)
{
	destroy_workqueue(ata_wq);
7460
	destroy_workqueue(ata_aux_wq);
L
Linus Torvalds 已提交
7461 7462
}

7463
subsys_initcall(ata_init);
L
Linus Torvalds 已提交
7464 7465
module_exit(ata_exit);

7466
static unsigned long ratelimit_time;
I
Ingo Molnar 已提交
7467
static DEFINE_SPINLOCK(ata_ratelimit_lock);
7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486

int ata_ratelimit(void)
{
	int rc;
	unsigned long flags;

	spin_lock_irqsave(&ata_ratelimit_lock, flags);

	if (time_after(jiffies, ratelimit_time)) {
		rc = 1;
		ratelimit_time = jiffies + (HZ/5);
	} else
		rc = 0;

	spin_unlock_irqrestore(&ata_ratelimit_lock, flags);

	return rc;
}

7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532
/**
 *	ata_wait_register - wait until register value changes
 *	@reg: IO-mapped register
 *	@mask: Mask to apply to read register value
 *	@val: Wait condition
 *	@interval_msec: polling interval in milliseconds
 *	@timeout_msec: timeout in milliseconds
 *
 *	Waiting for some bits of register to change is a common
 *	operation for ATA controllers.  This function reads 32bit LE
 *	IO-mapped register @reg and tests for the following condition.
 *
 *	(*@reg & mask) != val
 *
 *	If the condition is met, it returns; otherwise, the process is
 *	repeated after @interval_msec until timeout.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	The final register value.
 */
u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
		      unsigned long interval_msec,
		      unsigned long timeout_msec)
{
	unsigned long timeout;
	u32 tmp;

	tmp = ioread32(reg);

	/* Calculate timeout _after_ the first read to make sure
	 * preceding writes reach the controller before starting to
	 * eat away the timeout.
	 */
	timeout = jiffies + (timeout_msec * HZ) / 1000;

	while ((tmp & mask) == val && time_before(jiffies, timeout)) {
		msleep(interval_msec);
		tmp = ioread32(reg);
	}

	return tmp;
}

T
Tejun Heo 已提交
7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564
/*
 * Dummy port_ops
 */
static void ata_dummy_noret(struct ata_port *ap)	{ }
static int ata_dummy_ret0(struct ata_port *ap)		{ return 0; }
static void ata_dummy_qc_noret(struct ata_queued_cmd *qc) { }

static u8 ata_dummy_check_status(struct ata_port *ap)
{
	return ATA_DRDY;
}

static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
{
	return AC_ERR_SYSTEM;
}

const struct ata_port_operations ata_dummy_port_ops = {
	.check_status		= ata_dummy_check_status,
	.check_altstatus	= ata_dummy_check_status,
	.dev_select		= ata_noop_dev_select,
	.qc_prep		= ata_noop_qc_prep,
	.qc_issue		= ata_dummy_qc_issue,
	.freeze			= ata_dummy_noret,
	.thaw			= ata_dummy_noret,
	.error_handler		= ata_dummy_noret,
	.post_internal_cmd	= ata_dummy_qc_noret,
	.irq_clear		= ata_dummy_noret,
	.port_start		= ata_dummy_ret0,
	.port_stop		= ata_dummy_noret,
};

7565 7566 7567 7568
const struct ata_port_info ata_dummy_port_info = {
	.port_ops		= &ata_dummy_port_ops,
};

L
Linus Torvalds 已提交
7569 7570 7571 7572 7573 7574
/*
 * libata is essentially a library of internal helper functions for
 * low-level ATA host controller drivers.  As such, the API/ABI is
 * likely to change as new drivers are added and updated.
 * Do not depend on ABI/API stability.
 */
7575 7576 7577
EXPORT_SYMBOL_GPL(sata_deb_timing_normal);
EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug);
EXPORT_SYMBOL_GPL(sata_deb_timing_long);
T
Tejun Heo 已提交
7578
EXPORT_SYMBOL_GPL(ata_dummy_port_ops);
7579
EXPORT_SYMBOL_GPL(ata_dummy_port_info);
L
Linus Torvalds 已提交
7580 7581
EXPORT_SYMBOL_GPL(ata_std_bios_param);
EXPORT_SYMBOL_GPL(ata_std_ports);
J
Jeff Garzik 已提交
7582
EXPORT_SYMBOL_GPL(ata_host_init);
7583
EXPORT_SYMBOL_GPL(ata_host_alloc);
7584
EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
7585
EXPORT_SYMBOL_GPL(ata_host_start);
7586
EXPORT_SYMBOL_GPL(ata_host_register);
7587
EXPORT_SYMBOL_GPL(ata_host_activate);
T
Tejun Heo 已提交
7588
EXPORT_SYMBOL_GPL(ata_host_detach);
L
Linus Torvalds 已提交
7589 7590
EXPORT_SYMBOL_GPL(ata_sg_init);
EXPORT_SYMBOL_GPL(ata_sg_init_one);
7591
EXPORT_SYMBOL_GPL(ata_hsm_move);
7592
EXPORT_SYMBOL_GPL(ata_qc_complete);
7593
EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
L
Linus Torvalds 已提交
7594 7595 7596 7597 7598
EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
EXPORT_SYMBOL_GPL(ata_tf_load);
EXPORT_SYMBOL_GPL(ata_tf_read);
EXPORT_SYMBOL_GPL(ata_noop_dev_select);
EXPORT_SYMBOL_GPL(ata_std_dev_select);
7599
EXPORT_SYMBOL_GPL(sata_print_link_status);
L
Linus Torvalds 已提交
7600 7601 7602 7603 7604 7605
EXPORT_SYMBOL_GPL(ata_tf_to_fis);
EXPORT_SYMBOL_GPL(ata_tf_from_fis);
EXPORT_SYMBOL_GPL(ata_check_status);
EXPORT_SYMBOL_GPL(ata_altstatus);
EXPORT_SYMBOL_GPL(ata_exec_command);
EXPORT_SYMBOL_GPL(ata_port_start);
7606
EXPORT_SYMBOL_GPL(ata_sff_port_start);
L
Linus Torvalds 已提交
7607
EXPORT_SYMBOL_GPL(ata_interrupt);
7608
EXPORT_SYMBOL_GPL(ata_do_set_mode);
T
Tejun Heo 已提交
7609 7610
EXPORT_SYMBOL_GPL(ata_data_xfer);
EXPORT_SYMBOL_GPL(ata_data_xfer_noirq);
7611
EXPORT_SYMBOL_GPL(ata_std_qc_defer);
L
Linus Torvalds 已提交
7612
EXPORT_SYMBOL_GPL(ata_qc_prep);
7613
EXPORT_SYMBOL_GPL(ata_dumb_qc_prep);
7614
EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
L
Linus Torvalds 已提交
7615 7616 7617 7618 7619
EXPORT_SYMBOL_GPL(ata_bmdma_setup);
EXPORT_SYMBOL_GPL(ata_bmdma_start);
EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
EXPORT_SYMBOL_GPL(ata_bmdma_status);
EXPORT_SYMBOL_GPL(ata_bmdma_stop);
7620 7621 7622 7623 7624
EXPORT_SYMBOL_GPL(ata_bmdma_freeze);
EXPORT_SYMBOL_GPL(ata_bmdma_thaw);
EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh);
EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);
EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
L
Linus Torvalds 已提交
7625
EXPORT_SYMBOL_GPL(ata_port_probe);
7626
EXPORT_SYMBOL_GPL(ata_dev_disable);
7627
EXPORT_SYMBOL_GPL(sata_set_spd);
7628 7629
EXPORT_SYMBOL_GPL(sata_link_debounce);
EXPORT_SYMBOL_GPL(sata_link_resume);
L
Linus Torvalds 已提交
7630
EXPORT_SYMBOL_GPL(ata_bus_reset);
7631
EXPORT_SYMBOL_GPL(ata_std_prereset);
7632
EXPORT_SYMBOL_GPL(ata_std_softreset);
T
Tejun Heo 已提交
7633
EXPORT_SYMBOL_GPL(sata_link_hardreset);
7634 7635
EXPORT_SYMBOL_GPL(sata_std_hardreset);
EXPORT_SYMBOL_GPL(ata_std_postreset);
7636 7637
EXPORT_SYMBOL_GPL(ata_dev_classify);
EXPORT_SYMBOL_GPL(ata_dev_pair);
L
Linus Torvalds 已提交
7638
EXPORT_SYMBOL_GPL(ata_port_disable);
7639
EXPORT_SYMBOL_GPL(ata_ratelimit);
7640
EXPORT_SYMBOL_GPL(ata_wait_register);
7641
EXPORT_SYMBOL_GPL(ata_busy_sleep);
7642
EXPORT_SYMBOL_GPL(ata_wait_after_reset);
7643
EXPORT_SYMBOL_GPL(ata_wait_ready);
T
Tejun Heo 已提交
7644
EXPORT_SYMBOL_GPL(ata_port_queue_task);
L
Linus Torvalds 已提交
7645 7646 7647
EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
7648
EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
7649
EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
L
Linus Torvalds 已提交
7650
EXPORT_SYMBOL_GPL(ata_host_intr);
7651 7652 7653 7654
EXPORT_SYMBOL_GPL(sata_scr_valid);
EXPORT_SYMBOL_GPL(sata_scr_read);
EXPORT_SYMBOL_GPL(sata_scr_write);
EXPORT_SYMBOL_GPL(sata_scr_write_flush);
7655 7656
EXPORT_SYMBOL_GPL(ata_link_online);
EXPORT_SYMBOL_GPL(ata_link_offline);
7657
#ifdef CONFIG_PM
J
Jeff Garzik 已提交
7658 7659
EXPORT_SYMBOL_GPL(ata_host_suspend);
EXPORT_SYMBOL_GPL(ata_host_resume);
7660
#endif /* CONFIG_PM */
7661 7662
EXPORT_SYMBOL_GPL(ata_id_string);
EXPORT_SYMBOL_GPL(ata_id_c_string);
7663
EXPORT_SYMBOL_GPL(ata_id_to_dma_mode);
L
Linus Torvalds 已提交
7664 7665
EXPORT_SYMBOL_GPL(ata_scsi_simulate);

7666
EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
A
Alan Cox 已提交
7667 7668 7669
EXPORT_SYMBOL_GPL(ata_timing_compute);
EXPORT_SYMBOL_GPL(ata_timing_merge);

L
Linus Torvalds 已提交
7670 7671
#ifdef CONFIG_PCI
EXPORT_SYMBOL_GPL(pci_test_config_bits);
7672
EXPORT_SYMBOL_GPL(ata_pci_init_sff_host);
T
Tejun Heo 已提交
7673
EXPORT_SYMBOL_GPL(ata_pci_init_bmdma);
7674
EXPORT_SYMBOL_GPL(ata_pci_prepare_sff_host);
L
Linus Torvalds 已提交
7675 7676
EXPORT_SYMBOL_GPL(ata_pci_init_one);
EXPORT_SYMBOL_GPL(ata_pci_remove_one);
7677
#ifdef CONFIG_PM
7678 7679
EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend);
EXPORT_SYMBOL_GPL(ata_pci_device_do_resume);
J
Jens Axboe 已提交
7680 7681
EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
EXPORT_SYMBOL_GPL(ata_pci_device_resume);
7682
#endif /* CONFIG_PM */
A
Alan Cox 已提交
7683 7684
EXPORT_SYMBOL_GPL(ata_pci_default_filter);
EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
L
Linus Torvalds 已提交
7685
#endif /* CONFIG_PCI */
J
Jens Axboe 已提交
7686

7687
EXPORT_SYMBOL_GPL(sata_pmp_qc_defer_cmd_switch);
7688 7689 7690 7691 7692
EXPORT_SYMBOL_GPL(sata_pmp_std_prereset);
EXPORT_SYMBOL_GPL(sata_pmp_std_hardreset);
EXPORT_SYMBOL_GPL(sata_pmp_std_postreset);
EXPORT_SYMBOL_GPL(sata_pmp_do_eh);

T
Tejun Heo 已提交
7693 7694 7695
EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);
EXPORT_SYMBOL_GPL(ata_ehi_push_desc);
EXPORT_SYMBOL_GPL(ata_ehi_clear_desc);
7696 7697 7698 7699
EXPORT_SYMBOL_GPL(ata_port_desc);
#ifdef CONFIG_PCI
EXPORT_SYMBOL_GPL(ata_port_pbar_desc);
#endif /* CONFIG_PCI */
7700
EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
7701
EXPORT_SYMBOL_GPL(ata_link_abort);
7702
EXPORT_SYMBOL_GPL(ata_port_abort);
7703
EXPORT_SYMBOL_GPL(ata_port_freeze);
7704
EXPORT_SYMBOL_GPL(sata_async_notification);
7705 7706
EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
7707 7708
EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
T
Tejun Heo 已提交
7709
EXPORT_SYMBOL_GPL(ata_do_eh);
7710
EXPORT_SYMBOL_GPL(ata_irq_on);
A
Akira Iguchi 已提交
7711
EXPORT_SYMBOL_GPL(ata_dev_try_classify);
A
Alan Cox 已提交
7712 7713 7714 7715 7716

EXPORT_SYMBOL_GPL(ata_cable_40wire);
EXPORT_SYMBOL_GPL(ata_cable_80wire);
EXPORT_SYMBOL_GPL(ata_cable_unknown);
EXPORT_SYMBOL_GPL(ata_cable_sata);