1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/* USB OTG (On The Go) defines */
/*
*
* These APIs may be used between USB controllers. USB device drivers
* (for either host or peripheral roles) don't use these calls; they
* continue to use just usb_device and usb_gadget.
*/
#ifndef __LINUX_USB_PHY_H
#define __LINUX_USB_PHY_H
#include <notifier.h>
#include <usb/usb.h>
#include <linux/err.h>
enum usb_phy_interface {
USBPHY_INTERFACE_MODE_UNKNOWN,
USBPHY_INTERFACE_MODE_UTMI,
USBPHY_INTERFACE_MODE_UTMIW,
USBPHY_INTERFACE_MODE_ULPI,
USBPHY_INTERFACE_MODE_SERIAL,
USBPHY_INTERFACE_MODE_HSIC,
};
enum usb_phy_events {
USB_EVENT_NONE, /* no events or cable disconnected */
USB_EVENT_VBUS, /* vbus valid event */
USB_EVENT_ID, /* id was grounded */
USB_EVENT_CHARGER, /* usb dedicated charger */
USB_EVENT_ENUMERATED, /* gadget driver enumerated */
};
/* associate a type with PHY */
enum usb_phy_type {
USB_PHY_TYPE_UNDEFINED,
USB_PHY_TYPE_USB2,
USB_PHY_TYPE_USB3,
};
struct usb_phy;
/* for transceivers connected thru an ULPI interface, the user must
* provide access ops
*/
struct usb_phy_io_ops {
int (*read)(struct usb_phy *x, u32 reg);
int (*write)(struct usb_phy *x, u32 val, u32 reg);
};
struct usb_phy {
struct device_d *dev;
const char *label;
unsigned int flags;
enum usb_phy_type type;
enum usb_phy_events last_event;
struct usb_phy_io_ops *io_ops;
void __iomem *io_priv;
/* to pass extra port status to the root hub */
u16 port_status;
u16 port_change;
/* to support controllers that have multiple transceivers */
struct list_head head;
/* initialize/shutdown the OTG controller */
int (*init)(struct usb_phy *x);
void (*shutdown)(struct usb_phy *x);
/* enable/disable VBUS */
int (*set_vbus)(struct usb_phy *x, int on);
/* effective for B devices, ignored for A-peripheral */
int (*set_power)(struct usb_phy *x,
unsigned mA);
/* for non-OTG B devices: set transceiver into suspend mode */
int (*set_suspend)(struct usb_phy *x,
int suspend);
/*
* Set wakeup enable for PHY, in that case, the PHY can be
* woken up from suspend status due to external events,
* like vbus change, dp/dm change and id.
*/
int (*set_wakeup)(struct usb_phy *x, bool enabled);
/* notify phy connect status change */
int (*notify_connect)(struct usb_phy *x,
enum usb_device_speed speed);
int (*notify_disconnect)(struct usb_phy *x,
enum usb_device_speed speed);
};
/**
* struct usb_phy_bind - represent the binding for the phy
* @dev_name: the device name of the device that will bind to the phy
* @phy_dev_name: the device name of the phy
* @index: used if a single controller uses multiple phys
* @phy: reference to the phy
* @list: to maintain a linked list of the binding information
*/
struct usb_phy_bind {
const char *dev_name;
const char *phy_dev_name;
u8 index;
struct usb_phy *phy;
struct list_head list;
};
/* helpers for direct access thru low-level io interface */
static inline int usb_phy_io_read(struct usb_phy *x, u32 reg)
{
if (x && x->io_ops && x->io_ops->read)
return x->io_ops->read(x, reg);
return -EINVAL;
}
static inline int usb_phy_io_write(struct usb_phy *x, u32 val, u32 reg)
{
if (x && x->io_ops && x->io_ops->write)
return x->io_ops->write(x, val, reg);
return -EINVAL;
}
static inline int
usb_phy_init(struct usb_phy *x)
{
if (x && x->init)
return x->init(x);
return 0;
}
static inline void
usb_phy_shutdown(struct usb_phy *x)
{
if (x && x->shutdown)
x->shutdown(x);
}
static inline int
usb_phy_vbus_on(struct usb_phy *x)
{
if (!x || !x->set_vbus)
return 0;
return x->set_vbus(x, true);
}
static inline int
usb_phy_vbus_off(struct usb_phy *x)
{
if (!x || !x->set_vbus)
return 0;
return x->set_vbus(x, false);
}
static inline int
usb_phy_set_power(struct usb_phy *x, unsigned mA)
{
if (x && x->set_power)
return x->set_power(x, mA);
return 0;
}
/* Context: can sleep */
static inline int
usb_phy_set_suspend(struct usb_phy *x, int suspend)
{
if (x && x->set_suspend != NULL)
return x->set_suspend(x, suspend);
else
return 0;
}
static inline int
usb_phy_set_wakeup(struct usb_phy *x, bool enabled)
{
if (x && x->set_wakeup)
return x->set_wakeup(x, enabled);
else
return 0;
}
static inline int
usb_phy_notify_connect(struct usb_phy *x, enum usb_device_speed speed)
{
if (x && x->notify_connect)
return x->notify_connect(x, speed);
else
return 0;
}
static inline int
usb_phy_notify_disconnect(struct usb_phy *x, enum usb_device_speed speed)
{
if (x && x->notify_disconnect)
return x->notify_disconnect(x, speed);
else
return 0;
}
static inline const char *usb_phy_type_string(enum usb_phy_type type)
{
switch (type) {
case USB_PHY_TYPE_USB2:
return "USB2 PHY";
case USB_PHY_TYPE_USB3:
return "USB3 PHY";
default:
return "UNKNOWN PHY TYPE";
}
}
#endif /* __LINUX_USB_PHY_H */
|
