libata-acpi.c 28.2 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 * libata-acpi.c
 * Provides ACPI support for PATA/SATA.
 *
 * Copyright (C) 2006 Intel Corp.
 * Copyright (C) 2006 Randy Dunlap
 */

9
#include <linux/module.h>
10 11 12 13 14 15 16 17
#include <linux/ata.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/acpi.h>
#include <linux/libata.h>
#include <linux/pci.h>
18
#include <linux/slab.h>
19
#include <linux/pm_runtime.h>
20
#include <scsi/scsi_device.h>
21 22 23 24
#include "libata.h"

#include <acpi/acpi_bus.h>

25
unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT;
26
module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644);
27
MODULE_PARM_DESC(acpi_gtf_filter, "filter mask for ACPI _GTF commands, set to filter out (0x1=set xfermode, 0x2=lock/freeze lock, 0x4=DIPM, 0x8=FPDMA non-zero offset, 0x10=FPDMA DMA Setup FIS auto-activate)");
28

29
#define NO_PORT_MULT		0xffff
30
#define SATA_ADR(root, pmp)	(((root) << 16) | (pmp))
31 32

#define REGS_PER_GTF		7
33 34 35
struct ata_acpi_gtf {
	u8	tf[REGS_PER_GTF];	/* regs. 0x1f1 - 0x1f7 */
} __packed;
36

37 38 39 40 41 42 43
/*
 *	Helper - belongs in the PCI layer somewhere eventually
 */
static int is_pci_dev(struct device *dev)
{
	return (dev->bus == &pci_bus_type);
}
44

45 46 47 48 49 50
static void ata_acpi_clear_gtf(struct ata_device *dev)
{
	kfree(dev->gtf_cache);
	dev->gtf_cache = NULL;
}

51 52 53 54 55 56 57 58
/**
 * ata_ap_acpi_handle - provide the acpi_handle for an ata_port
 * @ap: the acpi_handle returned will correspond to this port
 *
 * Returns the acpi_handle for the ACPI namespace object corresponding to
 * the ata_port passed into the function, or NULL if no such object exists
 */
acpi_handle ata_ap_acpi_handle(struct ata_port *ap)
59 60 61 62
{
	if (ap->flags & ATA_FLAG_ACPI_SATA)
		return NULL;

63 64
	return ap->scsi_host ?
		DEVICE_ACPI_HANDLE(&ap->scsi_host->shost_gendev) : NULL;
65
}
66
EXPORT_SYMBOL(ata_ap_acpi_handle);
67

68 69 70 71 72 73 74 75
/**
 * ata_dev_acpi_handle - provide the acpi_handle for an ata_device
 * @dev: the acpi_device returned will correspond to this port
 *
 * Returns the acpi_handle for the ACPI namespace object corresponding to
 * the ata_device passed into the function, or NULL if no such object exists
 */
acpi_handle ata_dev_acpi_handle(struct ata_device *dev)
76 77 78 79
{
	acpi_integer adr;
	struct ata_port *ap = dev->link->ap;

80
	if (libata_noacpi || dev->flags & ATA_DFLAG_ACPI_DISABLED)
81 82
		return NULL;

83 84 85 86 87 88 89
	if (ap->flags & ATA_FLAG_ACPI_SATA) {
		if (!sata_pmp_attached(ap))
			adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
		else
			adr = SATA_ADR(ap->port_no, dev->link->pmp);
		return acpi_get_child(DEVICE_ACPI_HANDLE(ap->host->dev), adr);
	} else
90
		return acpi_get_child(ata_ap_acpi_handle(ap), dev->devno);
91
}
92
EXPORT_SYMBOL(ata_dev_acpi_handle);
93

94 95 96 97 98 99 100 101 102
/* @ap and @dev are the same as ata_acpi_handle_hotplug() */
static void ata_acpi_detach_device(struct ata_port *ap, struct ata_device *dev)
{
	if (dev)
		dev->flags |= ATA_DFLAG_DETACH;
	else {
		struct ata_link *tlink;
		struct ata_device *tdev;

Tejun Heo's avatar
Tejun Heo committed
103 104
		ata_for_each_link(tlink, ap, EDGE)
			ata_for_each_dev(tdev, tlink, ALL)
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
				tdev->flags |= ATA_DFLAG_DETACH;
	}

	ata_port_schedule_eh(ap);
}

/**
 * ata_acpi_handle_hotplug - ACPI event handler backend
 * @ap: ATA port ACPI event occurred
 * @dev: ATA device ACPI event occurred (can be NULL)
 * @event: ACPI event which occurred
 *
 * All ACPI bay / device realted events end up in this function.  If
 * the event is port-wide @dev is NULL.  If the event is specific to a
 * device, @dev points to it.
 *
 * Hotplug (as opposed to unplug) notification is always handled as
 * port-wide while unplug only kills the target device on device-wide
 * event.
 *
 * LOCKING:
 * ACPI notify handler context.  May sleep.
 */
static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev,
129
				    u32 event)
130
{
131
	struct ata_eh_info *ehi = &ap->link.eh_info;
132 133
	int wait = 0;
	unsigned long flags;
134

135
	spin_lock_irqsave(ap->lock, flags);
136 137 138 139 140
	/*
	 * When dock driver calls into the routine, it will always use
	 * ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
	 * ACPI_NOTIFY_EJECT_REQUEST for remove
	 */
141 142 143 144
	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
	case ACPI_NOTIFY_DEVICE_CHECK:
		ata_ehi_push_desc(ehi, "ACPI event");
145

146 147
		ata_ehi_hotplugged(ehi);
		ata_port_freeze(ap);
148 149 150 151 152 153 154
		break;
	case ACPI_NOTIFY_EJECT_REQUEST:
		ata_ehi_push_desc(ehi, "ACPI event");

		ata_acpi_detach_device(ap, dev);
		wait = 1;
		break;
155 156
	}

157 158
	spin_unlock_irqrestore(ap->lock, flags);

159
	if (wait) {
160
		ata_port_wait_eh(ap);
161 162
		flush_work(&ap->hotplug_task.work);
	}
163 164 165 166 167 168
}

static void ata_acpi_dev_notify_dock(acpi_handle handle, u32 event, void *data)
{
	struct ata_device *dev = data;

169
	ata_acpi_handle_hotplug(dev->link->ap, dev, event);
170 171 172 173 174 175
}

static void ata_acpi_ap_notify_dock(acpi_handle handle, u32 event, void *data)
{
	struct ata_port *ap = data;

176
	ata_acpi_handle_hotplug(ap, NULL, event);
177 178
}

179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
static void ata_acpi_uevent(struct ata_port *ap, struct ata_device *dev,
	u32 event)
{
	struct kobject *kobj = NULL;
	char event_string[20];
	char *envp[] = { event_string, NULL };

	if (dev) {
		if (dev->sdev)
			kobj = &dev->sdev->sdev_gendev.kobj;
	} else
		kobj = &ap->dev->kobj;

	if (kobj) {
		snprintf(event_string, 20, "BAY_EVENT=%d", event);
		kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
	}
}

static void ata_acpi_ap_uevent(acpi_handle handle, u32 event, void *data)
{
	ata_acpi_uevent(data, NULL, event);
}

static void ata_acpi_dev_uevent(acpi_handle handle, u32 event, void *data)
{
	struct ata_device *dev = data;
	ata_acpi_uevent(dev->link->ap, dev, event);
}

209
static const struct acpi_dock_ops ata_acpi_dev_dock_ops = {
210 211 212 213
	.handler = ata_acpi_dev_notify_dock,
	.uevent = ata_acpi_dev_uevent,
};

214
static const struct acpi_dock_ops ata_acpi_ap_dock_ops = {
215 216 217 218
	.handler = ata_acpi_ap_notify_dock,
	.uevent = ata_acpi_ap_uevent,
};

219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
void ata_acpi_hotplug_init(struct ata_host *host)
{
	int i;

	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];
		acpi_handle handle;
		struct ata_device *dev;

		if (!ap)
			continue;

		handle = ata_ap_acpi_handle(ap);
		if (handle) {
			/* we might be on a docking station */
			register_hotplug_dock_device(handle,
						     &ata_acpi_ap_dock_ops, ap,
						     NULL, NULL);
		}

		ata_for_each_dev(dev, &ap->link, ALL) {
			handle = ata_dev_acpi_handle(dev);
			if (!handle)
				continue;

			/* we might be on a docking station */
			register_hotplug_dock_device(handle,
						     &ata_acpi_dev_dock_ops,
						     dev, NULL, NULL);
		}
	}
}

252 253 254 255 256 257 258 259 260 261 262 263
/**
 * ata_acpi_dissociate - dissociate ATA host from ACPI objects
 * @host: target ATA host
 *
 * This function is called during driver detach after the whole host
 * is shut down.
 *
 * LOCKING:
 * EH context.
 */
void ata_acpi_dissociate(struct ata_host *host)
{
264 265 266 267 268 269 270 271 272
	int i;

	/* Restore initial _GTM values so that driver which attaches
	 * afterward can use them too.
	 */
	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];
		const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);

273
		if (ata_ap_acpi_handle(ap) && gtm)
274 275
			ata_acpi_stm(ap, gtm);
	}
276 277
}

278 279
static int __ata_acpi_gtm(struct ata_port *ap, acpi_handle handle,
			  struct ata_acpi_gtm *gtm)
280 281 282 283 284 285
{
	struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
	union acpi_object *out_obj;
	acpi_status status;
	int rc = 0;

286
	status = acpi_evaluate_object(handle, "_GTM", NULL, &output);
287 288 289 290 291 292 293

	rc = -ENOENT;
	if (status == AE_NOT_FOUND)
		goto out_free;

	rc = -EINVAL;
	if (ACPI_FAILURE(status)) {
294 295
		ata_port_err(ap, "ACPI get timing mode failed (AE 0x%x)\n",
			     status);
296 297 298 299 300
		goto out_free;
	}

	out_obj = output.pointer;
	if (out_obj->type != ACPI_TYPE_BUFFER) {
301 302
		ata_port_warn(ap, "_GTM returned unexpected object type 0x%x\n",
			      out_obj->type);
303 304 305 306 307

		goto out_free;
	}

	if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) {
308 309
		ata_port_err(ap, "_GTM returned invalid length %d\n",
			     out_obj->buffer.length);
310 311 312 313 314 315 316 317 318 319
		goto out_free;
	}

	memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm));
	rc = 0;
 out_free:
	kfree(output.pointer);
	return rc;
}

320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
/**
 * ata_acpi_gtm - execute _GTM
 * @ap: target ATA port
 * @gtm: out parameter for _GTM result
 *
 * Evaluate _GTM and store the result in @gtm.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
 */
int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *gtm)
{
	if (ata_ap_acpi_handle(ap))
		return __ata_acpi_gtm(ap, ata_ap_acpi_handle(ap), gtm);
	else
		return -EINVAL;
}

341 342
EXPORT_SYMBOL_GPL(ata_acpi_gtm);

343 344 345 346 347 348 349 350 351 352 353 354 355
/**
 * ata_acpi_stm - execute _STM
 * @ap: target ATA port
 * @stm: timing parameter to _STM
 *
 * Evaluate _STM with timing parameter @stm.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
 */
356
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm)
357 358
{
	acpi_status status;
359
	struct ata_acpi_gtm		stm_buf = *stm;
360 361 362 363 364
	struct acpi_object_list         input;
	union acpi_object               in_params[3];

	in_params[0].type = ACPI_TYPE_BUFFER;
	in_params[0].buffer.length = sizeof(struct ata_acpi_gtm);
365
	in_params[0].buffer.pointer = (u8 *)&stm_buf;
366 367 368
	/* Buffers for id may need byteswapping ? */
	in_params[1].type = ACPI_TYPE_BUFFER;
	in_params[1].buffer.length = 512;
369
	in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
370 371
	in_params[2].type = ACPI_TYPE_BUFFER;
	in_params[2].buffer.length = 512;
372
	in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
373 374 375 376

	input.count = 3;
	input.pointer = in_params;

377 378
	status = acpi_evaluate_object(ata_ap_acpi_handle(ap), "_STM", &input,
				      NULL);
379 380 381 382

	if (status == AE_NOT_FOUND)
		return -ENOENT;
	if (ACPI_FAILURE(status)) {
383 384
		ata_port_err(ap, "ACPI set timing mode failed (status=0x%x)\n",
			     status);
385 386 387 388 389
		return -EINVAL;
	}
	return 0;
}

390 391
EXPORT_SYMBOL_GPL(ata_acpi_stm);

392
/**
393
 * ata_dev_get_GTF - get the drive bootup default taskfile settings
394
 * @dev: target ATA device
395
 * @gtf: output parameter for buffer containing _GTF taskfile arrays
396 397 398 399 400 401 402 403 404
 *
 * This applies to both PATA and SATA drives.
 *
 * The _GTF method has no input parameters.
 * It returns a variable number of register set values (registers
 * hex 1F1..1F7, taskfiles).
 * The <variable number> is not known in advance, so have ACPI-CA
 * allocate the buffer as needed and return it, then free it later.
 *
405 406 407 408
 * LOCKING:
 * EH context.
 *
 * RETURNS:
409 410
 * Number of taskfiles on success, 0 if _GTF doesn't exist.  -EINVAL
 * if _GTF is invalid.
411
 */
412
static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
413
{
414
	struct ata_port *ap = dev->link->ap;
415 416 417
	acpi_status status;
	struct acpi_buffer output;
	union acpi_object *out_obj;
418
	int rc = 0;
419

420 421 422 423 424 425
	/* if _GTF is cached, use the cached value */
	if (dev->gtf_cache) {
		out_obj = dev->gtf_cache;
		goto done;
	}

426 427 428
	/* set up output buffer */
	output.length = ACPI_ALLOCATE_BUFFER;
	output.pointer = NULL;	/* ACPI-CA sets this; save/free it later */
429 430

	if (ata_msg_probe(ap))
431 432
		ata_dev_dbg(dev, "%s: ENTER: port#: %d\n",
			    __func__, ap->port_no);
433 434

	/* _GTF has no input parameters */
435 436
	status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_GTF", NULL,
				      &output);
437
	out_obj = dev->gtf_cache = output.pointer;
438

439
	if (ACPI_FAILURE(status)) {
440
		if (status != AE_NOT_FOUND) {
441 442
			ata_dev_warn(dev, "_GTF evaluation failed (AE 0x%x)\n",
				     status);
443
			rc = -EINVAL;
444 445
		}
		goto out_free;
446 447 448 449
	}

	if (!output.length || !output.pointer) {
		if (ata_msg_probe(ap))
450 451 452 453
			ata_dev_dbg(dev, "%s: Run _GTF: length or ptr is NULL (0x%llx, 0x%p)\n",
				    __func__,
				    (unsigned long long)output.length,
				    output.pointer);
454
		rc = -EINVAL;
455
		goto out_free;
456 457 458
	}

	if (out_obj->type != ACPI_TYPE_BUFFER) {
459 460
		ata_dev_warn(dev, "_GTF unexpected object type 0x%x\n",
			     out_obj->type);
461
		rc = -EINVAL;
462
		goto out_free;
463 464
	}

465
	if (out_obj->buffer.length % REGS_PER_GTF) {
466 467
		ata_dev_warn(dev, "unexpected _GTF length (%d)\n",
			     out_obj->buffer.length);
468
		rc = -EINVAL;
469
		goto out_free;
470 471
	}

472
 done:
473
	rc = out_obj->buffer.length / REGS_PER_GTF;
474 475 476
	if (gtf) {
		*gtf = (void *)out_obj->buffer.pointer;
		if (ata_msg_probe(ap))
477 478
			ata_dev_dbg(dev, "%s: returning gtf=%p, gtf_count=%d\n",
				    __func__, *gtf, rc);
479
	}
480 481 482
	return rc;

 out_free:
483
	ata_acpi_clear_gtf(dev);
484
	return rc;
485 486
}

487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
/**
 * ata_acpi_gtm_xfermode - determine xfermode from GTM parameter
 * @dev: target device
 * @gtm: GTM parameter to use
 *
 * Determine xfermask for @dev from @gtm.
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * Determined xfermask.
 */
unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
				    const struct ata_acpi_gtm *gtm)
{
503 504 505 506
	unsigned long xfer_mask = 0;
	unsigned int type;
	int unit;
	u8 mode;
507 508 509 510 511 512

	/* we always use the 0 slot for crap hardware */
	unit = dev->devno;
	if (!(gtm->flags & 0x10))
		unit = 0;

513 514 515
	/* PIO */
	mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio);
	xfer_mask |= ata_xfer_mode2mask(mode);
516 517 518 519 520

	/* See if we have MWDMA or UDMA data. We don't bother with
	 * MWDMA if UDMA is available as this means the BIOS set UDMA
	 * and our error changedown if it works is UDMA to PIO anyway.
	 */
521 522 523 524 525 526 527
	if (!(gtm->flags & (1 << (2 * unit))))
		type = ATA_SHIFT_MWDMA;
	else
		type = ATA_SHIFT_UDMA;

	mode = ata_timing_cycle2mode(type, gtm->drive[unit].dma);
	xfer_mask |= ata_xfer_mode2mask(mode);
528

529
	return xfer_mask;
530 531 532
}
EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask);

533 534 535
/**
 * ata_acpi_cbl_80wire		-	Check for 80 wire cable
 * @ap: Port to check
536
 * @gtm: GTM data to use
537
 *
538
 * Return 1 if the @gtm indicates the BIOS selected an 80wire mode.
539
 */
540
int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm)
541
{
542 543
	struct ata_device *dev;

Tejun Heo's avatar
Tejun Heo committed
544
	ata_for_each_dev(dev, &ap->link, ENABLED) {
545 546 547 548 549 550 551 552 553
		unsigned long xfer_mask, udma_mask;

		xfer_mask = ata_acpi_gtm_xfermask(dev, gtm);
		ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask);

		if (udma_mask & ~ATA_UDMA_MASK_40C)
			return 1;
	}

554 555 556 557
	return 0;
}
EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);

558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
static void ata_acpi_gtf_to_tf(struct ata_device *dev,
			       const struct ata_acpi_gtf *gtf,
			       struct ata_taskfile *tf)
{
	ata_tf_init(dev, tf);

	tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
	tf->protocol = ATA_PROT_NODATA;
	tf->feature = gtf->tf[0];	/* 0x1f1 */
	tf->nsect   = gtf->tf[1];	/* 0x1f2 */
	tf->lbal    = gtf->tf[2];	/* 0x1f3 */
	tf->lbam    = gtf->tf[3];	/* 0x1f4 */
	tf->lbah    = gtf->tf[4];	/* 0x1f5 */
	tf->device  = gtf->tf[5];	/* 0x1f6 */
	tf->command = gtf->tf[6];	/* 0x1f7 */
}

575 576
static int ata_acpi_filter_tf(struct ata_device *dev,
			      const struct ata_taskfile *tf,
577 578
			      const struct ata_taskfile *ptf)
{
579
	if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) {
580 581 582 583 584 585 586 587
		/* libata doesn't use ACPI to configure transfer mode.
		 * It will only confuse device configuration.  Skip.
		 */
		if (tf->command == ATA_CMD_SET_FEATURES &&
		    tf->feature == SETFEATURES_XFER)
			return 1;
	}

588
	if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) {
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
		/* BIOS writers, sorry but we don't wanna lock
		 * features unless the user explicitly said so.
		 */

		/* DEVICE CONFIGURATION FREEZE LOCK */
		if (tf->command == ATA_CMD_CONF_OVERLAY &&
		    tf->feature == ATA_DCO_FREEZE_LOCK)
			return 1;

		/* SECURITY FREEZE LOCK */
		if (tf->command == ATA_CMD_SEC_FREEZE_LOCK)
			return 1;

		/* SET MAX LOCK and SET MAX FREEZE LOCK */
		if ((!ptf || ptf->command != ATA_CMD_READ_NATIVE_MAX) &&
		    tf->command == ATA_CMD_SET_MAX &&
		    (tf->feature == ATA_SET_MAX_LOCK ||
		     tf->feature == ATA_SET_MAX_FREEZE_LOCK))
			return 1;
	}

610 611
	if (tf->command == ATA_CMD_SET_FEATURES &&
	    tf->feature == SETFEATURES_SATA_ENABLE) {
612
		/* inhibit enabling DIPM */
613
		if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM &&
614 615
		    tf->nsect == SATA_DIPM)
			return 1;
616 617

		/* inhibit FPDMA non-zero offset */
618
		if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET &&
619 620 621 622 623
		    (tf->nsect == SATA_FPDMA_OFFSET ||
		     tf->nsect == SATA_FPDMA_IN_ORDER))
			return 1;

		/* inhibit FPDMA auto activation */
624
		if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA &&
625 626
		    tf->nsect == SATA_FPDMA_AA)
			return 1;
627 628
	}

629 630 631
	return 0;
}

632
/**
633
 * ata_acpi_run_tf - send taskfile registers to host controller
634
 * @dev: target ATA device
635 636
 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
 *
637
 * Outputs ATA taskfile to standard ATA host controller.
638 639 640 641 642 643 644 645 646
 * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
 * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
 * hob_lbal, hob_lbam, and hob_lbah.
 *
 * This function waits for idle (!BUSY and !DRQ) after writing
 * registers.  If the control register has a new value, this
 * function also waits for idle after writing control and before
 * writing the remaining registers.
 *
647 648 649 650
 * LOCKING:
 * EH context.
 *
 * RETURNS:
651 652
 * 1 if command is executed successfully.  0 if ignored, rejected or
 * filtered out, -errno on other errors.
653
 */
654
static int ata_acpi_run_tf(struct ata_device *dev,
655 656
			   const struct ata_acpi_gtf *gtf,
			   const struct ata_acpi_gtf *prev_gtf)
657
{
658 659
	struct ata_taskfile *pptf = NULL;
	struct ata_taskfile tf, ptf, rtf;
660
	unsigned int err_mask;
661
	const char *level;
662
	const char *descr;
663 664
	char msg[60];
	int rc;
665

666 667 668 669
	if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
	    && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
	    && (gtf->tf[6] == 0))
		return 0;
670

671 672 673 674 675 676
	ata_acpi_gtf_to_tf(dev, gtf, &tf);
	if (prev_gtf) {
		ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf);
		pptf = &ptf;
	}

677
	if (!ata_acpi_filter_tf(dev, &tf, pptf)) {
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
		rtf = tf;
		err_mask = ata_exec_internal(dev, &rtf, NULL,
					     DMA_NONE, NULL, 0, 0);

		switch (err_mask) {
		case 0:
			level = KERN_DEBUG;
			snprintf(msg, sizeof(msg), "succeeded");
			rc = 1;
			break;

		case AC_ERR_DEV:
			level = KERN_INFO;
			snprintf(msg, sizeof(msg),
				 "rejected by device (Stat=0x%02x Err=0x%02x)",
				 rtf.command, rtf.feature);
			rc = 0;
			break;

		default:
			level = KERN_ERR;
			snprintf(msg, sizeof(msg),
				 "failed (Emask=0x%x Stat=0x%02x Err=0x%02x)",
				 err_mask, rtf.command, rtf.feature);
			rc = -EIO;
			break;
		}
	} else {
706
		level = KERN_INFO;
707
		snprintf(msg, sizeof(msg), "filtered out");
708
		rc = 0;
709
	}
710
	descr = ata_get_cmd_descript(tf.command);
711

712
	ata_dev_printk(dev, level,
713
		       "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n",
714
		       tf.command, tf.feature, tf.nsect, tf.lbal,
715 716
		       tf.lbam, tf.lbah, tf.device,
		       (descr ? descr : "unknown"), msg);
717 718

	return rc;
719 720 721 722
}

/**
 * ata_acpi_exec_tfs - get then write drive taskfile settings
723
 * @dev: target ATA device
724
 * @nr_executed: out parameter for the number of executed commands
725
 *
726
 * Evaluate _GTF and execute returned taskfiles.
727 728 729 730 731
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
732 733
 * Number of executed taskfiles on success, 0 if _GTF doesn't exist.
 * -errno on other errors.
734
 */
735
static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
736
{
737
	struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL;
738 739 740
	int gtf_count, i, rc;

	/* get taskfiles */
741 742 743 744
	rc = ata_dev_get_GTF(dev, &gtf);
	if (rc < 0)
		return rc;
	gtf_count = rc;
745 746

	/* execute them */
747 748
	for (i = 0; i < gtf_count; i++, gtf++) {
		rc = ata_acpi_run_tf(dev, gtf, pgtf);
749 750
		if (rc < 0)
			break;
751
		if (rc) {
752
			(*nr_executed)++;
753 754
			pgtf = gtf;
		}
755 756
	}

757
	ata_acpi_clear_gtf(dev);
758

759 760 761
	if (rc < 0)
		return rc;
	return 0;
762 763
}

764 765
/**
 * ata_acpi_push_id - send Identify data to drive
766
 * @dev: target ATA device
767 768 769 770 771 772
 *
 * _SDD ACPI object: for SATA mode only
 * Must be after Identify (Packet) Device -- uses its data
 * ATM this function never returns a failure.  It is an optional
 * method and if it fails for whatever reason, we should still
 * just keep going.
773 774 775 776 777
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
778
 * 0 on success, -ENOENT if _SDD doesn't exist, -errno on failure.
779
 */
780
static int ata_acpi_push_id(struct ata_device *dev)
781
{
782
	struct ata_port *ap = dev->link->ap;
783 784 785
	acpi_status status;
	struct acpi_object_list input;
	union acpi_object in_params[1];
786 787

	if (ata_msg_probe(ap))
788 789
		ata_dev_dbg(dev, "%s: ix = %d, port#: %d\n",
			    __func__, dev->devno, ap->port_no);
790 791 792 793 794 795

	/* Give the drive Identify data to the drive via the _SDD method */
	/* _SDD: set up input parameters */
	input.count = 1;
	input.pointer = in_params;
	in_params[0].type = ACPI_TYPE_BUFFER;
796 797
	in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
	in_params[0].buffer.pointer = (u8 *)dev->id;
798 799 800
	/* Output buffer: _SDD has no output */

	/* It's OK for _SDD to be missing too. */
801
	swap_buf_le16(dev->id, ATA_ID_WORDS);
802 803
	status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_SDD", &input,
				      NULL);
804
	swap_buf_le16(dev->id, ATA_ID_WORDS);
805

806 807 808 809
	if (status == AE_NOT_FOUND)
		return -ENOENT;

	if (ACPI_FAILURE(status)) {
810
		ata_dev_warn(dev, "ACPI _SDD failed (AE 0x%x)\n", status);
811 812
		return -EIO;
	}
813

814
	return 0;
815 816
}

817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
/**
 * ata_acpi_on_suspend - ATA ACPI hook called on suspend
 * @ap: target ATA port
 *
 * This function is called when @ap is about to be suspended.  All
 * devices are already put to sleep but the port_suspend() callback
 * hasn't been executed yet.  Error return from this function aborts
 * suspend.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
int ata_acpi_on_suspend(struct ata_port *ap)
{
834 835
	/* nada */
	return 0;
836 837
}

838 839 840 841 842 843 844 845 846 847 848 849
/**
 * ata_acpi_on_resume - ATA ACPI hook called on resume
 * @ap: target ATA port
 *
 * This function is called when @ap is resumed - right after port
 * itself is resumed but before any EH action is taken.
 *
 * LOCKING:
 * EH context.
 */
void ata_acpi_on_resume(struct ata_port *ap)
{
850
	const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
851
	struct ata_device *dev;
852

853
	if (ata_ap_acpi_handle(ap) && gtm) {
854 855 856
		/* _GTM valid */

		/* restore timing parameters */
857
		ata_acpi_stm(ap, gtm);
858

859 860 861 862
		/* _GTF should immediately follow _STM so that it can
		 * use values set by _STM.  Cache _GTF result and
		 * schedule _GTF.
		 */
Tejun Heo's avatar
Tejun Heo committed
863
		ata_for_each_dev(dev, &ap->link, ALL) {
864
			ata_acpi_clear_gtf(dev);
865 866
			if (ata_dev_enabled(dev) &&
			    ata_dev_get_GTF(dev, NULL) >= 0)
867 868 869 870 871 872 873
				dev->flags |= ATA_DFLAG_ACPI_PENDING;
		}
	} else {
		/* SATA _GTF needs to be evaulated after _SDD and
		 * there's no reason to evaluate IDE _GTF early
		 * without _STM.  Clear cache and schedule _GTF.
		 */
Tejun Heo's avatar
Tejun Heo committed
874
		ata_for_each_dev(dev, &ap->link, ALL) {
875
			ata_acpi_clear_gtf(dev);
876 877
			if (ata_dev_enabled(dev))
				dev->flags |= ATA_DFLAG_ACPI_PENDING;
878 879
		}
	}
880 881
}

882
static int ata_acpi_choose_suspend_state(struct ata_device *dev, bool runtime)
883 884
{
	int d_max_in = ACPI_STATE_D3_COLD;
885 886
	if (!runtime)
		goto out;
887 888 889 890 891 892 893 894 895

	/*
	 * For ATAPI, runtime D3 cold is only allowed
	 * for ZPODD in zero power ready state
	 */
	if (dev->class == ATA_DEV_ATAPI &&
	    !(zpodd_dev_enabled(dev) && zpodd_zpready(dev)))
		d_max_in = ACPI_STATE_D3_HOT;

896
out:
897 898 899 900
	return acpi_pm_device_sleep_state(&dev->sdev->sdev_gendev,
					  NULL, d_max_in);
}

901
static void sata_acpi_set_state(struct ata_port *ap, pm_message_t state)
902
{
903
	bool runtime = PMSG_IS_AUTO(state);
904
	struct ata_device *dev;
905
	acpi_handle handle;
906
	int acpi_state;
907

Tejun Heo's avatar
Tejun Heo committed
908
	ata_for_each_dev(dev, &ap->link, ENABLED) {
909
		handle = ata_dev_acpi_handle(dev);
910 911 912
		if (!handle)
			continue;

913 914
		if (!(state.event & PM_EVENT_RESUME)) {
			acpi_state = ata_acpi_choose_suspend_state(dev, runtime);
915 916
			if (acpi_state == ACPI_STATE_D0)
				continue;
917
			if (runtime && zpodd_dev_enabled(dev) &&
918 919 920
			    acpi_state == ACPI_STATE_D3_COLD)
				zpodd_enable_run_wake(dev);
			acpi_bus_set_power(handle, acpi_state);
921
		} else {
922
			if (runtime && zpodd_dev_enabled(dev))
923
				zpodd_disable_run_wake(dev);
924 925
			acpi_bus_set_power(handle, ACPI_STATE_D0);
		}
926
	}
927
}
928

929 930 931 932 933 934 935 936 937 938 939 940 941 942
/* ACPI spec requires _PS0 when IDE power on and _PS3 when power off */
static void pata_acpi_set_state(struct ata_port *ap, pm_message_t state)
{
	struct ata_device *dev;
	acpi_handle port_handle;

	port_handle = ata_ap_acpi_handle(ap);
	if (!port_handle)
		return;

	/* channel first and then drives for power on and vica versa
	   for power off */
	if (state.event & PM_EVENT_RESUME)
		acpi_bus_set_power(port_handle, ACPI_STATE_D0);
943

944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
	ata_for_each_dev(dev, &ap->link, ENABLED) {
		acpi_handle dev_handle = ata_dev_acpi_handle(dev);
		if (!dev_handle)
			continue;

		acpi_bus_set_power(dev_handle, state.event & PM_EVENT_RESUME ?
						ACPI_STATE_D0 : ACPI_STATE_D3);
	}

	if (!(state.event & PM_EVENT_RESUME))
		acpi_bus_set_power(port_handle, ACPI_STATE_D3);
}

/**
 * ata_acpi_set_state - set the port power state
 * @ap: target ATA port
 * @state: state, on/off
 *
 * This function sets a proper ACPI D state for the device on
 * system and runtime PM operations.
 */
void ata_acpi_set_state(struct ata_port *ap, pm_message_t state)
{
	if (ap->flags & ATA_FLAG_ACPI_SATA)
		sata_acpi_set_state(ap, state);
	else
		pata_acpi_set_state(ap, state);
971 972
}

973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
/**
 * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
 * @dev: target ATA device
 *
 * This function is called when @dev is about to be configured.
 * IDENTIFY data might have been modified after this hook is run.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * Positive number if IDENTIFY data needs to be refreshed, 0 if not,
 * -errno on failure.
 */
int ata_acpi_on_devcfg(struct ata_device *dev)
{
989 990
	struct ata_port *ap = dev->link->ap;
	struct ata_eh_context *ehc = &ap->link.eh_context;
991
	int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
992
	int nr_executed = 0;
993 994
	int rc;

995
	if (!ata_dev_acpi_handle(dev))
996 997 998 999 1000 1001 1002 1003 1004 1005
		return 0;

	/* do we need to do _GTF? */
	if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
	    !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
		return 0;

	/* do _SDD if SATA */
	if (acpi_sata) {
		rc = ata_acpi_push_id(dev);
1006
		if (rc && rc != -ENOENT)
1007 1008 1009 1010
			goto acpi_err;
	}

	/* do _GTF */
1011 1012
	rc = ata_acpi_exec_tfs(dev, &nr_executed);
	if (rc)
1013 1014 1015 1016 1017
		goto acpi_err;

	dev->flags &= ~ATA_DFLAG_ACPI_PENDING;

	/* refresh IDENTIFY page if any _GTF command has been executed */
1018
	if (nr_executed) {
1019 1020
		rc = ata_dev_reread_id(dev, 0);
		if (rc < 0) {
1021 1022
			ata_dev_err(dev,
				    "failed to IDENTIFY after ACPI commands\n");
1023 1024 1025 1026 1027 1028 1029
			return rc;
		}
	}

	return 0;

 acpi_err:
1030 1031 1032
	/* ignore evaluation failure if we can continue safely */
	if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
		return 0;
1033

1034 1035 1036 1037
	/* fail and let EH retry once more for unknown IO errors */
	if (!(dev->flags & ATA_DFLAG_ACPI_FAILED)) {
		dev->flags |= ATA_DFLAG_ACPI_FAILED;
		return rc;
1038
	}
1039

1040
	dev->flags |= ATA_DFLAG_ACPI_DISABLED;
1041
	ata_dev_warn(dev, "ACPI: failed the second time, disabled\n");
1042 1043 1044 1045 1046 1047 1048

	/* We can safely continue if no _GTF command has been executed
	 * and port is not frozen.
	 */
	if (!nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
		return 0;

1049 1050
	return rc;
}
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062

/**
 * ata_acpi_on_disable - ATA ACPI hook called when a device is disabled
 * @dev: target ATA device
 *
 * This function is called when @dev is about to be disabled.
 *
 * LOCKING:
 * EH context.
 */
void ata_acpi_on_disable(struct ata_device *dev)
{
1063
	ata_acpi_clear_gtf(dev);
1064
}
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084

static int compat_pci_ata(struct ata_port *ap)
{
	struct device *dev = ap->tdev.parent;
	struct pci_dev *pdev;

	if (!is_pci_dev(dev))
		return 0;

	pdev = to_pci_dev(dev);

	if ((pdev->class >> 8) != PCI_CLASS_STORAGE_SATA &&
	    (pdev->class >> 8) != PCI_CLASS_STORAGE_IDE)
		return 0;

	return 1;
}

static int ata_acpi_bind_host(struct ata_port *ap, acpi_handle *handle)
{
1085
	if (libata_noacpi || ap->flags & ATA_FLAG_ACPI_SATA)
1086 1087 1088 1089 1090 1091 1092 1093
		return -ENODEV;

	*handle = acpi_get_child(DEVICE_ACPI_HANDLE(ap->tdev.parent),
			ap->port_no);

	if (!*handle)
		return -ENODEV;

1094
	if (__ata_acpi_gtm(ap, *handle, &ap->__acpi_init_gtm) == 0)
1095 1096
		ap->pflags |= ATA_PFLAG_INIT_GTM_VALID;

1097 1098 1099 1100 1101 1102 1103 1104
	return 0;
}

static int ata_acpi_bind_device(struct ata_port *ap, struct scsi_device *sdev,
				acpi_handle *handle)
{
	struct ata_device *ata_dev;

1105 1106 1107 1108 1109 1110 1111
	if (ap->flags & ATA_FLAG_ACPI_SATA) {
		if (!sata_pmp_attached(ap))
			ata_dev = &ap->link.device[sdev->id];
		else
			ata_dev = &ap->pmp_link[sdev->channel].device[sdev->id];
	}
	else {
1112
		ata_dev = &ap->link.device[sdev->id];
1113
	}
1114

1115
	*handle = ata_dev_acpi_handle(ata_dev);
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158

	if (!*handle)
		return -ENODEV;

	return 0;
}

static int is_ata_port(const struct device *dev)
{
	return dev->type == &ata_port_type;
}

static struct ata_port *dev_to_ata_port(struct device *dev)
{
	while (!is_ata_port(dev)) {
		if (!dev->parent)
			return NULL;
		dev = dev->parent;
	}
	return to_ata_port(dev);
}

static int ata_acpi_find_device(struct device *dev, acpi_handle *handle)
{
	struct ata_port *ap = dev_to_ata_port(dev);

	if (!ap)
		return -ENODEV;

	if (!compat_pci_ata(ap))
		return -ENODEV;

	if (scsi_is_host_device(dev))
		return ata_acpi_bind_host(ap, handle);
	else if (scsi_is_sdev_device(dev)) {
		struct scsi_device *sdev = to_scsi_device(dev);

		return ata_acpi_bind_device(ap, sdev, handle);
	} else
		return -ENODEV;
}

static struct acpi_bus_type ata_acpi_bus = {
1159
	.name = "ATA",
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
	.find_device = ata_acpi_find_device,
};

int ata_acpi_register(void)
{
	return scsi_register_acpi_bus_type(&ata_acpi_bus);
}

void ata_acpi_unregister(void)
{
	scsi_unregister_acpi_bus_type(&ata_acpi_bus);
}