[deliverable/linux.git] / drivers / ata / libata-zpodd.c

#include <linux/libata.h>
#include <linux/cdrom.h>
#include <linux/pm_runtime.h>
#include <linux/module.h>
#include <scsi/scsi_device.h>

#include "libata.h"

static int zpodd_poweroff_delay = 30; /* 30 seconds for power off delay */
module_param(zpodd_poweroff_delay, int, 0644);
MODULE_PARM_DESC(zpodd_poweroff_delay, "Poweroff delay for ZPODD in seconds");

enum odd_mech_type {
	ODD_MECH_TYPE_SLOT,
	ODD_MECH_TYPE_DRAWER,
	ODD_MECH_TYPE_UNSUPPORTED,
};

struct zpodd {
	enum odd_mech_type	mech_type; /* init during probe, RO afterwards */
	struct ata_device	*dev;

	/* The following fields are synchronized by PM core. */
	bool			from_notify; /* resumed as a result of
					      * acpi wake notification */
	bool			zp_ready; /* ZP ready state */
	unsigned long		last_ready; /* last ZP ready timestamp */
	bool			zp_sampled; /* ZP ready state sampled */
	bool			powered_off; /* ODD is powered off
					      *	during suspend */
};

static int eject_tray(struct ata_device *dev)
{
	struct ata_taskfile tf = {};
	const char cdb[] = {  GPCMD_START_STOP_UNIT,
		0, 0, 0,
		0x02,     /* LoEj */
		0, 0, 0, 0, 0, 0, 0,
	};

	tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
	tf.command = ATA_CMD_PACKET;
	tf.protocol = ATAPI_PROT_NODATA;

	return ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
}

/* Per the spec, only slot type and drawer type ODD can be supported */
static enum odd_mech_type zpodd_get_mech_type(struct ata_device *dev)
{
	char buf[16];
	unsigned int ret;
	struct rm_feature_desc *desc = (void *)(buf + 8);
	struct ata_taskfile tf = {};

	char cdb[] = {  GPCMD_GET_CONFIGURATION,
			2,      /* only 1 feature descriptor requested */
			0, 3,   /* 3, removable medium feature */
			0, 0, 0,/* reserved */
			0, sizeof(buf),
			0, 0, 0,
	};

	tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
	tf.command = ATA_CMD_PACKET;
	tf.protocol = ATAPI_PROT_PIO;
	tf.lbam = sizeof(buf);

	ret = ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
				buf, sizeof(buf), 0);
	if (ret)
		return ODD_MECH_TYPE_UNSUPPORTED;

	if (be16_to_cpu(desc->feature_code) != 3)
		return ODD_MECH_TYPE_UNSUPPORTED;

	if (desc->mech_type == 0 && desc->load == 0 && desc->eject == 1)
		return ODD_MECH_TYPE_SLOT;
	else if (desc->mech_type == 1 && desc->load == 0 && desc->eject == 1)
		return ODD_MECH_TYPE_DRAWER;
	else
		return ODD_MECH_TYPE_UNSUPPORTED;
}

static bool odd_can_poweroff(struct ata_device *ata_dev)
{
	acpi_handle handle;
	acpi_status status;
	struct acpi_device *acpi_dev;

	handle = ata_dev_acpi_handle(ata_dev);
	if (!handle)
		return false;

	status = acpi_bus_get_device(handle, &acpi_dev);
	if (ACPI_FAILURE(status))
		return false;

	return acpi_device_can_poweroff(acpi_dev);
}

/* Test if ODD is zero power ready by sense code */
static bool zpready(struct ata_device *dev)
{
	u8 sense_key, *sense_buf;
	unsigned int ret, asc, ascq, add_len;
	struct zpodd *zpodd = dev->zpodd;

	ret = atapi_eh_tur(dev, &sense_key);

	if (!ret || sense_key != NOT_READY)
		return false;

	sense_buf = dev->link->ap->sector_buf;
	ret = atapi_eh_request_sense(dev, sense_buf, sense_key);
	if (ret)
		return false;

	/* sense valid */
	if ((sense_buf[0] & 0x7f) != 0x70)
		return false;

	add_len = sense_buf[7];
	/* has asc and ascq */
	if (add_len < 6)
		return false;

	asc = sense_buf[12];
	ascq = sense_buf[13];

	if (zpodd->mech_type == ODD_MECH_TYPE_SLOT)
		/* no media inside */
		return asc == 0x3a;
	else
		/* no media inside and door closed */
		return asc == 0x3a && ascq == 0x01;
}

/*
 * Update the zpodd->zp_ready field. This field will only be set
 * if the ODD has stayed in ZP ready state for zpodd_poweroff_delay
 * time, and will be used to decide if power off is allowed. If it
 * is set, it will be cleared during resume from powered off state.
 */
void zpodd_on_suspend(struct ata_device *dev)
{
	struct zpodd *zpodd = dev->zpodd;
	unsigned long expires;

	if (!zpready(dev)) {
		zpodd->zp_sampled = false;
		return;
	}

	if (!zpodd->zp_sampled) {
		zpodd->zp_sampled = true;
		zpodd->last_ready = jiffies;
		return;
	}

	expires = zpodd->last_ready +
		  msecs_to_jiffies(zpodd_poweroff_delay * 1000);
	if (time_before(jiffies, expires))
		return;

	zpodd->zp_ready = true;
}

bool zpodd_zpready(struct ata_device *dev)
{
	struct zpodd *zpodd = dev->zpodd;
	return zpodd->zp_ready;
}

/*
 * Enable runtime wake capability through ACPI and set the powered_off flag,
 * this flag will be used during resume to decide what operations are needed
 * to take.
 */
void zpodd_enable_run_wake(struct ata_device *dev)
{
	struct zpodd *zpodd = dev->zpodd;

	zpodd->powered_off = true;
	device_set_run_wake(&dev->sdev->sdev_gendev, true);
	acpi_pm_device_run_wake(&dev->sdev->sdev_gendev, true);
}

/* Disable runtime wake capability if it is enabled */
void zpodd_disable_run_wake(struct ata_device *dev)
{
	struct zpodd *zpodd = dev->zpodd;

	if (zpodd->powered_off) {
		acpi_pm_device_run_wake(&dev->sdev->sdev_gendev, false);
		device_set_run_wake(&dev->sdev->sdev_gendev, false);
	}
}

/*
 * Post power on processing after the ODD has been recovered. If the
 * ODD wasn't powered off during suspend, it doesn't do anything.
 *
 * For drawer type ODD, if it is powered on due to user pressed the
 * eject button, the tray needs to be ejected. This can only be done
 * after the ODD has been recovered, i.e. link is initialized and
 * device is able to process NON_DATA PIO command, as eject needs to
 * send command for the ODD to process.
 *
 * The from_notify flag set in wake notification handler function
 * zpodd_wake_dev represents if power on is due to user's action.
 *
 * For both types of ODD, several fields need to be reset.
 */
void zpodd_post_poweron(struct ata_device *dev)
{
	struct zpodd *zpodd = dev->zpodd;

	if (!zpodd->powered_off)
		return;

	zpodd->powered_off = false;

	if (zpodd->from_notify) {
		zpodd->from_notify = false;
		if (zpodd->mech_type == ODD_MECH_TYPE_DRAWER)
			eject_tray(dev);
	}

	zpodd->zp_sampled = false;
	zpodd->zp_ready = false;
}

static void zpodd_wake_dev(acpi_handle handle, u32 event, void *context)
{
	struct ata_device *ata_dev = context;
	struct zpodd *zpodd = ata_dev->zpodd;
	struct device *dev = &ata_dev->sdev->sdev_gendev;

	if (event == ACPI_NOTIFY_DEVICE_WAKE && ata_dev &&
			pm_runtime_suspended(dev)) {
		zpodd->from_notify = true;
		pm_runtime_resume(dev);
	}
}

static void ata_acpi_add_pm_notifier(struct ata_device *dev)
{
	acpi_handle handle = ata_dev_acpi_handle(dev);
	acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
				    zpodd_wake_dev, dev);
}

static void ata_acpi_remove_pm_notifier(struct ata_device *dev)
{
	acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->sdev->sdev_gendev);
	acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY, zpodd_wake_dev);
}

void zpodd_init(struct ata_device *dev)
{
	enum odd_mech_type mech_type;
	struct zpodd *zpodd;

	if (dev->zpodd)
		return;

	if (!odd_can_poweroff(dev))
		return;

	mech_type = zpodd_get_mech_type(dev);
	if (mech_type == ODD_MECH_TYPE_UNSUPPORTED)
		return;

	zpodd = kzalloc(sizeof(struct zpodd), GFP_KERNEL);
	if (!zpodd)
		return;

	zpodd->mech_type = mech_type;

	ata_acpi_add_pm_notifier(dev);
	zpodd->dev = dev;
	dev->zpodd = zpodd;
}

void zpodd_exit(struct ata_device *dev)
{
	ata_acpi_remove_pm_notifier(dev);
	kfree(dev->zpodd);
	dev->zpodd = NULL;
}
Commit	Line	Data
afe75951 AL	1	#include <linux/libata.h>
afe75951 AL	2	#include <linux/cdrom.h>
f064a20d	3	#include <linux/pm_runtime.h>
3dc67440	4	#include <linux/module.h>
f064a20d	5	#include <scsi/scsi_device.h>
afe75951 AL	6
	7	#include "libata.h"
	8
3dc67440 AL	9	static int zpodd_poweroff_delay = 30; /* 30 seconds for power off delay */
	10	module_param(zpodd_poweroff_delay, int, 0644);
	11	MODULE_PARM_DESC(zpodd_poweroff_delay, "Poweroff delay for ZPODD in seconds");
	12
afe75951 AL	13	enum odd_mech_type {
	14	ODD_MECH_TYPE_SLOT,
	15	ODD_MECH_TYPE_DRAWER,
	16	ODD_MECH_TYPE_UNSUPPORTED,
	17	};
	18
	19	struct zpodd {
	20	enum odd_mech_type mech_type; /* init during probe, RO afterwards */
	21	struct ata_device *dev;
f064a20d AL	22
	23	/* The following fields are synchronized by PM core. */
	24	bool from_notify; /* resumed as a result of
	25	* acpi wake notification */
3dc67440 AL	26	bool zp_ready; /* ZP ready state */
	27	unsigned long last_ready; /* last ZP ready timestamp */
	28	bool zp_sampled; /* ZP ready state sampled */
21334205 AL	29	bool powered_off; /* ODD is powered off
21334205 AL	30	* during suspend */
afe75951 AL	31	};
afe75951 AL	32
21334205 AL	33	static int eject_tray(struct ata_device *dev)
	34	{
	35	struct ata_taskfile tf = {};
	36	const char cdb[] = { GPCMD_START_STOP_UNIT,
	37	0, 0, 0,
	38	0x02, /* LoEj */
	39	0, 0, 0, 0, 0, 0, 0,
	40	};
	41
	42	tf.flags = ATA_TFLAG_ISADDR \| ATA_TFLAG_DEVICE;
	43	tf.command = ATA_CMD_PACKET;
	44	tf.protocol = ATAPI_PROT_NODATA;
	45
	46	return ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
	47	}
	48
afe75951 AL	49	/* Per the spec, only slot type and drawer type ODD can be supported */
	50	static enum odd_mech_type zpodd_get_mech_type(struct ata_device *dev)
	51	{
	52	char buf[16];
	53	unsigned int ret;
	54	struct rm_feature_desc desc = (void )(buf + 8);
	55	struct ata_taskfile tf = {};
	56
	57	char cdb[] = { GPCMD_GET_CONFIGURATION,
	58	2, /* only 1 feature descriptor requested */
	59	0, 3, /* 3, removable medium feature */
	60	0, 0, 0,/* reserved */
	61	0, sizeof(buf),
	62	0, 0, 0,
	63	};
	64
	65	tf.flags = ATA_TFLAG_ISADDR \| ATA_TFLAG_DEVICE;
	66	tf.command = ATA_CMD_PACKET;
	67	tf.protocol = ATAPI_PROT_PIO;
	68	tf.lbam = sizeof(buf);
	69
	70	ret = ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
	71	buf, sizeof(buf), 0);
	72	if (ret)
	73	return ODD_MECH_TYPE_UNSUPPORTED;
	74
	75	if (be16_to_cpu(desc->feature_code) != 3)
	76	return ODD_MECH_TYPE_UNSUPPORTED;
	77
	78	if (desc->mech_type == 0 && desc->load == 0 && desc->eject == 1)
	79	return ODD_MECH_TYPE_SLOT;
	80	else if (desc->mech_type == 1 && desc->load == 0 && desc->eject == 1)
	81	return ODD_MECH_TYPE_DRAWER;
	82	else
	83	return ODD_MECH_TYPE_UNSUPPORTED;
	84	}
	85
	86	static bool odd_can_poweroff(struct ata_device *ata_dev)
	87	{
	88	acpi_handle handle;
	89	acpi_status status;
	90	struct acpi_device *acpi_dev;
	91
	92	handle = ata_dev_acpi_handle(ata_dev);
	93	if (!handle)
	94	return false;
	95
	96	status = acpi_bus_get_device(handle, &acpi_dev);
	97	if (ACPI_FAILURE(status))
	98	return false;
	99
	100	return acpi_device_can_poweroff(acpi_dev);
	101	}
	102
3dc67440 AL	103	/* Test if ODD is zero power ready by sense code */
	104	static bool zpready(struct ata_device *dev)
	105	{
	106	u8 sense_key, *sense_buf;
	107	unsigned int ret, asc, ascq, add_len;
	108	struct zpodd *zpodd = dev->zpodd;
	109
	110	ret = atapi_eh_tur(dev, &sense_key);
	111
	112	if (!ret \|\| sense_key != NOT_READY)
	113	return false;
	114
	115	sense_buf = dev->link->ap->sector_buf;
	116	ret = atapi_eh_request_sense(dev, sense_buf, sense_key);
	117	if (ret)
	118	return false;
	119
	120	/* sense valid */
	121	if ((sense_buf[0] & 0x7f) != 0x70)
	122	return false;
	123
	124	add_len = sense_buf[7];
	125	/* has asc and ascq */
	126	if (add_len < 6)
	127	return false;
	128
	129	asc = sense_buf[12];
	130	ascq = sense_buf[13];
	131
	132	if (zpodd->mech_type == ODD_MECH_TYPE_SLOT)
	133	/* no media inside */
	134	return asc == 0x3a;
	135	else
	136	/* no media inside and door closed */
	137	return asc == 0x3a && ascq == 0x01;
	138	}
	139
	140	/*
	141	* Update the zpodd->zp_ready field. This field will only be set
	142	* if the ODD has stayed in ZP ready state for zpodd_poweroff_delay
	143	* time, and will be used to decide if power off is allowed. If it
	144	* is set, it will be cleared during resume from powered off state.
	145	*/
	146	void zpodd_on_suspend(struct ata_device *dev)
	147	{
	148	struct zpodd *zpodd = dev->zpodd;
	149	unsigned long expires;
	150
	151	if (!zpready(dev)) {
	152	zpodd->zp_sampled = false;
	153	return;
	154	}
	155
	156	if (!zpodd->zp_sampled) {
	157	zpodd->zp_sampled = true;
	158	zpodd->last_ready = jiffies;
	159	return;
	160	}
	161
	162	expires = zpodd->last_ready +
	163	msecs_to_jiffies(zpodd_poweroff_delay * 1000);
	164	if (time_before(jiffies, expires))
	165	return;
	166
167	zpodd->zp_ready = true;
168	}
169
21334205 AL	170	bool zpodd_zpready(struct ata_device *dev)
	171	{
	172	struct zpodd *zpodd = dev->zpodd;
	173	return zpodd->zp_ready;
	174	}
	175
	176	/*
	177	* Enable runtime wake capability through ACPI and set the powered_off flag,
	178	* this flag will be used during resume to decide what operations are needed
	179	* to take.
	180	*/
	181	void zpodd_enable_run_wake(struct ata_device *dev)
	182	{
	183	struct zpodd *zpodd = dev->zpodd;
	184
	185	zpodd->powered_off = true;
	186	device_set_run_wake(&dev->sdev->sdev_gendev, true);
	187	acpi_pm_device_run_wake(&dev->sdev->sdev_gendev, true);
	188	}
	189
	190	/* Disable runtime wake capability if it is enabled */
	191	void zpodd_disable_run_wake(struct ata_device *dev)
	192	{
	193	struct zpodd *zpodd = dev->zpodd;
	194
	195	if (zpodd->powered_off) {
	196	acpi_pm_device_run_wake(&dev->sdev->sdev_gendev, false);
	197	device_set_run_wake(&dev->sdev->sdev_gendev, false);
	198	}
	199	}
	200
	201	/*
	202	* Post power on processing after the ODD has been recovered. If the
	203	* ODD wasn't powered off during suspend, it doesn't do anything.
	204	*
	205	* For drawer type ODD, if it is powered on due to user pressed the
	206	* eject button, the tray needs to be ejected. This can only be done
	207	* after the ODD has been recovered, i.e. link is initialized and
	208	* device is able to process NON_DATA PIO command, as eject needs to
	209	* send command for the ODD to process.
	210	*
	211	* The from_notify flag set in wake notification handler function
	212	* zpodd_wake_dev represents if power on is due to user's action.
	213	*
	214	* For both types of ODD, several fields need to be reset.
	215	*/
	216	void zpodd_post_poweron(struct ata_device *dev)
	217	{
	218	struct zpodd *zpodd = dev->zpodd;
	219
	220	if (!zpodd->powered_off)
	221	return;
	222
	223	zpodd->powered_off = false;
	224
	225	if (zpodd->from_notify) {
	226	zpodd->from_notify = false;
	227	if (zpodd->mech_type == ODD_MECH_TYPE_DRAWER)
	228	eject_tray(dev);
	229	}
	230
	231	zpodd->zp_sampled = false;
	232	zpodd->zp_ready = false;
	233	}
234
f064a20d AL	235	static void zpodd_wake_dev(acpi_handle handle, u32 event, void *context)
	236	{
	237	struct ata_device *ata_dev = context;
	238	struct zpodd *zpodd = ata_dev->zpodd;
	239	struct device *dev = &ata_dev->sdev->sdev_gendev;
	240
	241	if (event == ACPI_NOTIFY_DEVICE_WAKE && ata_dev &&
	242	pm_runtime_suspended(dev)) {
	243	zpodd->from_notify = true;
	244	pm_runtime_resume(dev);
	245	}
	246	}
	247
	248	static void ata_acpi_add_pm_notifier(struct ata_device *dev)
	249	{
	250	acpi_handle handle = ata_dev_acpi_handle(dev);
	251	acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
	252	zpodd_wake_dev, dev);
	253	}
	254
	255	static void ata_acpi_remove_pm_notifier(struct ata_device *dev)
	256	{
	257	acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->sdev->sdev_gendev);
	258	acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY, zpodd_wake_dev);
	259	}
	260
afe75951 AL	261	void zpodd_init(struct ata_device *dev)
	262	{
	263	enum odd_mech_type mech_type;
	264	struct zpodd *zpodd;
	265
	266	if (dev->zpodd)
	267	return;
	268
	269	if (!odd_can_poweroff(dev))
	270	return;
	271
	272	mech_type = zpodd_get_mech_type(dev);
	273	if (mech_type == ODD_MECH_TYPE_UNSUPPORTED)
	274	return;
	275
	276	zpodd = kzalloc(sizeof(struct zpodd), GFP_KERNEL);
	277	if (!zpodd)
	278	return;
	279
	280	zpodd->mech_type = mech_type;
	281
f064a20d	282	ata_acpi_add_pm_notifier(dev);
afe75951 AL	283	zpodd->dev = dev;
	284	dev->zpodd = zpodd;
	285	}
	286
	287	void zpodd_exit(struct ata_device *dev)
	288	{
f064a20d	289	ata_acpi_remove_pm_notifier(dev);
afe75951 AL	290	kfree(dev->zpodd);
	291	dev->zpodd = NULL;
	292	}