[deliverable/linux.git] / drivers / usb / core / port.c

/*
 * usb port device code
 *
 * Copyright (C) 2012 Intel Corp
 *
 * Author: Lan Tianyu <tianyu.lan@intel.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * 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.
 *
 */

#include <linux/slab.h>
#include <linux/pm_qos.h>

#include "hub.h"

static const struct attribute_group *port_dev_group[];

static ssize_t show_port_connect_type(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct usb_port *port_dev = to_usb_port(dev);
	char *result;

	switch (port_dev->connect_type) {
	case USB_PORT_CONNECT_TYPE_HOT_PLUG:
		result = "hotplug";
		break;
	case USB_PORT_CONNECT_TYPE_HARD_WIRED:
		result = "hardwired";
		break;
	case USB_PORT_NOT_USED:
		result = "not used";
		break;
	default:
		result = "unknown";
		break;
	}

	return sprintf(buf, "%s\n", result);
}
static DEVICE_ATTR(connect_type, S_IRUGO, show_port_connect_type,
		NULL);

static struct attribute *port_dev_attrs[] = {
	&dev_attr_connect_type.attr,
	NULL,
};

static struct attribute_group port_dev_attr_grp = {
	.attrs = port_dev_attrs,
};

static const struct attribute_group *port_dev_group[] = {
	&port_dev_attr_grp,
	NULL,
};

static void usb_port_device_release(struct device *dev)
{
	struct usb_port *port_dev = to_usb_port(dev);

	usb_acpi_unregister_power_resources(dev);
	kfree(port_dev);
}

#ifdef CONFIG_USB_SUSPEND
static int usb_port_runtime_resume(struct device *dev)
{
	struct usb_port *port_dev = to_usb_port(dev);
	struct usb_device *hdev = to_usb_device(dev->parent->parent);
	struct usb_interface *intf = to_usb_interface(dev->parent);
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
	int port1 = port_dev->portnum;
	int retval;

	if (!hub)
		return -EINVAL;

	usb_autopm_get_interface(intf);
	set_bit(port1, hub->busy_bits);

	retval = usb_hub_set_port_power(hdev, port1, true);
	if (port_dev->child && !retval) {
		/*
		 * Wait for usb hub port to be reconnected in order to make
		 * the resume procedure successful.
		 */
		retval = hub_port_debounce_be_connected(hub, port1);
		if (retval < 0) {
			dev_dbg(&port_dev->dev, "can't get reconnection after setting port  power on, status %d\n",
					retval);
			goto out;
		}
		usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);

		/* Set return value to 0 if debounce successful */
		retval = 0;
	}

out:
	clear_bit(port1, hub->busy_bits);
	usb_autopm_put_interface(intf);
	return retval;
}

static int usb_port_runtime_suspend(struct device *dev)
{
	struct usb_port *port_dev = to_usb_port(dev);
	struct usb_device *hdev = to_usb_device(dev->parent->parent);
	struct usb_interface *intf = to_usb_interface(dev->parent);
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
	int port1 = port_dev->portnum;
	int retval;

	if (!hub)
		return -EINVAL;

	if (dev_pm_qos_flags(&port_dev->dev, PM_QOS_FLAG_NO_POWER_OFF)
			== PM_QOS_FLAGS_ALL)
		return -EAGAIN;

	usb_autopm_get_interface(intf);
	set_bit(port1, hub->busy_bits);
	retval = usb_hub_set_port_power(hdev, port1, false);
	usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
	usb_clear_port_feature(hdev, port1,	USB_PORT_FEAT_C_ENABLE);
	clear_bit(port1, hub->busy_bits);
	usb_autopm_put_interface(intf);
	return retval;
}
#endif

static const struct dev_pm_ops usb_port_pm_ops = {
#ifdef CONFIG_USB_SUSPEND
	.runtime_suspend =	usb_port_runtime_suspend,
	.runtime_resume =	usb_port_runtime_resume,
	.runtime_idle =		pm_generic_runtime_idle,
#endif
};

struct device_type usb_port_device_type = {
	.name =		"usb_port",
	.release =	usb_port_device_release,
	.pm =		&usb_port_pm_ops,
};

int usb_hub_create_port_device(struct usb_hub *hub, int port1)
{
	struct usb_port *port_dev = NULL;
	int retval;

	port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
	if (!port_dev) {
		retval = -ENOMEM;
		goto exit;
	}

	hub->ports[port1 - 1] = port_dev;
	port_dev->portnum = port1;
	port_dev->power_is_on = true;
	port_dev->dev.parent = hub->intfdev;
	port_dev->dev.groups = port_dev_group;
	port_dev->dev.type = &usb_port_device_type;
	dev_set_name(&port_dev->dev, "port%d", port1);

	retval = device_register(&port_dev->dev);
	if (retval)
		goto error_register;

	pm_runtime_set_active(&port_dev->dev);
	pm_runtime_enable(&port_dev->dev);

	retval = usb_acpi_register_power_resources(&port_dev->dev);
	if (retval && retval != -ENODEV)
		dev_warn(&port_dev->dev, "the port can't register its ACPI power resource.\n");

	return 0;

error_register:
	put_device(&port_dev->dev);
exit:
	return retval;
}

void usb_hub_remove_port_device(struct usb_hub *hub,
				       int port1)
{
	device_unregister(&hub->ports[port1 - 1]->dev);
}
Commit	Line	Data
6e30d7cb LT	1	/*
	2	* usb port device code
	3	*
	4	* Copyright (C) 2012 Intel Corp
	5	*
	6	* Author: Lan Tianyu <tianyu.lan@intel.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
	14	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	* for more details.
	16	*
	17	*/
	18
9f7344fb	19	#include <linux/slab.h>
971fcd49	20	#include <linux/pm_qos.h>
9f7344fb	21
6e30d7cb LT	22	#include "hub.h"
6e30d7cb LT	23
cef7468c LT	24	static const struct attribute_group *port_dev_group[];
	25
	26	static ssize_t show_port_connect_type(struct device *dev,
	27	struct device_attribute attr, char buf)
	28	{
	29	struct usb_port *port_dev = to_usb_port(dev);
	30	char *result;
	31
	32	switch (port_dev->connect_type) {
	33	case USB_PORT_CONNECT_TYPE_HOT_PLUG:
	34	result = "hotplug";
	35	break;
	36	case USB_PORT_CONNECT_TYPE_HARD_WIRED:
	37	result = "hardwired";
	38	break;
	39	case USB_PORT_NOT_USED:
	40	result = "not used";
	41	break;
	42	default:
	43	result = "unknown";
	44	break;
	45	}
	46
	47	return sprintf(buf, "%s\n", result);
	48	}
	49	static DEVICE_ATTR(connect_type, S_IRUGO, show_port_connect_type,
	50	NULL);
	51
	52	static struct attribute *port_dev_attrs[] = {
	53	&dev_attr_connect_type.attr,
	54	NULL,
	55	};
	56
	57	static struct attribute_group port_dev_attr_grp = {
	58	.attrs = port_dev_attrs,
	59	};
	60
	61	static const struct attribute_group *port_dev_group[] = {
	62	&port_dev_attr_grp,
	63	NULL,
	64	};
	65
6e30d7cb LT	66	static void usb_port_device_release(struct device *dev)
	67	{
	68	struct usb_port *port_dev = to_usb_port(dev);
	69
88bb965e	70	usb_acpi_unregister_power_resources(dev);
6e30d7cb LT	71	kfree(port_dev);
	72	}
	73
971fcd49 LT	74	#ifdef CONFIG_USB_SUSPEND
	75	static int usb_port_runtime_resume(struct device *dev)
	76	{
	77	struct usb_port *port_dev = to_usb_port(dev);
	78	struct usb_device *hdev = to_usb_device(dev->parent->parent);
	79	struct usb_interface *intf = to_usb_interface(dev->parent);
ad493e5e LT	80	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
ad493e5e LT	81	int port1 = port_dev->portnum;
971fcd49 LT	82	int retval;
971fcd49 LT	83
ad493e5e LT	84	if (!hub)
	85	return -EINVAL;
	86
971fcd49	87	usb_autopm_get_interface(intf);
ad493e5e LT	88	set_bit(port1, hub->busy_bits);
	89
	90	retval = usb_hub_set_port_power(hdev, port1, true);
	91	if (port_dev->child && !retval) {
	92	/*
	93	* Wait for usb hub port to be reconnected in order to make
	94	* the resume procedure successful.
	95	*/
	96	retval = hub_port_debounce_be_connected(hub, port1);
	97	if (retval < 0) {
	98	dev_dbg(&port_dev->dev, "can't get reconnection after setting port power on, status %d\n",
	99	retval);
	100	goto out;
	101	}
	102	usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
	103
	104	/* Set return value to 0 if debounce successful */
	105	retval = 0;
	106	}
	107
	108	out:
	109	clear_bit(port1, hub->busy_bits);
971fcd49 LT	110	usb_autopm_put_interface(intf);
	111	return retval;
	112	}
	113
	114	static int usb_port_runtime_suspend(struct device *dev)
	115	{
	116	struct usb_port *port_dev = to_usb_port(dev);
	117	struct usb_device *hdev = to_usb_device(dev->parent->parent);
	118	struct usb_interface *intf = to_usb_interface(dev->parent);
ad493e5e LT	119	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
ad493e5e LT	120	int port1 = port_dev->portnum;
971fcd49 LT	121	int retval;
971fcd49 LT	122
ad493e5e LT	123	if (!hub)
	124	return -EINVAL;
	125
971fcd49 LT	126	if (dev_pm_qos_flags(&port_dev->dev, PM_QOS_FLAG_NO_POWER_OFF)
	127	== PM_QOS_FLAGS_ALL)
	128	return -EAGAIN;
	129
	130	usb_autopm_get_interface(intf);
ad493e5e LT	131	set_bit(port1, hub->busy_bits);
	132	retval = usb_hub_set_port_power(hdev, port1, false);
	133	usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
	134	usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
	135	clear_bit(port1, hub->busy_bits);
971fcd49 LT	136	usb_autopm_put_interface(intf);
	137	return retval;
	138	}
	139	#endif
	140
	141	static const struct dev_pm_ops usb_port_pm_ops = {
	142	#ifdef CONFIG_USB_SUSPEND
	143	.runtime_suspend = usb_port_runtime_suspend,
	144	.runtime_resume = usb_port_runtime_resume,
	145	.runtime_idle = pm_generic_runtime_idle,
	146	#endif
	147	};
	148
6e30d7cb LT	149	struct device_type usb_port_device_type = {
	150	.name = "usb_port",
	151	.release = usb_port_device_release,
971fcd49	152	.pm = &usb_port_pm_ops,
6e30d7cb LT	153	};
	154
	155	int usb_hub_create_port_device(struct usb_hub *hub, int port1)
	156	{
	157	struct usb_port *port_dev = NULL;
	158	int retval;
	159
	160	port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
	161	if (!port_dev) {
	162	retval = -ENOMEM;
	163	goto exit;
	164	}
	165
	166	hub->ports[port1 - 1] = port_dev;
971fcd49	167	port_dev->portnum = port1;
ad493e5e	168	port_dev->power_is_on = true;
6e30d7cb	169	port_dev->dev.parent = hub->intfdev;
cef7468c	170	port_dev->dev.groups = port_dev_group;
6e30d7cb LT	171	port_dev->dev.type = &usb_port_device_type;
	172	dev_set_name(&port_dev->dev, "port%d", port1);
	173
	174	retval = device_register(&port_dev->dev);
	175	if (retval)
	176	goto error_register;
	177
971fcd49 LT	178	pm_runtime_set_active(&port_dev->dev);
	179	pm_runtime_enable(&port_dev->dev);
	180
88bb965e LT	181	retval = usb_acpi_register_power_resources(&port_dev->dev);
	182	if (retval && retval != -ENODEV)
	183	dev_warn(&port_dev->dev, "the port can't register its ACPI power resource.\n");
	184
6e30d7cb LT	185	return 0;
	186
	187	error_register:
	188	put_device(&port_dev->dev);
	189	exit:
	190	return retval;
	191	}
	192
	193	void usb_hub_remove_port_device(struct usb_hub *hub,
	194	int port1)
	195	{
	196	device_unregister(&hub->ports[port1 - 1]->dev);
	197	}
	198