1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * of.c The helpers for hcd device tree support 4 * 5 * Copyright (C) 2016 Freescale Semiconductor, Inc. 6 * Author: Peter Chen <peter.chen@freescale.com> 7 * Copyright (C) 2017 Johan Hovold <johan@kernel.org> 8 */ 9 10 #include <linux/of.h> 11 #include <linux/of_graph.h> 12 #include <linux/usb/of.h> 13 14 /** 15 * usb_of_get_device_node() - get a USB device node 16 * @hub: hub to which device is connected 17 * @port1: one-based index of port 18 * 19 * Look up the node of a USB device given its parent hub device and one-based 20 * port number. 21 * 22 * Return: A pointer to the node with incremented refcount if found, or 23 * %NULL otherwise. 24 */ 25 struct device_node *usb_of_get_device_node(struct usb_device *hub, int port1) 26 { 27 struct device_node *node; 28 u32 reg; 29 30 for_each_child_of_node(hub->dev.of_node, node) { 31 if (of_property_read_u32(node, "reg", ®)) 32 continue; 33 34 if (reg == port1) 35 return node; 36 } 37 38 return NULL; 39 } 40 EXPORT_SYMBOL_GPL(usb_of_get_device_node); 41 42 /** 43 * usb_of_has_combined_node() - determine whether a device has a combined node 44 * @udev: USB device 45 * 46 * Determine whether a USB device has a so called combined node which is 47 * shared with its sole interface. This is the case if and only if the device 48 * has a node and its descriptors report the following: 49 * 50 * 1) bDeviceClass is 0 or 9, and 51 * 2) bNumConfigurations is 1, and 52 * 3) bNumInterfaces is 1. 53 * 54 * Return: True iff the device has a device node and its descriptors match the 55 * criteria for a combined node. 56 */ 57 bool usb_of_has_combined_node(struct usb_device *udev) 58 { 59 struct usb_device_descriptor *ddesc = &udev->descriptor; 60 struct usb_config_descriptor *cdesc; 61 62 if (!udev->dev.of_node) 63 return false; 64 65 switch (ddesc->bDeviceClass) { 66 case USB_CLASS_PER_INTERFACE: 67 case USB_CLASS_HUB: 68 if (ddesc->bNumConfigurations == 1) { 69 cdesc = &udev->config->desc; 70 if (cdesc->bNumInterfaces == 1) 71 return true; 72 } 73 } 74 75 return false; 76 } 77 EXPORT_SYMBOL_GPL(usb_of_has_combined_node); 78 79 static bool usb_of_has_devices_or_graph(const struct usb_device *hub) 80 { 81 const struct device_node *np = hub->dev.of_node; 82 struct device_node *child; 83 84 if (of_graph_is_present(np)) 85 return true; 86 87 for_each_child_of_node(np, child) { 88 if (of_property_present(child, "reg")) { 89 of_node_put(child); 90 return true; 91 } 92 } 93 94 return false; 95 } 96 97 /** 98 * usb_of_get_connect_type() - get a USB hub's port connect_type 99 * @hub: hub to which port is for @port1 100 * @port1: one-based index of port 101 * 102 * Get the connect_type of @port1 based on the device node for @hub. If the 103 * port is described in the OF graph, the connect_type is "hotplug". If the 104 * @hub has a child device has with a 'reg' property equal to @port1 the 105 * connect_type is "hard-wired". If there isn't an OF graph or child node at 106 * all then the connect_type is "unknown". Otherwise, the port is considered 107 * "unused" because it isn't described at all. 108 * 109 * Return: A connect_type for @port1 based on the device node for @hub. 110 */ 111 enum usb_port_connect_type usb_of_get_connect_type(struct usb_device *hub, int port1) 112 { 113 struct device_node *np, *child, *ep, *remote_np; 114 enum usb_port_connect_type connect_type; 115 116 /* Only set connect_type if binding has ports/hardwired devices. */ 117 if (!usb_of_has_devices_or_graph(hub)) 118 return USB_PORT_CONNECT_TYPE_UNKNOWN; 119 120 /* Assume port is unused if there's a graph or a child node. */ 121 connect_type = USB_PORT_NOT_USED; 122 123 np = hub->dev.of_node; 124 /* 125 * Hotplug ports are connected to an available remote node, e.g. 126 * usb-a-connector compatible node, in the OF graph. 127 */ 128 if (of_graph_is_present(np)) { 129 ep = of_graph_get_endpoint_by_regs(np, port1, -1); 130 if (ep) { 131 remote_np = of_graph_get_remote_port_parent(ep); 132 of_node_put(ep); 133 if (of_device_is_available(remote_np)) 134 connect_type = USB_PORT_CONNECT_TYPE_HOT_PLUG; 135 of_node_put(remote_np); 136 } 137 } 138 139 /* 140 * Hard-wired ports are child nodes with a reg property corresponding 141 * to the port number, i.e. a usb device. 142 */ 143 child = usb_of_get_device_node(hub, port1); 144 if (of_device_is_available(child)) 145 connect_type = USB_PORT_CONNECT_TYPE_HARD_WIRED; 146 of_node_put(child); 147 148 return connect_type; 149 } 150 EXPORT_SYMBOL_GPL(usb_of_get_connect_type); 151 152 /** 153 * usb_of_get_interface_node() - get a USB interface node 154 * @udev: USB device of interface 155 * @config: configuration value 156 * @ifnum: interface number 157 * 158 * Look up the node of a USB interface given its USB device, configuration 159 * value and interface number. 160 * 161 * Return: A pointer to the node with incremented refcount if found, or 162 * %NULL otherwise. 163 */ 164 struct device_node * 165 usb_of_get_interface_node(struct usb_device *udev, u8 config, u8 ifnum) 166 { 167 struct device_node *node; 168 u32 reg[2]; 169 170 for_each_child_of_node(udev->dev.of_node, node) { 171 if (of_property_read_u32_array(node, "reg", reg, 2)) 172 continue; 173 174 if (reg[0] == ifnum && reg[1] == config) 175 return node; 176 } 177 178 return NULL; 179 } 180 EXPORT_SYMBOL_GPL(usb_of_get_interface_node); 181