This source file includes following definitions.
- to_gb_usb_device
- gb_usb_device_to_hcd
- hcd_stop
- hcd_start
- urb_enqueue
- urb_dequeue
- get_frame_number
- hub_status_data
- hub_control
- gb_usb_probe
- gb_usb_remove
1
2
3
4
5
6
7
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/usb.h>
12 #include <linux/usb/hcd.h>
13 #include <linux/greybus.h>
14
15 #include "gbphy.h"
16
17
18 #define GB_USB_TYPE_HCD_START 0x02
19 #define GB_USB_TYPE_HCD_STOP 0x03
20 #define GB_USB_TYPE_HUB_CONTROL 0x04
21
22 struct gb_usb_hub_control_request {
23 __le16 typeReq;
24 __le16 wValue;
25 __le16 wIndex;
26 __le16 wLength;
27 };
28
29 struct gb_usb_hub_control_response {
30 u8 buf[0];
31 };
32
33 struct gb_usb_device {
34 struct gb_connection *connection;
35 struct gbphy_device *gbphy_dev;
36 };
37
38 static inline struct gb_usb_device *to_gb_usb_device(struct usb_hcd *hcd)
39 {
40 return (struct gb_usb_device *)hcd->hcd_priv;
41 }
42
43 static inline struct usb_hcd *gb_usb_device_to_hcd(struct gb_usb_device *dev)
44 {
45 return container_of((void *)dev, struct usb_hcd, hcd_priv);
46 }
47
48 static void hcd_stop(struct usb_hcd *hcd)
49 {
50 struct gb_usb_device *dev = to_gb_usb_device(hcd);
51 int ret;
52
53 ret = gb_operation_sync(dev->connection, GB_USB_TYPE_HCD_STOP,
54 NULL, 0, NULL, 0);
55 if (ret)
56 dev_err(&dev->gbphy_dev->dev, "HCD stop failed '%d'\n", ret);
57 }
58
59 static int hcd_start(struct usb_hcd *hcd)
60 {
61 struct usb_bus *bus = hcd_to_bus(hcd);
62 struct gb_usb_device *dev = to_gb_usb_device(hcd);
63 int ret;
64
65 ret = gb_operation_sync(dev->connection, GB_USB_TYPE_HCD_START,
66 NULL, 0, NULL, 0);
67 if (ret) {
68 dev_err(&dev->gbphy_dev->dev, "HCD start failed '%d'\n", ret);
69 return ret;
70 }
71
72 hcd->state = HC_STATE_RUNNING;
73 if (bus->root_hub)
74 usb_hcd_resume_root_hub(hcd);
75 return 0;
76 }
77
78 static int urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
79 {
80 return -ENXIO;
81 }
82
83 static int urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
84 {
85 return -ENXIO;
86 }
87
88 static int get_frame_number(struct usb_hcd *hcd)
89 {
90 return 0;
91 }
92
93 static int hub_status_data(struct usb_hcd *hcd, char *buf)
94 {
95 return 0;
96 }
97
98 static int hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
99 char *buf, u16 wLength)
100 {
101 struct gb_usb_device *dev = to_gb_usb_device(hcd);
102 struct gb_operation *operation;
103 struct gb_usb_hub_control_request *request;
104 struct gb_usb_hub_control_response *response;
105 size_t response_size;
106 int ret;
107
108
109 response_size = sizeof(*response) + wLength;
110
111 operation = gb_operation_create(dev->connection,
112 GB_USB_TYPE_HUB_CONTROL,
113 sizeof(*request),
114 response_size,
115 GFP_KERNEL);
116 if (!operation)
117 return -ENOMEM;
118
119 request = operation->request->payload;
120 request->typeReq = cpu_to_le16(typeReq);
121 request->wValue = cpu_to_le16(wValue);
122 request->wIndex = cpu_to_le16(wIndex);
123 request->wLength = cpu_to_le16(wLength);
124
125 ret = gb_operation_request_send_sync(operation);
126 if (ret)
127 goto out;
128
129 if (wLength) {
130
131 response = operation->response->payload;
132 memcpy(buf, response->buf, wLength);
133 }
134 out:
135 gb_operation_put(operation);
136
137 return ret;
138 }
139
140 static const struct hc_driver usb_gb_hc_driver = {
141 .description = "greybus-hcd",
142 .product_desc = "Greybus USB Host Controller",
143 .hcd_priv_size = sizeof(struct gb_usb_device),
144
145 .flags = HCD_USB2,
146
147 .start = hcd_start,
148 .stop = hcd_stop,
149
150 .urb_enqueue = urb_enqueue,
151 .urb_dequeue = urb_dequeue,
152
153 .get_frame_number = get_frame_number,
154 .hub_status_data = hub_status_data,
155 .hub_control = hub_control,
156 };
157
158 static int gb_usb_probe(struct gbphy_device *gbphy_dev,
159 const struct gbphy_device_id *id)
160 {
161 struct gb_connection *connection;
162 struct device *dev = &gbphy_dev->dev;
163 struct gb_usb_device *gb_usb_dev;
164 struct usb_hcd *hcd;
165 int retval;
166
167 hcd = usb_create_hcd(&usb_gb_hc_driver, dev, dev_name(dev));
168 if (!hcd)
169 return -ENOMEM;
170
171 connection = gb_connection_create(gbphy_dev->bundle,
172 le16_to_cpu(gbphy_dev->cport_desc->id),
173 NULL);
174 if (IS_ERR(connection)) {
175 retval = PTR_ERR(connection);
176 goto exit_usb_put;
177 }
178
179 gb_usb_dev = to_gb_usb_device(hcd);
180 gb_usb_dev->connection = connection;
181 gb_connection_set_data(connection, gb_usb_dev);
182 gb_usb_dev->gbphy_dev = gbphy_dev;
183 gb_gbphy_set_data(gbphy_dev, gb_usb_dev);
184
185 hcd->has_tt = 1;
186
187 retval = gb_connection_enable(connection);
188 if (retval)
189 goto exit_connection_destroy;
190
191
192
193
194
195
196
197 if (1) {
198 dev_warn(dev, "USB protocol disabled\n");
199 retval = -EPROTONOSUPPORT;
200 goto exit_connection_disable;
201 }
202
203 retval = usb_add_hcd(hcd, 0, 0);
204 if (retval)
205 goto exit_connection_disable;
206
207 return 0;
208
209 exit_connection_disable:
210 gb_connection_disable(connection);
211 exit_connection_destroy:
212 gb_connection_destroy(connection);
213 exit_usb_put:
214 usb_put_hcd(hcd);
215
216 return retval;
217 }
218
219 static void gb_usb_remove(struct gbphy_device *gbphy_dev)
220 {
221 struct gb_usb_device *gb_usb_dev = gb_gbphy_get_data(gbphy_dev);
222 struct gb_connection *connection = gb_usb_dev->connection;
223 struct usb_hcd *hcd = gb_usb_device_to_hcd(gb_usb_dev);
224
225 usb_remove_hcd(hcd);
226 gb_connection_disable(connection);
227 gb_connection_destroy(connection);
228 usb_put_hcd(hcd);
229 }
230
231 static const struct gbphy_device_id gb_usb_id_table[] = {
232 { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_USB) },
233 { },
234 };
235 MODULE_DEVICE_TABLE(gbphy, gb_usb_id_table);
236
237 static struct gbphy_driver usb_driver = {
238 .name = "usb",
239 .probe = gb_usb_probe,
240 .remove = gb_usb_remove,
241 .id_table = gb_usb_id_table,
242 };
243
244 module_gbphy_driver(usb_driver);
245 MODULE_LICENSE("GPL v2");