1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * USB-ACPI glue code
  4 *
  5 * Copyright 2012 Red Hat <mjg@redhat.com>
  6 */
  7#include <linux/module.h>
  8#include <linux/usb.h>
  9#include <linux/device.h>
 10#include <linux/errno.h>
 11#include <linux/kernel.h>
 12#include <linux/acpi.h>
 13#include <linux/pci.h>
 14#include <linux/usb/hcd.h>
 15
 16#include "hub.h"
 17
 18/**
 19 * usb_acpi_power_manageable - check whether usb port has
 20 * acpi power resource.
 21 * @hdev: USB device belonging to the usb hub
 22 * @index: port index based zero
 23 *
 24 * Return true if the port has acpi power resource and false if no.
 25 */
 26bool usb_acpi_power_manageable(struct usb_device *hdev, int index)
 27{
 28	acpi_handle port_handle;
 29	int port1 = index + 1;
 30
 31	port_handle = usb_get_hub_port_acpi_handle(hdev,
 32		port1);
 33	if (port_handle)
 34		return acpi_bus_power_manageable(port_handle);
 35	else
 36		return false;
 37}
 38EXPORT_SYMBOL_GPL(usb_acpi_power_manageable);
 39
 40/**
 41 * usb_acpi_set_power_state - control usb port's power via acpi power
 42 * resource
 43 * @hdev: USB device belonging to the usb hub
 44 * @index: port index based zero
 45 * @enable: power state expected to be set
 46 *
 47 * Notice to use usb_acpi_power_manageable() to check whether the usb port
 48 * has acpi power resource before invoking this function.
 49 *
 50 * Returns 0 on success, else negative errno.
 51 */
 52int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
 53{
 54	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 55	struct usb_port *port_dev;
 56	acpi_handle port_handle;
 57	unsigned char state;
 58	int port1 = index + 1;
 59	int error = -EINVAL;
 60
 61	if (!hub)
 62		return -ENODEV;
 63	port_dev = hub->ports[port1 - 1];
 64
 65	port_handle = (acpi_handle) usb_get_hub_port_acpi_handle(hdev, port1);
 66	if (!port_handle)
 67		return error;
 68
 69	if (enable)
 70		state = ACPI_STATE_D0;
 71	else
 72		state = ACPI_STATE_D3_COLD;
 73
 74	error = acpi_bus_set_power(port_handle, state);
 75	if (!error)
 76		dev_dbg(&port_dev->dev, "acpi: power was set to %d\n", enable);
 77	else
 78		dev_dbg(&port_dev->dev, "acpi: power failed to be set\n");
 79
 80	return error;
 81}
 82EXPORT_SYMBOL_GPL(usb_acpi_set_power_state);
 83
 84static enum usb_port_connect_type usb_acpi_get_connect_type(acpi_handle handle,
 85		struct acpi_pld_info *pld)
 86{
 87	enum usb_port_connect_type connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
 88	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 89	union acpi_object *upc;
 90	acpi_status status;
 91
 92	/*
 93	 * According to 9.14 in ACPI Spec 6.2. _PLD indicates whether usb port
 94	 * is user visible and _UPC indicates whether it is connectable. If
 95	 * the port was visible and connectable, it could be freely connected
 96	 * and disconnected with USB devices. If no visible and connectable,
 97	 * a usb device is directly hard-wired to the port. If no visible and
 98	 * no connectable, the port would be not used.
 99	 */
100	status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
101	upc = buffer.pointer;
102	if (!upc || (upc->type != ACPI_TYPE_PACKAGE)
103		|| upc->package.count != 4) {
104		goto out;
105	}
106
107	if (upc->package.elements[0].integer.value)
108		if (pld->user_visible)
109			connect_type = USB_PORT_CONNECT_TYPE_HOT_PLUG;
110		else
111			connect_type = USB_PORT_CONNECT_TYPE_HARD_WIRED;
112	else if (!pld->user_visible)
113		connect_type = USB_PORT_NOT_USED;
114out:
115	kfree(upc);
116	return connect_type;
117}
118
119
120/*
121 * Private to usb-acpi, all the core needs to know is that
122 * port_dev->location is non-zero when it has been set by the firmware.
123 */
124#define USB_ACPI_LOCATION_VALID (1 << 31)
125
126static struct acpi_device *usb_acpi_find_port(struct acpi_device *parent,
127					      int raw)
128{
129	struct acpi_device *adev;
130
131	if (!parent)
132		return NULL;
133
134	list_for_each_entry(adev, &parent->children, node) {
135		if (acpi_device_adr(adev) == raw)
136			return adev;
137	}
138
139	return acpi_find_child_device(parent, raw, false);
140}
141
142static struct acpi_device *usb_acpi_find_companion(struct device *dev)
143{
144	struct usb_device *udev;
145	struct acpi_device *adev;
146	acpi_handle *parent_handle;
147
148	/*
149	 * In the ACPI DSDT table, only usb root hub and usb ports are
150	 * acpi device nodes. The hierarchy like following.
151	 * Device (EHC1)
152	 *	Device (HUBN)
153	 *		Device (PR01)
154	 *			Device (PR11)
155	 *			Device (PR12)
156	 *			Device (PR13)
157	 *			...
158	 * So all binding process is divided into two parts. binding
159	 * root hub and usb ports.
160	 */
161	if (is_usb_device(dev)) {
162		udev = to_usb_device(dev);
163		if (udev->parent)
164			return NULL;
165
166		/* root hub is only child (_ADR=0) under its parent, the HC */
167		adev = ACPI_COMPANION(dev->parent);
168		return acpi_find_child_device(adev, 0, false);
169	} else if (is_usb_port(dev)) {
170		struct usb_port *port_dev = to_usb_port(dev);
171		int port1 = port_dev->portnum;
172		struct acpi_pld_info *pld;
173		acpi_handle *handle;
174		acpi_status status;
175
176		/* Get the struct usb_device point of port's hub */
177		udev = to_usb_device(dev->parent->parent);
178
179		/*
180		 * The root hub ports' parent is the root hub. The non-root-hub
181		 * ports' parent is the parent hub port which the hub is
182		 * connected to.
183		 */
184		if (!udev->parent) {
185			struct usb_hcd *hcd = bus_to_hcd(udev->bus);
186			int raw;
187
188			raw = usb_hcd_find_raw_port_number(hcd, port1);
189
190			adev = usb_acpi_find_port(ACPI_COMPANION(&udev->dev),
191						  raw);
192
193			if (!adev)
194				return NULL;
195		} else {
196			parent_handle =
197				usb_get_hub_port_acpi_handle(udev->parent,
198				udev->portnum);
199			if (!parent_handle)
200				return NULL;
201
202			acpi_bus_get_device(parent_handle, &adev);
203
204			adev = usb_acpi_find_port(adev, port1);
205
206			if (!adev)
207				return NULL;
208		}
209		handle = adev->handle;
210		status = acpi_get_physical_device_location(handle, &pld);
211		if (ACPI_FAILURE(status) || !pld)
212			return adev;
213
214		port_dev->location = USB_ACPI_LOCATION_VALID
215			| pld->group_token << 8 | pld->group_position;
216		port_dev->connect_type = usb_acpi_get_connect_type(handle, pld);
217		ACPI_FREE(pld);
218
219		return adev;
220	}
221
222	return NULL;
223}
224
225static bool usb_acpi_bus_match(struct device *dev)
226{
227	return is_usb_device(dev) || is_usb_port(dev);
228}
229
230static struct acpi_bus_type usb_acpi_bus = {
231	.name = "USB",
232	.match = usb_acpi_bus_match,
233	.find_companion = usb_acpi_find_companion,
234};
235
236int usb_acpi_register(void)
237{
238	return register_acpi_bus_type(&usb_acpi_bus);
239}
240
241void usb_acpi_unregister(void)
242{
243	unregister_acpi_bus_type(&usb_acpi_bus);
244}