2 * Provides code common for host and device side USB.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation, version 2.
8 * If either host side (ie. CONFIG_USB=y) or device side USB stack
9 * (ie. CONFIG_USB_GADGET=y) is compiled in the kernel, this module is
10 * compiled-in as well. Otherwise, if either of the two stacks is
11 * compiled as module, this file is compiled as module as well.
14 #include <linux/kernel.h>
15 #include <linux/module.h>
17 #include <linux/usb/ch9.h>
18 #include <linux/usb/of.h>
19 #include <linux/usb/otg.h>
20 #include <linux/of_platform.h>
22 const char *usb_otg_state_string(enum usb_otg_state state
)
24 static const char *const names
[] = {
25 [OTG_STATE_A_IDLE
] = "a_idle",
26 [OTG_STATE_A_WAIT_VRISE
] = "a_wait_vrise",
27 [OTG_STATE_A_WAIT_BCON
] = "a_wait_bcon",
28 [OTG_STATE_A_HOST
] = "a_host",
29 [OTG_STATE_A_SUSPEND
] = "a_suspend",
30 [OTG_STATE_A_PERIPHERAL
] = "a_peripheral",
31 [OTG_STATE_A_WAIT_VFALL
] = "a_wait_vfall",
32 [OTG_STATE_A_VBUS_ERR
] = "a_vbus_err",
33 [OTG_STATE_B_IDLE
] = "b_idle",
34 [OTG_STATE_B_SRP_INIT
] = "b_srp_init",
35 [OTG_STATE_B_PERIPHERAL
] = "b_peripheral",
36 [OTG_STATE_B_WAIT_ACON
] = "b_wait_acon",
37 [OTG_STATE_B_HOST
] = "b_host",
40 if (state
< 0 || state
>= ARRAY_SIZE(names
))
45 EXPORT_SYMBOL_GPL(usb_otg_state_string
);
47 static const char *const speed_names
[] = {
48 [USB_SPEED_UNKNOWN
] = "UNKNOWN",
49 [USB_SPEED_LOW
] = "low-speed",
50 [USB_SPEED_FULL
] = "full-speed",
51 [USB_SPEED_HIGH
] = "high-speed",
52 [USB_SPEED_WIRELESS
] = "wireless",
53 [USB_SPEED_SUPER
] = "super-speed",
54 [USB_SPEED_SUPER_PLUS
] = "super-speed-plus",
57 const char *usb_speed_string(enum usb_device_speed speed
)
59 if (speed
< 0 || speed
>= ARRAY_SIZE(speed_names
))
60 speed
= USB_SPEED_UNKNOWN
;
61 return speed_names
[speed
];
63 EXPORT_SYMBOL_GPL(usb_speed_string
);
65 enum usb_device_speed
usb_get_maximum_speed(struct device
*dev
)
67 const char *maximum_speed
;
71 err
= device_property_read_string(dev
, "maximum-speed", &maximum_speed
);
73 return USB_SPEED_UNKNOWN
;
75 for (i
= 0; i
< ARRAY_SIZE(speed_names
); i
++)
76 if (strcmp(maximum_speed
, speed_names
[i
]) == 0)
79 return USB_SPEED_UNKNOWN
;
81 EXPORT_SYMBOL_GPL(usb_get_maximum_speed
);
83 const char *usb_state_string(enum usb_device_state state
)
85 static const char *const names
[] = {
86 [USB_STATE_NOTATTACHED
] = "not attached",
87 [USB_STATE_ATTACHED
] = "attached",
88 [USB_STATE_POWERED
] = "powered",
89 [USB_STATE_RECONNECTING
] = "reconnecting",
90 [USB_STATE_UNAUTHENTICATED
] = "unauthenticated",
91 [USB_STATE_DEFAULT
] = "default",
92 [USB_STATE_ADDRESS
] = "addressed",
93 [USB_STATE_CONFIGURED
] = "configured",
94 [USB_STATE_SUSPENDED
] = "suspended",
97 if (state
< 0 || state
>= ARRAY_SIZE(names
))
102 EXPORT_SYMBOL_GPL(usb_state_string
);
104 static const char *const usb_dr_modes
[] = {
105 [USB_DR_MODE_UNKNOWN
] = "",
106 [USB_DR_MODE_HOST
] = "host",
107 [USB_DR_MODE_PERIPHERAL
] = "peripheral",
108 [USB_DR_MODE_OTG
] = "otg",
111 static enum usb_dr_mode
usb_get_dr_mode_from_string(const char *str
)
115 for (i
= 0; i
< ARRAY_SIZE(usb_dr_modes
); i
++)
116 if (!strcmp(usb_dr_modes
[i
], str
))
119 return USB_DR_MODE_UNKNOWN
;
122 enum usb_dr_mode
usb_get_dr_mode(struct device
*dev
)
127 err
= device_property_read_string(dev
, "dr_mode", &dr_mode
);
129 return USB_DR_MODE_UNKNOWN
;
131 return usb_get_dr_mode_from_string(dr_mode
);
133 EXPORT_SYMBOL_GPL(usb_get_dr_mode
);
137 * of_usb_get_dr_mode_by_phy - Get dual role mode for the controller device
138 * which is associated with the given phy device_node
139 * @np: Pointer to the given phy device_node
141 * In dts a usb controller associates with phy devices. The function gets
142 * the string from property 'dr_mode' of the controller associated with the
143 * given phy device node, and returns the correspondig enum usb_dr_mode.
145 enum usb_dr_mode
of_usb_get_dr_mode_by_phy(struct device_node
*phy_np
)
147 struct device_node
*controller
= NULL
;
148 struct device_node
*phy
;
154 controller
= of_find_node_with_property(controller
, "phys");
157 phy
= of_parse_phandle(controller
, "phys", index
);
163 } while (controller
);
166 err
= of_property_read_string(controller
, "dr_mode", &dr_mode
);
167 of_node_put(controller
);
170 return USB_DR_MODE_UNKNOWN
;
172 return usb_get_dr_mode_from_string(dr_mode
);
174 EXPORT_SYMBOL_GPL(of_usb_get_dr_mode_by_phy
);
177 * of_usb_host_tpl_support - to get if Targeted Peripheral List is supported
178 * for given targeted hosts (non-PC hosts)
179 * @np: Pointer to the given device_node
181 * The function gets if the targeted hosts support TPL or not
183 bool of_usb_host_tpl_support(struct device_node
*np
)
185 if (of_find_property(np
, "tpl-support", NULL
))
190 EXPORT_SYMBOL_GPL(of_usb_host_tpl_support
);
193 * of_usb_update_otg_caps - to update usb otg capabilities according to
194 * the passed properties in DT.
195 * @np: Pointer to the given device_node
196 * @otg_caps: Pointer to the target usb_otg_caps to be set
198 * The function updates the otg capabilities
200 int of_usb_update_otg_caps(struct device_node
*np
,
201 struct usb_otg_caps
*otg_caps
)
208 if (!of_property_read_u32(np
, "otg-rev", &otg_rev
)) {
214 /* Choose the lesser one if it's already been set */
215 if (otg_caps
->otg_rev
)
216 otg_caps
->otg_rev
= min_t(u16
, otg_rev
,
219 otg_caps
->otg_rev
= otg_rev
;
222 pr_err("%s: unsupported otg-rev: 0x%x\n",
223 np
->full_name
, otg_rev
);
228 * otg-rev is mandatory for otg properties, if not passed
229 * we set it to be 0 and assume it's a legacy otg device.
230 * Non-dt platform can set it afterwards.
232 otg_caps
->otg_rev
= 0;
235 if (of_find_property(np
, "hnp-disable", NULL
))
236 otg_caps
->hnp_support
= false;
237 if (of_find_property(np
, "srp-disable", NULL
))
238 otg_caps
->srp_support
= false;
239 if (of_find_property(np
, "adp-disable", NULL
) ||
240 (otg_caps
->otg_rev
< 0x0200))
241 otg_caps
->adp_support
= false;
245 EXPORT_SYMBOL_GPL(of_usb_update_otg_caps
);
249 MODULE_LICENSE("GPL");