blob: de4f97d84a822ffd746b5550dcb68da08b581438 [file] [log] [blame]
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001/*
2 * Renesas USB driver
3 *
4 * Copyright (C) 2011 Renesas Solutions Corp.
5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
15 *
16 */
Kuninori Morimotodfbb7f42011-11-24 17:28:35 -080017#include <linux/delay.h>
Kuninori Morimotod128a2592011-08-03 21:41:26 -070018#include <linux/dma-mapping.h>
Kuninori Morimoto2f983822011-04-05 11:40:54 +090019#include <linux/io.h>
20#include <linux/module.h>
21#include <linux/platform_device.h>
22#include <linux/usb/ch9.h>
23#include <linux/usb/gadget.h>
Phil Edworthyb5a28752015-07-13 16:30:18 +010024#include <linux/usb/otg.h>
Kuninori Morimoto2f983822011-04-05 11:40:54 +090025#include "common.h"
26
27/*
28 * struct
29 */
30struct usbhsg_request {
31 struct usb_request req;
Kuninori Morimoto4bd04812011-06-06 14:18:07 +090032 struct usbhs_pkt pkt;
Kuninori Morimoto2f983822011-04-05 11:40:54 +090033};
34
35#define EP_NAME_SIZE 8
36struct usbhsg_gpriv;
Kuninori Morimoto2f983822011-04-05 11:40:54 +090037struct usbhsg_uep {
38 struct usb_ep ep;
39 struct usbhs_pipe *pipe;
Kuninori Morimoto2f983822011-04-05 11:40:54 +090040
41 char ep_name[EP_NAME_SIZE];
42
43 struct usbhsg_gpriv *gpriv;
Kuninori Morimoto2f983822011-04-05 11:40:54 +090044};
45
46struct usbhsg_gpriv {
47 struct usb_gadget gadget;
48 struct usbhs_mod mod;
49
50 struct usbhsg_uep *uep;
51 int uep_size;
52
53 struct usb_gadget_driver *driver;
Phil Edworthyb5a28752015-07-13 16:30:18 +010054 struct usb_phy *transceiver;
55 bool vbus_active;
Kuninori Morimoto2f983822011-04-05 11:40:54 +090056
57 u32 status;
58#define USBHSG_STATUS_STARTED (1 << 0)
59#define USBHSG_STATUS_REGISTERD (1 << 1)
60#define USBHSG_STATUS_WEDGE (1 << 2)
Shimoda, Yoshihirocac402d2012-03-16 13:10:15 +090061#define USBHSG_STATUS_SELF_POWERED (1 << 3)
Takeshi Kihara04a5def2014-11-04 10:05:43 +090062#define USBHSG_STATUS_SOFT_CONNECT (1 << 4)
Kuninori Morimoto2f983822011-04-05 11:40:54 +090063};
64
Kuninori Morimoto2f983822011-04-05 11:40:54 +090065struct usbhsg_recip_handle {
66 char *name;
67 int (*device)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
68 struct usb_ctrlrequest *ctrl);
69 int (*interface)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
70 struct usb_ctrlrequest *ctrl);
71 int (*endpoint)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
72 struct usb_ctrlrequest *ctrl);
73};
74
75/*
76 * macro
77 */
78#define usbhsg_priv_to_gpriv(priv) \
79 container_of( \
80 usbhs_mod_get(priv, USBHS_GADGET), \
81 struct usbhsg_gpriv, mod)
82
83#define __usbhsg_for_each_uep(start, pos, g, i) \
Kuninori Morimoto925403f2013-07-11 22:32:31 -070084 for ((i) = start; \
85 ((i) < (g)->uep_size) && ((pos) = (g)->uep + (i)); \
86 (i)++)
Kuninori Morimoto2f983822011-04-05 11:40:54 +090087
88#define usbhsg_for_each_uep(pos, gpriv, i) \
89 __usbhsg_for_each_uep(1, pos, gpriv, i)
90
91#define usbhsg_for_each_uep_with_dcp(pos, gpriv, i) \
92 __usbhsg_for_each_uep(0, pos, gpriv, i)
93
94#define usbhsg_gadget_to_gpriv(g)\
95 container_of(g, struct usbhsg_gpriv, gadget)
96
97#define usbhsg_req_to_ureq(r)\
98 container_of(r, struct usbhsg_request, req)
99
100#define usbhsg_ep_to_uep(e) container_of(e, struct usbhsg_uep, ep)
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900101#define usbhsg_gpriv_to_dev(gp) usbhs_priv_to_dev((gp)->mod.priv)
102#define usbhsg_gpriv_to_priv(gp) ((gp)->mod.priv)
103#define usbhsg_gpriv_to_dcp(gp) ((gp)->uep)
104#define usbhsg_gpriv_to_nth_uep(gp, i) ((gp)->uep + i)
105#define usbhsg_uep_to_gpriv(u) ((u)->gpriv)
106#define usbhsg_uep_to_pipe(u) ((u)->pipe)
107#define usbhsg_pipe_to_uep(p) ((p)->mod_private)
108#define usbhsg_is_dcp(u) ((u) == usbhsg_gpriv_to_dcp((u)->gpriv))
109
Kuninori Morimoto4bd04812011-06-06 14:18:07 +0900110#define usbhsg_ureq_to_pkt(u) (&(u)->pkt)
111#define usbhsg_pkt_to_ureq(i) \
112 container_of(i, struct usbhsg_request, pkt)
113
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900114#define usbhsg_is_not_connected(gp) ((gp)->gadget.speed == USB_SPEED_UNKNOWN)
115
116/* status */
117#define usbhsg_status_init(gp) do {(gp)->status = 0; } while (0)
118#define usbhsg_status_set(gp, b) (gp->status |= b)
119#define usbhsg_status_clr(gp, b) (gp->status &= ~b)
120#define usbhsg_status_has(gp, b) (gp->status & b)
121
122/*
Kuninori Morimoto233f5192011-07-07 00:23:24 -0700123 * queue push/pop
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900124 */
Yoshihiro Shimoda00f30d22015-03-16 16:36:48 +0900125static void __usbhsg_queue_pop(struct usbhsg_uep *uep,
126 struct usbhsg_request *ureq,
127 int status)
128{
129 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
130 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
131 struct device *dev = usbhsg_gpriv_to_dev(gpriv);
132 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
133
134 dev_dbg(dev, "pipe %d : queue pop\n", usbhs_pipe_number(pipe));
135
136 ureq->req.status = status;
137 spin_unlock(usbhs_priv_to_lock(priv));
138 usb_gadget_giveback_request(&uep->ep, &ureq->req);
139 spin_lock(usbhs_priv_to_lock(priv));
140}
141
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900142static void usbhsg_queue_pop(struct usbhsg_uep *uep,
143 struct usbhsg_request *ureq,
144 int status)
145{
146 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
Yoshihiro Shimoda00f30d22015-03-16 16:36:48 +0900147 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
148 unsigned long flags;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900149
Yoshihiro Shimoda00f30d22015-03-16 16:36:48 +0900150 usbhs_lock(priv, flags);
151 __usbhsg_queue_pop(uep, ureq, status);
152 usbhs_unlock(priv, flags);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900153}
154
Kuninori Morimoto2cc97192011-10-10 22:03:39 -0700155static void usbhsg_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900156{
Kuninori Morimoto4bd04812011-06-06 14:18:07 +0900157 struct usbhs_pipe *pipe = pkt->pipe;
158 struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
159 struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
Kuninori Morimoto4bd04812011-06-06 14:18:07 +0900160
Kuninori Morimoto659d4952011-06-06 14:18:23 +0900161 ureq->req.actual = pkt->actual;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900162
Kuninori Morimoto659d4952011-06-06 14:18:23 +0900163 usbhsg_queue_pop(uep, ureq, 0);
Kuninori Morimoto4bd04812011-06-06 14:18:07 +0900164}
165
Kuninori Morimotob3318722011-10-10 22:04:41 -0700166static void usbhsg_queue_push(struct usbhsg_uep *uep,
167 struct usbhsg_request *ureq)
168{
169 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
170 struct device *dev = usbhsg_gpriv_to_dev(gpriv);
171 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
172 struct usbhs_pkt *pkt = usbhsg_ureq_to_pkt(ureq);
173 struct usb_request *req = &ureq->req;
174
175 req->actual = 0;
176 req->status = -EINPROGRESS;
177 usbhs_pkt_push(pipe, pkt, usbhsg_queue_done,
Kuninori Morimoto3edeee32011-12-08 18:28:54 -0800178 req->buf, req->length, req->zero, -1);
Kuninori Morimoto654c35a2011-10-10 22:04:53 -0700179 usbhs_pkt_start(pipe);
Kuninori Morimotob3318722011-10-10 22:04:41 -0700180
181 dev_dbg(dev, "pipe %d : queue push (%d)\n",
182 usbhs_pipe_number(pipe),
183 req->length);
184}
185
Kuninori Morimoto233f5192011-07-07 00:23:24 -0700186/*
187 * dma map/unmap
188 */
Kuninori Morimotoe73a9892011-06-06 14:19:03 +0900189static int usbhsg_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
190{
Felipe Balbiade78f92011-12-19 11:57:16 +0200191 struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
192 struct usb_request *req = &ureq->req;
Kuninori Morimotoe73a9892011-06-06 14:19:03 +0900193 struct usbhs_pipe *pipe = pkt->pipe;
194 struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
195 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
Kuninori Morimotoe73a9892011-06-06 14:19:03 +0900196 enum dma_data_direction dir;
Felipe Balbiade78f92011-12-19 11:57:16 +0200197 int ret = 0;
Kuninori Morimotoe73a9892011-06-06 14:19:03 +0900198
Felipe Balbiade78f92011-12-19 11:57:16 +0200199 dir = usbhs_pipe_is_dir_host(pipe);
Kuninori Morimotoe73a9892011-06-06 14:19:03 +0900200
Felipe Balbiade78f92011-12-19 11:57:16 +0200201 if (map) {
202 /* it can not use scatter/gather */
203 WARN_ON(req->num_sgs);
204
205 ret = usb_gadget_map_request(&gpriv->gadget, req, dir);
206 if (ret < 0)
207 return ret;
208
209 pkt->dma = req->dma;
210 } else {
211 usb_gadget_unmap_request(&gpriv->gadget, req, dir);
212 }
213
214 return ret;
Kuninori Morimotoe73a9892011-06-06 14:19:03 +0900215}
216
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900217/*
218 * USB_TYPE_STANDARD / clear feature functions
219 */
220static int usbhsg_recip_handler_std_control_done(struct usbhs_priv *priv,
221 struct usbhsg_uep *uep,
222 struct usb_ctrlrequest *ctrl)
223{
224 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
225 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
226 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
227
228 usbhs_dcp_control_transfer_done(pipe);
229
230 return 0;
231}
232
233static int usbhsg_recip_handler_std_clear_endpoint(struct usbhs_priv *priv,
234 struct usbhsg_uep *uep,
235 struct usb_ctrlrequest *ctrl)
236{
237 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
238 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
239
240 if (!usbhsg_status_has(gpriv, USBHSG_STATUS_WEDGE)) {
Kuninori Morimotoe8d548d2011-06-06 14:18:03 +0900241 usbhs_pipe_disable(pipe);
Kuninori Morimoto6e6db822011-10-10 22:05:30 -0700242 usbhs_pipe_sequence_data0(pipe);
Kuninori Morimotoe8d548d2011-06-06 14:18:03 +0900243 usbhs_pipe_enable(pipe);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900244 }
245
246 usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
247
Kuninori Morimoto25fa7072011-11-24 17:28:17 -0800248 usbhs_pkt_start(pipe);
249
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900250 return 0;
251}
252
Kuninori Morimoto225da3e2013-03-31 18:34:43 -0700253static struct usbhsg_recip_handle req_clear_feature = {
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900254 .name = "clear feature",
255 .device = usbhsg_recip_handler_std_control_done,
256 .interface = usbhsg_recip_handler_std_control_done,
257 .endpoint = usbhsg_recip_handler_std_clear_endpoint,
258};
259
260/*
Kuninori Morimotoced6e092011-11-24 17:27:50 -0800261 * USB_TYPE_STANDARD / set feature functions
262 */
Kuninori Morimotodfbb7f42011-11-24 17:28:35 -0800263static int usbhsg_recip_handler_std_set_device(struct usbhs_priv *priv,
264 struct usbhsg_uep *uep,
265 struct usb_ctrlrequest *ctrl)
266{
267 switch (le16_to_cpu(ctrl->wValue)) {
268 case USB_DEVICE_TEST_MODE:
269 usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
270 udelay(100);
271 usbhs_sys_set_test_mode(priv, le16_to_cpu(ctrl->wIndex >> 8));
272 break;
273 default:
274 usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
275 break;
276 }
277
278 return 0;
279}
280
Kuninori Morimotoced6e092011-11-24 17:27:50 -0800281static int usbhsg_recip_handler_std_set_endpoint(struct usbhs_priv *priv,
282 struct usbhsg_uep *uep,
283 struct usb_ctrlrequest *ctrl)
284{
285 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
286
287 usbhs_pipe_stall(pipe);
288
289 usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
290
291 return 0;
292}
293
Kuninori Morimoto225da3e2013-03-31 18:34:43 -0700294static struct usbhsg_recip_handle req_set_feature = {
Kuninori Morimotoced6e092011-11-24 17:27:50 -0800295 .name = "set feature",
Kuninori Morimotodfbb7f42011-11-24 17:28:35 -0800296 .device = usbhsg_recip_handler_std_set_device,
Kuninori Morimotoced6e092011-11-24 17:27:50 -0800297 .interface = usbhsg_recip_handler_std_control_done,
298 .endpoint = usbhsg_recip_handler_std_set_endpoint,
299};
300
301/*
Kuninori Morimoto17f7f762011-11-24 17:28:04 -0800302 * USB_TYPE_STANDARD / get status functions
303 */
304static void __usbhsg_recip_send_complete(struct usb_ep *ep,
305 struct usb_request *req)
306{
307 struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
308
309 /* free allocated recip-buffer/usb_request */
310 kfree(ureq->pkt.buf);
311 usb_ep_free_request(ep, req);
312}
313
314static void __usbhsg_recip_send_status(struct usbhsg_gpriv *gpriv,
315 unsigned short status)
316{
317 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
318 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
319 struct device *dev = usbhsg_gpriv_to_dev(gpriv);
320 struct usb_request *req;
321 unsigned short *buf;
322
323 /* alloc new usb_request for recip */
324 req = usb_ep_alloc_request(&dcp->ep, GFP_ATOMIC);
325 if (!req) {
326 dev_err(dev, "recip request allocation fail\n");
327 return;
328 }
329
330 /* alloc recip data buffer */
331 buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
332 if (!buf) {
333 usb_ep_free_request(&dcp->ep, req);
334 dev_err(dev, "recip data allocation fail\n");
335 return;
336 }
337
338 /* recip data is status */
339 *buf = cpu_to_le16(status);
340
341 /* allocated usb_request/buffer will be freed */
342 req->complete = __usbhsg_recip_send_complete;
343 req->buf = buf;
344 req->length = sizeof(*buf);
345 req->zero = 0;
346
347 /* push packet */
348 pipe->handler = &usbhs_fifo_pio_push_handler;
349 usbhsg_queue_push(dcp, usbhsg_req_to_ureq(req));
350}
351
352static int usbhsg_recip_handler_std_get_device(struct usbhs_priv *priv,
353 struct usbhsg_uep *uep,
354 struct usb_ctrlrequest *ctrl)
355{
356 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
Shimoda, Yoshihirocac402d2012-03-16 13:10:15 +0900357 unsigned short status = 0;
358
359 if (usbhsg_status_has(gpriv, USBHSG_STATUS_SELF_POWERED))
360 status = 1 << USB_DEVICE_SELF_POWERED;
Kuninori Morimoto17f7f762011-11-24 17:28:04 -0800361
362 __usbhsg_recip_send_status(gpriv, status);
363
364 return 0;
365}
366
367static int usbhsg_recip_handler_std_get_interface(struct usbhs_priv *priv,
368 struct usbhsg_uep *uep,
369 struct usb_ctrlrequest *ctrl)
370{
371 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
372 unsigned short status = 0;
373
374 __usbhsg_recip_send_status(gpriv, status);
375
376 return 0;
377}
378
379static int usbhsg_recip_handler_std_get_endpoint(struct usbhs_priv *priv,
380 struct usbhsg_uep *uep,
381 struct usb_ctrlrequest *ctrl)
382{
383 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
384 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
385 unsigned short status = 0;
386
387 if (usbhs_pipe_is_stall(pipe))
388 status = 1 << USB_ENDPOINT_HALT;
389
390 __usbhsg_recip_send_status(gpriv, status);
391
392 return 0;
393}
394
Kuninori Morimoto225da3e2013-03-31 18:34:43 -0700395static struct usbhsg_recip_handle req_get_status = {
Kuninori Morimoto17f7f762011-11-24 17:28:04 -0800396 .name = "get status",
397 .device = usbhsg_recip_handler_std_get_device,
398 .interface = usbhsg_recip_handler_std_get_interface,
399 .endpoint = usbhsg_recip_handler_std_get_endpoint,
400};
401
402/*
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900403 * USB_TYPE handler
404 */
405static int usbhsg_recip_run_handle(struct usbhs_priv *priv,
406 struct usbhsg_recip_handle *handler,
407 struct usb_ctrlrequest *ctrl)
408{
409 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
410 struct device *dev = usbhsg_gpriv_to_dev(gpriv);
411 struct usbhsg_uep *uep;
Kuninori Morimoto0432eed2011-06-06 14:18:54 +0900412 struct usbhs_pipe *pipe;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900413 int recip = ctrl->bRequestType & USB_RECIP_MASK;
414 int nth = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
Jesper Juhl7983bc72012-01-16 22:42:10 +0100415 int ret = 0;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900416 int (*func)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
417 struct usb_ctrlrequest *ctrl);
418 char *msg;
419
420 uep = usbhsg_gpriv_to_nth_uep(gpriv, nth);
Kuninori Morimoto0432eed2011-06-06 14:18:54 +0900421 pipe = usbhsg_uep_to_pipe(uep);
422 if (!pipe) {
Kuninori Morimoto9a28b7b2011-04-21 14:10:12 +0900423 dev_err(dev, "wrong recip request\n");
Kuninori Morimoto25fa7072011-11-24 17:28:17 -0800424 return -EINVAL;
Kuninori Morimoto9a28b7b2011-04-21 14:10:12 +0900425 }
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900426
427 switch (recip) {
428 case USB_RECIP_DEVICE:
429 msg = "DEVICE";
430 func = handler->device;
431 break;
432 case USB_RECIP_INTERFACE:
433 msg = "INTERFACE";
434 func = handler->interface;
435 break;
436 case USB_RECIP_ENDPOINT:
437 msg = "ENDPOINT";
438 func = handler->endpoint;
439 break;
440 default:
441 dev_warn(dev, "unsupported RECIP(%d)\n", recip);
442 func = NULL;
443 ret = -EINVAL;
444 }
445
446 if (func) {
447 dev_dbg(dev, "%s (pipe %d :%s)\n", handler->name, nth, msg);
448 ret = func(priv, uep, ctrl);
449 }
450
451 return ret;
452}
453
454/*
455 * irq functions
456 *
457 * it will be called from usbhs_interrupt
458 */
459static int usbhsg_irq_dev_state(struct usbhs_priv *priv,
460 struct usbhs_irq_state *irq_state)
461{
462 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
463 struct device *dev = usbhsg_gpriv_to_dev(gpriv);
464
Kuninori Morimoto75587f52011-10-10 22:01:51 -0700465 gpriv->gadget.speed = usbhs_bus_get_speed(priv);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900466
467 dev_dbg(dev, "state = %x : speed : %d\n",
468 usbhs_status_get_device_state(irq_state),
469 gpriv->gadget.speed);
470
471 return 0;
472}
473
474static int usbhsg_irq_ctrl_stage(struct usbhs_priv *priv,
475 struct usbhs_irq_state *irq_state)
476{
477 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
478 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
479 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
480 struct device *dev = usbhsg_gpriv_to_dev(gpriv);
481 struct usb_ctrlrequest ctrl;
482 struct usbhsg_recip_handle *recip_handler = NULL;
483 int stage = usbhs_status_get_ctrl_stage(irq_state);
484 int ret = 0;
485
486 dev_dbg(dev, "stage = %d\n", stage);
487
488 /*
489 * see Manual
490 *
491 * "Operation"
492 * - "Interrupt Function"
493 * - "Control Transfer Stage Transition Interrupt"
494 * - Fig. "Control Transfer Stage Transitions"
495 */
496
497 switch (stage) {
498 case READ_DATA_STAGE:
Kuninori Morimoto0c6ef985c2011-10-10 22:00:59 -0700499 pipe->handler = &usbhs_fifo_pio_push_handler;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900500 break;
501 case WRITE_DATA_STAGE:
Kuninori Morimoto0c6ef985c2011-10-10 22:00:59 -0700502 pipe->handler = &usbhs_fifo_pio_pop_handler;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900503 break;
504 case NODATA_STATUS_STAGE:
Kuninori Morimoto0c6ef985c2011-10-10 22:00:59 -0700505 pipe->handler = &usbhs_ctrl_stage_end_handler;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900506 break;
Yoshihiro Shimoda4ef35b12014-11-04 10:05:44 +0900507 case READ_STATUS_STAGE:
508 case WRITE_STATUS_STAGE:
509 usbhs_dcp_control_transfer_done(pipe);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900510 default:
511 return ret;
512 }
513
514 /*
515 * get usb request
516 */
517 usbhs_usbreq_get_val(priv, &ctrl);
518
519 switch (ctrl.bRequestType & USB_TYPE_MASK) {
520 case USB_TYPE_STANDARD:
521 switch (ctrl.bRequest) {
522 case USB_REQ_CLEAR_FEATURE:
523 recip_handler = &req_clear_feature;
524 break;
Kuninori Morimotoced6e092011-11-24 17:27:50 -0800525 case USB_REQ_SET_FEATURE:
526 recip_handler = &req_set_feature;
527 break;
Kuninori Morimoto17f7f762011-11-24 17:28:04 -0800528 case USB_REQ_GET_STATUS:
529 recip_handler = &req_get_status;
530 break;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900531 }
532 }
533
534 /*
535 * setup stage / run recip
536 */
537 if (recip_handler)
538 ret = usbhsg_recip_run_handle(priv, recip_handler, &ctrl);
539 else
540 ret = gpriv->driver->setup(&gpriv->gadget, &ctrl);
541
542 if (ret < 0)
Kuninori Morimotoe8d548d2011-06-06 14:18:03 +0900543 usbhs_pipe_stall(pipe);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900544
545 return ret;
546}
547
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900548/*
549 *
550 * usb_dcp_ops
551 *
552 */
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900553static int usbhsg_pipe_disable(struct usbhsg_uep *uep)
554{
555 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
Kuninori Morimoto8a2c2252011-06-06 14:18:33 +0900556 struct usbhs_pkt *pkt;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900557
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900558 while (1) {
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900559 pkt = usbhs_pkt_pop(pipe, NULL);
Kuninori Morimoto8a2c2252011-06-06 14:18:33 +0900560 if (!pkt)
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900561 break;
Kuninori Morimoto91b158f2011-11-24 17:28:26 -0800562
563 usbhsg_queue_pop(uep, usbhsg_pkt_to_ureq(pkt), -ECONNRESET);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900564 }
565
Kuninori Morimoto91b158f2011-11-24 17:28:26 -0800566 usbhs_pipe_disable(pipe);
567
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900568 return 0;
569}
570
571/*
572 *
573 * usb_ep_ops
574 *
575 */
576static int usbhsg_ep_enable(struct usb_ep *ep,
577 const struct usb_endpoint_descriptor *desc)
578{
579 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
580 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
581 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
582 struct usbhs_pipe *pipe;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900583 int ret = -EIO;
584
Kuninori Morimoto409ba9e2011-04-26 09:21:35 +0900585 /*
586 * if it already have pipe,
587 * nothing to do
588 */
Kuninori Morimoto08e6c612011-06-09 16:48:25 +0900589 if (uep->pipe) {
590 usbhs_pipe_clear(uep->pipe);
Kuninori Morimoto6e6db822011-10-10 22:05:30 -0700591 usbhs_pipe_sequence_data0(uep->pipe);
Kuninori Morimoto409ba9e2011-04-26 09:21:35 +0900592 return 0;
Kuninori Morimoto08e6c612011-06-09 16:48:25 +0900593 }
Kuninori Morimoto409ba9e2011-04-26 09:21:35 +0900594
Kuninori Morimotof5aa8892011-10-10 21:59:46 -0700595 pipe = usbhs_pipe_malloc(priv,
596 usb_endpoint_type(desc),
597 usb_endpoint_dir_in(desc));
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900598 if (pipe) {
599 uep->pipe = pipe;
600 pipe->mod_private = uep;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900601
Kuninori Morimotof5aa8892011-10-10 21:59:46 -0700602 /* set epnum / maxp */
Kuninori Morimotobc6fbf52011-10-10 22:04:00 -0700603 usbhs_pipe_config_update(pipe, 0,
Kuninori Morimotof5aa8892011-10-10 21:59:46 -0700604 usb_endpoint_num(desc),
605 usb_endpoint_maxp(desc));
606
Kuninori Morimoto233f5192011-07-07 00:23:24 -0700607 /*
608 * usbhs_fifo_dma_push/pop_handler try to
609 * use dmaengine if possible.
610 * It will use pio handler if impossible.
611 */
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900612 if (usb_endpoint_dir_in(desc))
Kuninori Morimoto0c6ef985c2011-10-10 22:00:59 -0700613 pipe->handler = &usbhs_fifo_dma_push_handler;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900614 else
Kuninori Morimoto0c6ef985c2011-10-10 22:00:59 -0700615 pipe->handler = &usbhs_fifo_dma_pop_handler;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900616
617 ret = 0;
618 }
Kuninori Morimotocb966322011-04-21 14:10:08 +0900619
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900620 return ret;
621}
622
623static int usbhsg_ep_disable(struct usb_ep *ep)
624{
625 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
Yoshihiro Shimodadfb87b82014-07-09 20:30:13 +0900626 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900627
Kazuya Mizuguchi11432052014-11-04 10:05:42 +0900628 if (!pipe)
629 return -EINVAL;
630
Kuninori Morimotod9fa2982012-12-10 22:44:07 -0800631 usbhsg_pipe_disable(uep);
Yoshihiro Shimodadfb87b82014-07-09 20:30:13 +0900632 usbhs_pipe_free(pipe);
Kuninori Morimotod9fa2982012-12-10 22:44:07 -0800633
634 uep->pipe->mod_private = NULL;
635 uep->pipe = NULL;
636
637 return 0;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900638}
639
640static struct usb_request *usbhsg_ep_alloc_request(struct usb_ep *ep,
641 gfp_t gfp_flags)
642{
643 struct usbhsg_request *ureq;
644
645 ureq = kzalloc(sizeof *ureq, gfp_flags);
646 if (!ureq)
647 return NULL;
648
Kuninori Morimoto6acb95d2011-06-06 14:18:16 +0900649 usbhs_pkt_init(usbhsg_ureq_to_pkt(ureq));
650
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900651 return &ureq->req;
652}
653
654static void usbhsg_ep_free_request(struct usb_ep *ep,
655 struct usb_request *req)
656{
657 struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
658
Kuninori Morimoto6acb95d2011-06-06 14:18:16 +0900659 WARN_ON(!list_empty(&ureq->pkt.node));
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900660 kfree(ureq);
661}
662
663static int usbhsg_ep_queue(struct usb_ep *ep, struct usb_request *req,
664 gfp_t gfp_flags)
665{
666 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
667 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
668 struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
669 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900670
671 /* param check */
672 if (usbhsg_is_not_connected(gpriv) ||
673 unlikely(!gpriv->driver) ||
674 unlikely(!pipe))
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900675 return -ESHUTDOWN;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900676
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900677 usbhsg_queue_push(uep, ureq);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900678
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900679 return 0;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900680}
681
682static int usbhsg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
683{
684 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
685 struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900686 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900687
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900688 usbhs_pkt_pop(pipe, usbhsg_ureq_to_pkt(ureq));
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900689 usbhsg_queue_pop(uep, ureq, -ECONNRESET);
690
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900691 return 0;
692}
693
694static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge)
695{
696 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
697 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
698 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900699 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900700 struct device *dev = usbhsg_gpriv_to_dev(gpriv);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900701 unsigned long flags;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900702
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900703 usbhsg_pipe_disable(uep);
704
705 dev_dbg(dev, "set halt %d (pipe %d)\n",
706 halt, usbhs_pipe_number(pipe));
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900707
708 /******************** spin lock ********************/
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900709 usbhs_lock(priv, flags);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900710
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900711 if (halt)
712 usbhs_pipe_stall(pipe);
713 else
714 usbhs_pipe_disable(pipe);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900715
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900716 if (halt && wedge)
717 usbhsg_status_set(gpriv, USBHSG_STATUS_WEDGE);
718 else
719 usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900720
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900721 usbhs_unlock(priv, flags);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900722 /******************** spin unlock ******************/
723
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900724 return 0;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900725}
726
727static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)
728{
729 return __usbhsg_ep_set_halt_wedge(ep, value, 0);
730}
731
732static int usbhsg_ep_set_wedge(struct usb_ep *ep)
733{
734 return __usbhsg_ep_set_halt_wedge(ep, 1, 1);
735}
736
737static struct usb_ep_ops usbhsg_ep_ops = {
738 .enable = usbhsg_ep_enable,
739 .disable = usbhsg_ep_disable,
740
741 .alloc_request = usbhsg_ep_alloc_request,
742 .free_request = usbhsg_ep_free_request,
743
744 .queue = usbhsg_ep_queue,
745 .dequeue = usbhsg_ep_dequeue,
746
747 .set_halt = usbhsg_ep_set_halt,
748 .set_wedge = usbhsg_ep_set_wedge,
749};
750
751/*
Takeshi Kihara04a5def2014-11-04 10:05:43 +0900752 * pullup control
753 */
754static int usbhsg_can_pullup(struct usbhs_priv *priv)
755{
756 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
757
758 return gpriv->driver &&
759 usbhsg_status_has(gpriv, USBHSG_STATUS_SOFT_CONNECT);
760}
761
762static void usbhsg_update_pullup(struct usbhs_priv *priv)
763{
764 if (usbhsg_can_pullup(priv))
765 usbhs_sys_function_pullup(priv, 1);
766 else
767 usbhs_sys_function_pullup(priv, 0);
768}
769
770/*
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900771 * usb module start/end
772 */
773static int usbhsg_try_start(struct usbhs_priv *priv, u32 status)
774{
775 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
776 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
777 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
778 struct device *dev = usbhs_priv_to_dev(priv);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900779 unsigned long flags;
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900780 int ret = 0;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900781
782 /******************** spin lock ********************/
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900783 usbhs_lock(priv, flags);
784
785 usbhsg_status_set(gpriv, status);
786 if (!(usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
787 usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD)))
788 ret = -1; /* not ready */
789
790 usbhs_unlock(priv, flags);
791 /******************** spin unlock ********************/
792
793 if (ret < 0)
794 return 0; /* not ready is not error */
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900795
796 /*
797 * enable interrupt and systems if ready
798 */
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900799 dev_dbg(dev, "start gadget\n");
800
801 /*
802 * pipe initialize and enable DCP
803 */
Yoshihiro Shimodacdeb7942014-11-04 10:05:45 +0900804 usbhs_fifo_init(priv);
Kuninori Morimoto4bd04812011-06-06 14:18:07 +0900805 usbhs_pipe_init(priv,
Kuninori Morimotoe73a9892011-06-06 14:19:03 +0900806 usbhsg_dma_map_ctrl);
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900807
Kuninori Morimotod9fa2982012-12-10 22:44:07 -0800808 /* dcp init instead of usbhsg_ep_enable() */
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900809 dcp->pipe = usbhs_dcp_malloc(priv);
810 dcp->pipe->mod_private = dcp;
Kuninori Morimotobc6fbf52011-10-10 22:04:00 -0700811 usbhs_pipe_config_update(dcp->pipe, 0, 0, 64);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900812
813 /*
814 * system config enble
815 * - HI speed
816 * - function
817 * - usb module
818 */
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900819 usbhs_sys_function_ctrl(priv, 1);
Takeshi Kihara04a5def2014-11-04 10:05:43 +0900820 usbhsg_update_pullup(priv);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900821
822 /*
823 * enable irq callback
824 */
825 mod->irq_dev_state = usbhsg_irq_dev_state;
826 mod->irq_ctrl_stage = usbhsg_irq_ctrl_stage;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900827 usbhs_irq_callback_update(priv, mod);
828
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900829 return 0;
830}
831
832static int usbhsg_try_stop(struct usbhs_priv *priv, u32 status)
833{
834 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
835 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
836 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
837 struct device *dev = usbhs_priv_to_dev(priv);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900838 unsigned long flags;
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900839 int ret = 0;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900840
841 /******************** spin lock ********************/
Kuninori Morimoto97664a22011-06-06 14:18:38 +0900842 usbhs_lock(priv, flags);
843
844 usbhsg_status_clr(gpriv, status);
845 if (!usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
846 !usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD))
847 ret = -1; /* already done */
848
849 usbhs_unlock(priv, flags);
850 /******************** spin unlock ********************/
851
852 if (ret < 0)
853 return 0; /* already done is not error */
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900854
855 /*
856 * disable interrupt and systems if 1st try
857 */
Kuninori Morimotodad67392011-06-06 14:18:28 +0900858 usbhs_fifo_quit(priv);
859
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900860 /* disable all irq */
861 mod->irq_dev_state = NULL;
862 mod->irq_ctrl_stage = NULL;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900863 usbhs_irq_callback_update(priv, mod);
864
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900865 gpriv->gadget.speed = USB_SPEED_UNKNOWN;
866
867 /* disable sys */
Kuninori Morimotodfbb7f42011-11-24 17:28:35 -0800868 usbhs_sys_set_test_mode(priv, 0);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900869 usbhs_sys_function_ctrl(priv, 0);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900870
Kuninori Morimotod9fa2982012-12-10 22:44:07 -0800871 usbhsg_ep_disable(&dcp->ep);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900872
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900873 dev_dbg(dev, "stop gadget\n");
874
875 return 0;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900876}
877
878/*
Phil Edworthyb5a28752015-07-13 16:30:18 +0100879 * VBUS provided by the PHY
880 */
881static int usbhsm_phy_get_vbus(struct platform_device *pdev)
882{
883 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
884 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
885
886 return gpriv->vbus_active;
887}
888
889static void usbhs_mod_phy_mode(struct usbhs_priv *priv)
890{
891 struct usbhs_mod_info *info = &priv->mod_info;
892
893 info->irq_vbus = NULL;
894 priv->pfunc.get_vbus = usbhsm_phy_get_vbus;
895
896 usbhs_irq_callback_update(priv, NULL);
897}
898
899/*
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900900 *
901 * linux usb function
902 *
903 */
Felipe Balbiaf1d7052011-10-10 17:11:20 +0300904static int usbhsg_gadget_start(struct usb_gadget *gadget,
905 struct usb_gadget_driver *driver)
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900906{
Felipe Balbiaf1d7052011-10-10 17:11:20 +0300907 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
Kuninori Morimotof8eff0a2011-11-17 18:19:06 -0800908 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
Phil Edworthyb5a28752015-07-13 16:30:18 +0100909 struct device *dev = usbhs_priv_to_dev(priv);
910 int ret;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900911
Felipe Balbiaf1d7052011-10-10 17:11:20 +0300912 if (!driver ||
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900913 !driver->setup ||
Michal Nazarewicz7177aed2011-11-19 18:27:38 +0100914 driver->max_speed < USB_SPEED_FULL)
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900915 return -EINVAL;
Kuninori Morimoto3b872182011-07-03 17:42:35 -0700916
Phil Edworthyb5a28752015-07-13 16:30:18 +0100917 /* connect to bus through transceiver */
918 if (!IS_ERR_OR_NULL(gpriv->transceiver)) {
919 ret = otg_set_peripheral(gpriv->transceiver->otg,
920 &gpriv->gadget);
921 if (ret) {
922 dev_err(dev, "%s: can't bind to transceiver\n",
923 gpriv->gadget.name);
924 return ret;
925 }
926
927 /* get vbus using phy versions */
928 usbhs_mod_phy_mode(priv);
929 }
930
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900931 /* first hook up the driver ... */
932 gpriv->driver = driver;
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900933
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900934 return usbhsg_try_start(priv, USBHSG_STATUS_REGISTERD);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900935}
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900936
Felipe Balbi22835b82014-10-17 12:05:12 -0500937static int usbhsg_gadget_stop(struct usb_gadget *gadget)
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900938{
Felipe Balbiaf1d7052011-10-10 17:11:20 +0300939 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
Kuninori Morimotof8eff0a2011-11-17 18:19:06 -0800940 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900941
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900942 usbhsg_try_stop(priv, USBHSG_STATUS_REGISTERD);
Phil Edworthyb5a28752015-07-13 16:30:18 +0100943
944 if (!IS_ERR_OR_NULL(gpriv->transceiver))
945 otg_set_peripheral(gpriv->transceiver->otg, NULL);
946
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900947 gpriv->driver = NULL;
948
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900949 return 0;
950}
Kuninori Morimoto2f983822011-04-05 11:40:54 +0900951
952/*
953 * usb gadget ops
954 */
955static int usbhsg_get_frame(struct usb_gadget *gadget)
956{
957 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
958 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
959
960 return usbhs_frame_get_num(priv);
961}
962
kuninori.morimoto.gx@renesas.com4cd2f592012-10-15 23:24:19 -0700963static int usbhsg_pullup(struct usb_gadget *gadget, int is_on)
964{
965 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
966 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
Takeshi Kihara04a5def2014-11-04 10:05:43 +0900967 unsigned long flags;
kuninori.morimoto.gx@renesas.com4cd2f592012-10-15 23:24:19 -0700968
Takeshi Kihara04a5def2014-11-04 10:05:43 +0900969 usbhs_lock(priv, flags);
970 if (is_on)
971 usbhsg_status_set(gpriv, USBHSG_STATUS_SOFT_CONNECT);
972 else
973 usbhsg_status_clr(gpriv, USBHSG_STATUS_SOFT_CONNECT);
974 usbhsg_update_pullup(priv);
975 usbhs_unlock(priv, flags);
kuninori.morimoto.gx@renesas.com4cd2f592012-10-15 23:24:19 -0700976
977 return 0;
978}
979
Shimoda, Yoshihirocac402d2012-03-16 13:10:15 +0900980static int usbhsg_set_selfpowered(struct usb_gadget *gadget, int is_self)
981{
982 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
983
984 if (is_self)
985 usbhsg_status_set(gpriv, USBHSG_STATUS_SELF_POWERED);
986 else
987 usbhsg_status_clr(gpriv, USBHSG_STATUS_SELF_POWERED);
988
Peter Chena17fd412015-01-28 16:32:28 +0800989 gadget->is_selfpowered = (is_self != 0);
990
Shimoda, Yoshihirocac402d2012-03-16 13:10:15 +0900991 return 0;
992}
993
Phil Edworthyb5a28752015-07-13 16:30:18 +0100994static int usbhsg_vbus_session(struct usb_gadget *gadget, int is_active)
995{
996 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
997 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
998 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
999
1000 gpriv->vbus_active = !!is_active;
1001
1002 renesas_usbhs_call_notify_hotplug(pdev);
1003
1004 return 0;
1005}
1006
Felipe Balbieeef4582013-01-24 17:58:16 +02001007static const struct usb_gadget_ops usbhsg_gadget_ops = {
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001008 .get_frame = usbhsg_get_frame,
Shimoda, Yoshihirocac402d2012-03-16 13:10:15 +09001009 .set_selfpowered = usbhsg_set_selfpowered,
Felipe Balbiaf1d7052011-10-10 17:11:20 +03001010 .udc_start = usbhsg_gadget_start,
1011 .udc_stop = usbhsg_gadget_stop,
kuninori.morimoto.gx@renesas.com4cd2f592012-10-15 23:24:19 -07001012 .pullup = usbhsg_pullup,
Phil Edworthyb5a28752015-07-13 16:30:18 +01001013 .vbus_session = usbhsg_vbus_session,
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001014};
1015
1016static int usbhsg_start(struct usbhs_priv *priv)
1017{
1018 return usbhsg_try_start(priv, USBHSG_STATUS_STARTED);
1019}
1020
1021static int usbhsg_stop(struct usbhs_priv *priv)
1022{
Kuninori Morimoto8885a892011-11-17 18:19:38 -08001023 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
1024
1025 /* cable disconnect */
1026 if (gpriv->driver &&
1027 gpriv->driver->disconnect)
1028 gpriv->driver->disconnect(&gpriv->gadget);
1029
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001030 return usbhsg_try_stop(priv, USBHSG_STATUS_STARTED);
1031}
1032
Kuninori Morimotob7a8d172011-10-26 19:33:49 -07001033int usbhs_mod_gadget_probe(struct usbhs_priv *priv)
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001034{
1035 struct usbhsg_gpriv *gpriv;
1036 struct usbhsg_uep *uep;
1037 struct device *dev = usbhs_priv_to_dev(priv);
1038 int pipe_size = usbhs_get_dparam(priv, pipe_size);
1039 int i;
Sebastian Andrzej Siewior0f913492011-06-28 16:33:47 +03001040 int ret;
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001041
1042 gpriv = kzalloc(sizeof(struct usbhsg_gpriv), GFP_KERNEL);
1043 if (!gpriv) {
1044 dev_err(dev, "Could not allocate gadget priv\n");
1045 return -ENOMEM;
1046 }
1047
1048 uep = kzalloc(sizeof(struct usbhsg_uep) * pipe_size, GFP_KERNEL);
1049 if (!uep) {
1050 dev_err(dev, "Could not allocate ep\n");
Sebastian Andrzej Siewior0f913492011-06-28 16:33:47 +03001051 ret = -ENOMEM;
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001052 goto usbhs_mod_gadget_probe_err_gpriv;
1053 }
1054
Phil Edworthyb5a28752015-07-13 16:30:18 +01001055 gpriv->transceiver = usb_get_phy(USB_PHY_TYPE_UNDEFINED);
1056 dev_info(dev, "%stransceiver found\n",
1057 gpriv->transceiver ? "" : "no ");
1058
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001059 /*
1060 * CAUTION
1061 *
1062 * There is no guarantee that it is possible to access usb module here.
1063 * Don't accesses to it.
1064 * The accesse will be enable after "usbhsg_start"
1065 */
1066
1067 /*
1068 * register itself
1069 */
1070 usbhs_mod_register(priv, &gpriv->mod, USBHS_GADGET);
1071
1072 /* init gpriv */
1073 gpriv->mod.name = "gadget";
1074 gpriv->mod.start = usbhsg_start;
1075 gpriv->mod.stop = usbhsg_stop;
1076 gpriv->uep = uep;
1077 gpriv->uep_size = pipe_size;
1078 usbhsg_status_init(gpriv);
1079
1080 /*
1081 * init gadget
1082 */
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001083 gpriv->gadget.dev.parent = dev;
1084 gpriv->gadget.name = "renesas_usbhs_udc";
1085 gpriv->gadget.ops = &usbhsg_gadget_ops;
Michal Nazarewiczd327ab52011-11-19 18:27:37 +01001086 gpriv->gadget.max_speed = USB_SPEED_HIGH;
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001087
1088 INIT_LIST_HEAD(&gpriv->gadget.ep_list);
1089
1090 /*
1091 * init usb_ep
1092 */
1093 usbhsg_for_each_uep_with_dcp(uep, gpriv, i) {
1094 uep->gpriv = gpriv;
Kuninori Morimoto58482942012-12-10 22:43:45 -08001095 uep->pipe = NULL;
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001096 snprintf(uep->ep_name, EP_NAME_SIZE, "ep%d", i);
1097
1098 uep->ep.name = uep->ep_name;
1099 uep->ep.ops = &usbhsg_ep_ops;
1100 INIT_LIST_HEAD(&uep->ep.ep_list);
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001101
1102 /* init DCP */
1103 if (usbhsg_is_dcp(uep)) {
1104 gpriv->gadget.ep0 = &uep->ep;
Robert Baldygae117e742013-12-13 12:23:38 +01001105 usb_ep_set_maxpacket_limit(&uep->ep, 64);
Robert Baldyga916f7ac2015-07-31 16:00:47 +02001106 uep->ep.caps.type_control = true;
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001107 }
1108 /* init normal pipe */
1109 else {
Robert Baldygae117e742013-12-13 12:23:38 +01001110 usb_ep_set_maxpacket_limit(&uep->ep, 512);
Robert Baldyga916f7ac2015-07-31 16:00:47 +02001111 uep->ep.caps.type_iso = true;
1112 uep->ep.caps.type_bulk = true;
1113 uep->ep.caps.type_int = true;
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001114 list_add_tail(&uep->ep.ep_list, &gpriv->gadget.ep_list);
1115 }
Robert Baldyga916f7ac2015-07-31 16:00:47 +02001116 uep->ep.caps.dir_in = true;
1117 uep->ep.caps.dir_out = true;
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001118 }
1119
Sebastian Andrzej Siewior0f913492011-06-28 16:33:47 +03001120 ret = usb_add_gadget_udc(dev, &gpriv->gadget);
1121 if (ret)
Felipe Balbi0972ef72013-01-24 17:08:01 +02001122 goto err_add_udc;
Sebastian Andrzej Siewior0f913492011-06-28 16:33:47 +03001123
1124
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001125 dev_info(dev, "gadget probed\n");
1126
1127 return 0;
Kuninori Morimotof8eff0a2011-11-17 18:19:06 -08001128
Sebastian Andrzej Siewior0f913492011-06-28 16:33:47 +03001129err_add_udc:
1130 kfree(gpriv->uep);
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001131
1132usbhs_mod_gadget_probe_err_gpriv:
1133 kfree(gpriv);
1134
Sebastian Andrzej Siewior0f913492011-06-28 16:33:47 +03001135 return ret;
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001136}
1137
Kuninori Morimotob7a8d172011-10-26 19:33:49 -07001138void usbhs_mod_gadget_remove(struct usbhs_priv *priv)
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001139{
1140 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
1141
Sebastian Andrzej Siewior0f913492011-06-28 16:33:47 +03001142 usb_del_gadget_udc(&gpriv->gadget);
Kuninori Morimoto3b872182011-07-03 17:42:35 -07001143
Sebastian Andrzej Siewior3af51ac2011-06-03 19:50:48 +02001144 kfree(gpriv->uep);
Kuninori Morimoto2f983822011-04-05 11:40:54 +09001145 kfree(gpriv);
1146}