phy.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 * USB PHY defines
  4 *
  5 * These APIs may be used between USB controllers.  USB device drivers
  6 * (for either host or peripheral roles) don't use these calls; they
  7 * continue to use just usb_device and usb_gadget.
  8 */
  9
 10#ifndef __LINUX_USB_PHY_H
 11#define __LINUX_USB_PHY_H
 12
 13#include <linux/extcon.h>
 14#include <linux/notifier.h>
 15#include <linux/usb.h>
 16#include <uapi/linux/usb/charger.h>
 17
 18enum usb_phy_interface {
 19	USBPHY_INTERFACE_MODE_UNKNOWN,
 20	USBPHY_INTERFACE_MODE_UTMI,
 21	USBPHY_INTERFACE_MODE_UTMIW,
 22	USBPHY_INTERFACE_MODE_ULPI,
 23	USBPHY_INTERFACE_MODE_SERIAL,
 24	USBPHY_INTERFACE_MODE_HSIC,
 25};
 26
 27enum usb_phy_events {
 28	USB_EVENT_NONE,         /* no events or cable disconnected */
 29	USB_EVENT_VBUS,         /* vbus valid event */
 30	USB_EVENT_ID,           /* id was grounded */
 31	USB_EVENT_CHARGER,      /* usb dedicated charger */
 32	USB_EVENT_ENUMERATED,   /* gadget driver enumerated */
 33};
 34
 35/* associate a type with PHY */
 36enum usb_phy_type {
 37	USB_PHY_TYPE_UNDEFINED,
 38	USB_PHY_TYPE_USB2,
 39	USB_PHY_TYPE_USB3,
 40};
 41
 42/* OTG defines lots of enumeration states before device reset */
 43enum usb_otg_state {
 44	OTG_STATE_UNDEFINED = 0,
 45
 46	/* single-role peripheral, and dual-role default-b */
 47	OTG_STATE_B_IDLE,
 48	OTG_STATE_B_SRP_INIT,
 49	OTG_STATE_B_PERIPHERAL,
 50
 51	/* extra dual-role default-b states */
 52	OTG_STATE_B_WAIT_ACON,
 53	OTG_STATE_B_HOST,
 54
 55	/* dual-role default-a */
 56	OTG_STATE_A_IDLE,
 57	OTG_STATE_A_WAIT_VRISE,
 58	OTG_STATE_A_WAIT_BCON,
 59	OTG_STATE_A_HOST,
 60	OTG_STATE_A_SUSPEND,
 61	OTG_STATE_A_PERIPHERAL,
 62	OTG_STATE_A_WAIT_VFALL,
 63	OTG_STATE_A_VBUS_ERR,
 64};
 65
 66struct usb_phy;
 67struct usb_otg;
 68
 69/* for phys connected thru an ULPI interface, the user must
 70 * provide access ops
 71 */
 72struct usb_phy_io_ops {
 73	int (*read)(struct usb_phy *x, u32 reg);
 74	int (*write)(struct usb_phy *x, u32 val, u32 reg);
 75};
 76
 77struct usb_charger_current {
 78	unsigned int sdp_min;
 79	unsigned int sdp_max;
 80	unsigned int dcp_min;
 81	unsigned int dcp_max;
 82	unsigned int cdp_min;
 83	unsigned int cdp_max;
 84	unsigned int aca_min;
 85	unsigned int aca_max;
 86};
 87
 88struct usb_phy {
 89	struct device		*dev;
 90	const char		*label;
 91	unsigned int		 flags;
 92
 93	enum usb_phy_type	type;
 94	enum usb_phy_events	last_event;
 95
 96	struct usb_otg		*otg;
 97
 98	struct device		*io_dev;
 99	struct usb_phy_io_ops	*io_ops;
100	void __iomem		*io_priv;
101
102	/* to support extcon device */
103	struct extcon_dev	*edev;
104	struct extcon_dev	*id_edev;
105	struct notifier_block	vbus_nb;
106	struct notifier_block	id_nb;
107	struct notifier_block	type_nb;
108
109	/* Support USB charger */
110	enum usb_charger_type	chg_type;
111	enum usb_charger_state	chg_state;
112	struct usb_charger_current	chg_cur;
113	struct work_struct		chg_work;
114
115	/* for notification of usb_phy_events */
116	struct atomic_notifier_head	notifier;
117
118	/* to pass extra port status to the root hub */
119	u16			port_status;
120	u16			port_change;
121
122	/* to support controllers that have multiple phys */
123	struct list_head	head;
124
125	/* initialize/shutdown the phy */
126	int	(*init)(struct usb_phy *x);
127	void	(*shutdown)(struct usb_phy *x);
128
129	/* enable/disable VBUS */
130	int	(*set_vbus)(struct usb_phy *x, int on);
131
132	/* effective for B devices, ignored for A-peripheral */
133	int	(*set_power)(struct usb_phy *x,
134				unsigned mA);
135
136	/* Set phy into suspend mode */
137	int	(*set_suspend)(struct usb_phy *x,
138				int suspend);
139
140	/*
141	 * Set wakeup enable for PHY, in that case, the PHY can be
142	 * woken up from suspend status due to external events,
143	 * like vbus change, dp/dm change and id.
144	 */
145	int	(*set_wakeup)(struct usb_phy *x, bool enabled);
146
147	/* notify phy connect status change */
148	int	(*notify_connect)(struct usb_phy *x,
149			enum usb_device_speed speed);
150	int	(*notify_disconnect)(struct usb_phy *x,
151			enum usb_device_speed speed);
152
153	/*
154	 * Charger detection method can be implemented if you need to
155	 * manually detect the charger type.
156	 */
157	enum usb_charger_type (*charger_detect)(struct usb_phy *x);
158};
159
160/* for board-specific init logic */
161extern int usb_add_phy(struct usb_phy *, enum usb_phy_type type);
162extern int usb_add_phy_dev(struct usb_phy *);
163extern void usb_remove_phy(struct usb_phy *);
164
165/* helpers for direct access thru low-level io interface */
166static inline int usb_phy_io_read(struct usb_phy *x, u32 reg)
167{
168	if (x && x->io_ops && x->io_ops->read)
169		return x->io_ops->read(x, reg);
170
171	return -EINVAL;
172}
173
174static inline int usb_phy_io_write(struct usb_phy *x, u32 val, u32 reg)
175{
176	if (x && x->io_ops && x->io_ops->write)
177		return x->io_ops->write(x, val, reg);
178
179	return -EINVAL;
180}
181
182static inline int
183usb_phy_init(struct usb_phy *x)
184{
185	if (x && x->init)
186		return x->init(x);
187
188	return 0;
189}
190
191static inline void
192usb_phy_shutdown(struct usb_phy *x)
193{
194	if (x && x->shutdown)
195		x->shutdown(x);
196}
197
198static inline int
199usb_phy_vbus_on(struct usb_phy *x)
200{
201	if (!x || !x->set_vbus)
202		return 0;
203
204	return x->set_vbus(x, true);
205}
206
207static inline int
208usb_phy_vbus_off(struct usb_phy *x)
209{
210	if (!x || !x->set_vbus)
211		return 0;
212
213	return x->set_vbus(x, false);
214}
215
216/* for usb host and peripheral controller drivers */
217#if IS_ENABLED(CONFIG_USB_PHY)
218extern struct usb_phy *usb_get_phy(enum usb_phy_type type);
219extern struct usb_phy *devm_usb_get_phy(struct device *dev,
220	enum usb_phy_type type);
221extern struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
222	const char *phandle, u8 index);
223extern struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
224	struct device_node *node, struct notifier_block *nb);
225extern void usb_put_phy(struct usb_phy *);
226extern void usb_phy_set_event(struct usb_phy *x, unsigned long event);
227extern void usb_phy_set_charger_current(struct usb_phy *usb_phy,
228					unsigned int mA);
229extern void usb_phy_get_charger_current(struct usb_phy *usb_phy,
230					unsigned int *min, unsigned int *max);
231extern void usb_phy_set_charger_state(struct usb_phy *usb_phy,
232				      enum usb_charger_state state);
233#else
234static inline struct usb_phy *usb_get_phy(enum usb_phy_type type)
235{
236	return ERR_PTR(-ENXIO);
237}
238
239static inline struct usb_phy *devm_usb_get_phy(struct device *dev,
240	enum usb_phy_type type)
241{
242	return ERR_PTR(-ENXIO);
243}
244
245static inline struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
246	const char *phandle, u8 index)
247{
248	return ERR_PTR(-ENXIO);
249}
250
251static inline struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
252	struct device_node *node, struct notifier_block *nb)
253{
254	return ERR_PTR(-ENXIO);
255}
256
257static inline void usb_put_phy(struct usb_phy *x)
258{
259}
260
261static inline void usb_phy_set_event(struct usb_phy *x, unsigned long event)
262{
263}
264
265static inline void usb_phy_set_charger_current(struct usb_phy *usb_phy,
266					       unsigned int mA)
267{
268}
269
270static inline void usb_phy_get_charger_current(struct usb_phy *usb_phy,
271					       unsigned int *min,
272					       unsigned int *max)
273{
274}
275
276static inline void usb_phy_set_charger_state(struct usb_phy *usb_phy,
277					     enum usb_charger_state state)
278{
279}
280#endif
281
282static inline int
283usb_phy_set_power(struct usb_phy *x, unsigned mA)
284{
285	if (!x)
286		return 0;
287
288	usb_phy_set_charger_current(x, mA);
289
290	if (x->set_power)
291		return x->set_power(x, mA);
292	return 0;
293}
294
295/* Context: can sleep */
296static inline int
297usb_phy_set_suspend(struct usb_phy *x, int suspend)
298{
299	if (x && x->set_suspend != NULL)
300		return x->set_suspend(x, suspend);
301	else
302		return 0;
303}
304
305static inline int
306usb_phy_set_wakeup(struct usb_phy *x, bool enabled)
307{
308	if (x && x->set_wakeup)
309		return x->set_wakeup(x, enabled);
310	else
311		return 0;
312}
313
314static inline int
315usb_phy_notify_connect(struct usb_phy *x, enum usb_device_speed speed)
316{
317	if (x && x->notify_connect)
318		return x->notify_connect(x, speed);
319	else
320		return 0;
321}
322
323static inline int
324usb_phy_notify_disconnect(struct usb_phy *x, enum usb_device_speed speed)
325{
326	if (x && x->notify_disconnect)
327		return x->notify_disconnect(x, speed);
328	else
329		return 0;
330}
331
332/* notifiers */
333static inline int
334usb_register_notifier(struct usb_phy *x, struct notifier_block *nb)
335{
336	return atomic_notifier_chain_register(&x->notifier, nb);
337}
338
339static inline void
340usb_unregister_notifier(struct usb_phy *x, struct notifier_block *nb)
341{
342	atomic_notifier_chain_unregister(&x->notifier, nb);
343}
344
345static inline const char *usb_phy_type_string(enum usb_phy_type type)
346{
347	switch (type) {
348	case USB_PHY_TYPE_USB2:
349		return "USB2 PHY";
350	case USB_PHY_TYPE_USB3:
351		return "USB3 PHY";
352	default:
353		return "UNKNOWN PHY TYPE";
354	}
355}
356#endif /* __LINUX_USB_PHY_H */