drivers/usb/renesas_usbhs/mod_gadget.c

   1 // SPDX-License-Identifier: GPL-1.0+
   2 /*
   3  * Renesas USB driver
   4  *
   5  * Copyright (C) 2011 Renesas Solutions Corp.
   6  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   7  */
   8 #include <linux/delay.h>
   9 #include <linux/dma-mapping.h>
  10 #include <linux/io.h>
  11 #include <linux/module.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/usb/ch9.h>
  14 #include <linux/usb/gadget.h>
  15 #include <linux/usb/otg.h>
  16 #include "common.h"
  17
  18 /*
  19  *              struct
  20  */
  21 struct usbhsg_request {
  22         struct usb_request      req;
  23         struct usbhs_pkt        pkt;
  24 };
  25
  26 #define EP_NAME_SIZE 8
  27 struct usbhsg_gpriv;
  28 struct usbhsg_uep {
  29         struct usb_ep            ep;
  30         struct usbhs_pipe       *pipe;
  31         spinlock_t              lock;   /* protect the pipe */
  32
  33         char ep_name[EP_NAME_SIZE];
  34
  35         struct usbhsg_gpriv *gpriv;
  36 };
  37
  38 struct usbhsg_gpriv {
  39         struct usb_gadget        gadget;
  40         struct usbhs_mod         mod;
  41
  42         struct usbhsg_uep       *uep;
  43         int                      uep_size;
  44
  45         struct usb_gadget_driver        *driver;
  46         struct usb_phy          *transceiver;
  47         bool                     vbus_active;
  48
  49         u32     status;
  50 #define USBHSG_STATUS_STARTED           (1 << 0)
  51 #define USBHSG_STATUS_REGISTERD         (1 << 1)
  52 #define USBHSG_STATUS_WEDGE             (1 << 2)
  53 #define USBHSG_STATUS_SELF_POWERED      (1 << 3)
  54 #define USBHSG_STATUS_SOFT_CONNECT      (1 << 4)
  55 };
  56
  57 struct usbhsg_recip_handle {
  58         char *name;
  59         int (*device)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
  60                       struct usb_ctrlrequest *ctrl);
  61         int (*interface)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
  62                          struct usb_ctrlrequest *ctrl);
  63         int (*endpoint)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
  64                         struct usb_ctrlrequest *ctrl);
  65 };
  66
  67 /*
  68  *              macro
  69  */
  70 #define usbhsg_priv_to_gpriv(priv)                      \
  71         container_of(                                   \
  72                 usbhs_mod_get(priv, USBHS_GADGET),      \
  73                 struct usbhsg_gpriv, mod)
  74
  75 #define __usbhsg_for_each_uep(start, pos, g, i) \
  76         for ((i) = start;                                       \
  77              ((i) < (g)->uep_size) && ((pos) = (g)->uep + (i)); \
  78              (i)++)
  79
  80 #define usbhsg_for_each_uep(pos, gpriv, i)      \
  81         __usbhsg_for_each_uep(1, pos, gpriv, i)
  82
  83 #define usbhsg_for_each_uep_with_dcp(pos, gpriv, i)     \
  84         __usbhsg_for_each_uep(0, pos, gpriv, i)
  85
  86 #define usbhsg_gadget_to_gpriv(g)\
  87         container_of(g, struct usbhsg_gpriv, gadget)
  88
  89 #define usbhsg_req_to_ureq(r)\
  90         container_of(r, struct usbhsg_request, req)
  91
  92 #define usbhsg_ep_to_uep(e)             container_of(e, struct usbhsg_uep, ep)
  93 #define usbhsg_gpriv_to_dev(gp)         usbhs_priv_to_dev((gp)->mod.priv)
  94 #define usbhsg_gpriv_to_priv(gp)        ((gp)->mod.priv)
  95 #define usbhsg_gpriv_to_dcp(gp)         ((gp)->uep)
  96 #define usbhsg_gpriv_to_nth_uep(gp, i)  ((gp)->uep + i)
  97 #define usbhsg_uep_to_gpriv(u)          ((u)->gpriv)
  98 #define usbhsg_uep_to_pipe(u)           ((u)->pipe)
  99 #define usbhsg_pipe_to_uep(p)           ((p)->mod_private)
 100 #define usbhsg_is_dcp(u)                ((u) == usbhsg_gpriv_to_dcp((u)->gpriv))
 101
 102 #define usbhsg_ureq_to_pkt(u)           (&(u)->pkt)
 103 #define usbhsg_pkt_to_ureq(i)   \
 104         container_of(i, struct usbhsg_request, pkt)
 105
 106 #define usbhsg_is_not_connected(gp) ((gp)->gadget.speed == USB_SPEED_UNKNOWN)
 107
 108 /* status */
 109 #define usbhsg_status_init(gp)   do {(gp)->status = 0; } while (0)
 110 #define usbhsg_status_set(gp, b) (gp->status |=  b)
 111 #define usbhsg_status_clr(gp, b) (gp->status &= ~b)
 112 #define usbhsg_status_has(gp, b) (gp->status &   b)
 113
 114 /*
 115  *              queue push/pop
 116  */
 117 static void __usbhsg_queue_pop(struct usbhsg_uep *uep,
 118                                struct usbhsg_request *ureq,
 119                                int status)
 120 {
 121         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 122         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
 123         struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 124         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
 125
 126         if (pipe)
 127                 dev_dbg(dev, "pipe %d : queue pop\n", usbhs_pipe_number(pipe));
 128
 129         ureq->req.status = status;
 130         spin_unlock(usbhs_priv_to_lock(priv));
 131         usb_gadget_giveback_request(&uep->ep, &ureq->req);
 132         spin_lock(usbhs_priv_to_lock(priv));
 133 }
 134
 135 static void usbhsg_queue_pop(struct usbhsg_uep *uep,
 136                              struct usbhsg_request *ureq,
 137                              int status)
 138 {
 139         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 140         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
 141         unsigned long flags;
 142
 143         usbhs_lock(priv, flags);
 144         __usbhsg_queue_pop(uep, ureq, status);
 145         usbhs_unlock(priv, flags);
 146 }
 147
 148 static void usbhsg_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
 149 {
 150         struct usbhs_pipe *pipe = pkt->pipe;
 151         struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
 152         struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
 153         unsigned long flags;
 154
 155         ureq->req.actual = pkt->actual;
 156
 157         usbhs_lock(priv, flags);
 158         if (uep)
 159                 __usbhsg_queue_pop(uep, ureq, 0);
 160         usbhs_unlock(priv, flags);
 161 }
 162
 163 static void usbhsg_queue_push(struct usbhsg_uep *uep,
 164                               struct usbhsg_request *ureq)
 165 {
 166         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 167         struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 168         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
 169         struct usbhs_pkt *pkt = usbhsg_ureq_to_pkt(ureq);
 170         struct usb_request *req = &ureq->req;
 171
 172         req->actual = 0;
 173         req->status = -EINPROGRESS;
 174         usbhs_pkt_push(pipe, pkt, usbhsg_queue_done,
 175                        req->buf, req->length, req->zero, -1);
 176         usbhs_pkt_start(pipe);
 177
 178         dev_dbg(dev, "pipe %d : queue push (%d)\n",
 179                 usbhs_pipe_number(pipe),
 180                 req->length);
 181 }
 182
 183 /*
 184  *              dma map/unmap
 185  */
 186 static int usbhsg_dma_map_ctrl(struct device *dma_dev, struct usbhs_pkt *pkt,
 187                                int map)
 188 {
 189         struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
 190         struct usb_request *req = &ureq->req;
 191         struct usbhs_pipe *pipe = pkt->pipe;
 192         enum dma_data_direction dir;
 193         int ret = 0;
 194
 195         dir = usbhs_pipe_is_dir_host(pipe);
 196
 197         if (map) {
 198                 /* it can not use scatter/gather */
 199                 WARN_ON(req->num_sgs);
 200
 201                 ret = usb_gadget_map_request_by_dev(dma_dev, req, dir);
 202                 if (ret < 0)
 203                         return ret;
 204
 205                 pkt->dma = req->dma;
 206         } else {
 207                 usb_gadget_unmap_request_by_dev(dma_dev, req, dir);
 208         }
 209
 210         return ret;
 211 }
 212
 213 /*
 214  *              USB_TYPE_STANDARD / clear feature functions
 215  */
 216 static int usbhsg_recip_handler_std_control_done(struct usbhs_priv *priv,
 217                                                  struct usbhsg_uep *uep,
 218                                                  struct usb_ctrlrequest *ctrl)
 219 {
 220         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 221         struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
 222         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
 223
 224         usbhs_dcp_control_transfer_done(pipe);
 225
 226         return 0;
 227 }
 228
 229 static int usbhsg_recip_handler_std_clear_endpoint(struct usbhs_priv *priv,
 230                                                    struct usbhsg_uep *uep,
 231                                                    struct usb_ctrlrequest *ctrl)
 232 {
 233         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 234         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
 235
 236         if (!usbhsg_status_has(gpriv, USBHSG_STATUS_WEDGE)) {
 237                 usbhs_pipe_disable(pipe);
 238                 usbhs_pipe_sequence_data0(pipe);
 239                 usbhs_pipe_enable(pipe);
 240         }
 241
 242         usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
 243
 244         usbhs_pkt_start(pipe);
 245
 246         return 0;
 247 }
 248
 249 static struct usbhsg_recip_handle req_clear_feature = {
 250         .name           = "clear feature",
 251         .device         = usbhsg_recip_handler_std_control_done,
 252         .interface      = usbhsg_recip_handler_std_control_done,
 253         .endpoint       = usbhsg_recip_handler_std_clear_endpoint,
 254 };
 255
 256 /*
 257  *              USB_TYPE_STANDARD / set feature functions
 258  */
 259 static int usbhsg_recip_handler_std_set_device(struct usbhs_priv *priv,
 260                                                  struct usbhsg_uep *uep,
 261                                                  struct usb_ctrlrequest *ctrl)
 262 {
 263         switch (le16_to_cpu(ctrl->wValue)) {
 264         case USB_DEVICE_TEST_MODE:
 265                 usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
 266                 udelay(100);
 267                 usbhs_sys_set_test_mode(priv, le16_to_cpu(ctrl->wIndex >> 8));
 268                 break;
 269         default:
 270                 usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
 271                 break;
 272         }
 273
 274         return 0;
 275 }
 276
 277 static int usbhsg_recip_handler_std_set_endpoint(struct usbhs_priv *priv,
 278                                                  struct usbhsg_uep *uep,
 279                                                  struct usb_ctrlrequest *ctrl)
 280 {
 281         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
 282
 283         usbhs_pipe_stall(pipe);
 284
 285         usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
 286
 287         return 0;
 288 }
 289
 290 static struct usbhsg_recip_handle req_set_feature = {
 291         .name           = "set feature",
 292         .device         = usbhsg_recip_handler_std_set_device,
 293         .interface      = usbhsg_recip_handler_std_control_done,
 294         .endpoint       = usbhsg_recip_handler_std_set_endpoint,
 295 };
 296
 297 /*
 298  *              USB_TYPE_STANDARD / get status functions
 299  */
 300 static void __usbhsg_recip_send_complete(struct usb_ep *ep,
 301                                          struct usb_request *req)
 302 {
 303         struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
 304
 305         /* free allocated recip-buffer/usb_request */
 306         kfree(ureq->pkt.buf);
 307         usb_ep_free_request(ep, req);
 308 }
 309
 310 static void __usbhsg_recip_send_status(struct usbhsg_gpriv *gpriv,
 311                                        unsigned short status)
 312 {
 313         struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
 314         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
 315         struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 316         struct usb_request *req;
 317         unsigned short *buf;
 318
 319         /* alloc new usb_request for recip */
 320         req = usb_ep_alloc_request(&dcp->ep, GFP_ATOMIC);
 321         if (!req) {
 322                 dev_err(dev, "recip request allocation fail\n");
 323                 return;
 324         }
 325
 326         /* alloc recip data buffer */
 327         buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
 328         if (!buf) {
 329                 usb_ep_free_request(&dcp->ep, req);
 330                 return;
 331         }
 332
 333         /* recip data is status */
 334         *buf = cpu_to_le16(status);
 335
 336         /* allocated usb_request/buffer will be freed */
 337         req->complete   = __usbhsg_recip_send_complete;
 338         req->buf        = buf;
 339         req->length     = sizeof(*buf);
 340         req->zero       = 0;
 341
 342         /* push packet */
 343         pipe->handler = &usbhs_fifo_pio_push_handler;
 344         usbhsg_queue_push(dcp, usbhsg_req_to_ureq(req));
 345 }
 346
 347 static int usbhsg_recip_handler_std_get_device(struct usbhs_priv *priv,
 348                                                struct usbhsg_uep *uep,
 349                                                struct usb_ctrlrequest *ctrl)
 350 {
 351         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 352         unsigned short status = 0;
 353
 354         if (usbhsg_status_has(gpriv, USBHSG_STATUS_SELF_POWERED))
 355                 status = 1 << USB_DEVICE_SELF_POWERED;
 356
 357         __usbhsg_recip_send_status(gpriv, status);
 358
 359         return 0;
 360 }
 361
 362 static int usbhsg_recip_handler_std_get_interface(struct usbhs_priv *priv,
 363                                                   struct usbhsg_uep *uep,
 364                                                   struct usb_ctrlrequest *ctrl)
 365 {
 366         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 367         unsigned short status = 0;
 368
 369         __usbhsg_recip_send_status(gpriv, status);
 370
 371         return 0;
 372 }
 373
 374 static int usbhsg_recip_handler_std_get_endpoint(struct usbhs_priv *priv,
 375                                                  struct usbhsg_uep *uep,
 376                                                  struct usb_ctrlrequest *ctrl)
 377 {
 378         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 379         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
 380         unsigned short status = 0;
 381
 382         if (usbhs_pipe_is_stall(pipe))
 383                 status = 1 << USB_ENDPOINT_HALT;
 384
 385         __usbhsg_recip_send_status(gpriv, status);
 386
 387         return 0;
 388 }
 389
 390 static struct usbhsg_recip_handle req_get_status = {
 391         .name           = "get status",
 392         .device         = usbhsg_recip_handler_std_get_device,
 393         .interface      = usbhsg_recip_handler_std_get_interface,
 394         .endpoint       = usbhsg_recip_handler_std_get_endpoint,
 395 };
 396
 397 /*
 398  *              USB_TYPE handler
 399  */
 400 static int usbhsg_recip_run_handle(struct usbhs_priv *priv,
 401                                    struct usbhsg_recip_handle *handler,
 402                                    struct usb_ctrlrequest *ctrl)
 403 {
 404         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 405         struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 406         struct usbhsg_uep *uep;
 407         struct usbhs_pipe *pipe;
 408         int recip = ctrl->bRequestType & USB_RECIP_MASK;
 409         int nth = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
 410         int ret = 0;
 411         int (*func)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
 412                     struct usb_ctrlrequest *ctrl);
 413         char *msg;
 414
 415         uep = usbhsg_gpriv_to_nth_uep(gpriv, nth);
 416         pipe = usbhsg_uep_to_pipe(uep);
 417         if (!pipe) {
 418                 dev_err(dev, "wrong recip request\n");
 419                 return -EINVAL;
 420         }
 421
 422         switch (recip) {
 423         case USB_RECIP_DEVICE:
 424                 msg     = "DEVICE";
 425                 func    = handler->device;
 426                 break;
 427         case USB_RECIP_INTERFACE:
 428                 msg     = "INTERFACE";
 429                 func    = handler->interface;
 430                 break;
 431         case USB_RECIP_ENDPOINT:
 432                 msg     = "ENDPOINT";
 433                 func    = handler->endpoint;
 434                 break;
 435         default:
 436                 dev_warn(dev, "unsupported RECIP(%d)\n", recip);
 437                 func = NULL;
 438                 ret = -EINVAL;
 439         }
 440
 441         if (func) {
 442                 dev_dbg(dev, "%s (pipe %d :%s)\n", handler->name, nth, msg);
 443                 ret = func(priv, uep, ctrl);
 444         }
 445
 446         return ret;
 447 }
 448
 449 /*
 450  *              irq functions
 451  *
 452  * it will be called from usbhs_interrupt
 453  */
 454 static int usbhsg_irq_dev_state(struct usbhs_priv *priv,
 455                                 struct usbhs_irq_state *irq_state)
 456 {
 457         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 458         struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 459         int state = usbhs_status_get_device_state(irq_state);
 460
 461         gpriv->gadget.speed = usbhs_bus_get_speed(priv);
 462
 463         dev_dbg(dev, "state = %x : speed : %d\n", state, gpriv->gadget.speed);
 464
 465         if (gpriv->gadget.speed != USB_SPEED_UNKNOWN &&
 466             (state & SUSPENDED_STATE)) {
 467                 if (gpriv->driver && gpriv->driver->suspend)
 468                         gpriv->driver->suspend(&gpriv->gadget);
 469                 usb_gadget_set_state(&gpriv->gadget, USB_STATE_SUSPENDED);
 470         }
 471
 472         return 0;
 473 }
 474
 475 static int usbhsg_irq_ctrl_stage(struct usbhs_priv *priv,
 476                                  struct usbhs_irq_state *irq_state)
 477 {
 478         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 479         struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
 480         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
 481         struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 482         struct usb_ctrlrequest ctrl;
 483         struct usbhsg_recip_handle *recip_handler = NULL;
 484         int stage = usbhs_status_get_ctrl_stage(irq_state);
 485         int ret = 0;
 486
 487         dev_dbg(dev, "stage = %d\n", stage);
 488
 489         /*
 490          * see Manual
 491          *
 492          *  "Operation"
 493          *  - "Interrupt Function"
 494          *    - "Control Transfer Stage Transition Interrupt"
 495          *      - Fig. "Control Transfer Stage Transitions"
 496          */
 497
 498         switch (stage) {
 499         case READ_DATA_STAGE:
 500                 pipe->handler = &usbhs_fifo_pio_push_handler;
 501                 break;
 502         case WRITE_DATA_STAGE:
 503                 pipe->handler = &usbhs_fifo_pio_pop_handler;
 504                 break;
 505         case NODATA_STATUS_STAGE:
 506                 pipe->handler = &usbhs_ctrl_stage_end_handler;
 507                 break;
 508         case READ_STATUS_STAGE:
 509         case WRITE_STATUS_STAGE:
 510                 usbhs_dcp_control_transfer_done(pipe);
 511                 /* fall through */
 512         default:
 513                 return ret;
 514         }
 515
 516         /*
 517          * get usb request
 518          */
 519         usbhs_usbreq_get_val(priv, &ctrl);
 520
 521         switch (ctrl.bRequestType & USB_TYPE_MASK) {
 522         case USB_TYPE_STANDARD:
 523                 switch (ctrl.bRequest) {
 524                 case USB_REQ_CLEAR_FEATURE:
 525                         recip_handler = &req_clear_feature;
 526                         break;
 527                 case USB_REQ_SET_FEATURE:
 528                         recip_handler = &req_set_feature;
 529                         break;
 530                 case USB_REQ_GET_STATUS:
 531                         recip_handler = &req_get_status;
 532                         break;
 533                 }
 534         }
 535
 536         /*
 537          * setup stage / run recip
 538          */
 539         if (recip_handler)
 540                 ret = usbhsg_recip_run_handle(priv, recip_handler, &ctrl);
 541         else
 542                 ret = gpriv->driver->setup(&gpriv->gadget, &ctrl);
 543
 544         if (ret < 0)
 545                 usbhs_pipe_stall(pipe);
 546
 547         return ret;
 548 }
 549
 550 /*
 551  *
 552  *              usb_dcp_ops
 553  *
 554  */
 555 static int usbhsg_pipe_disable(struct usbhsg_uep *uep)
 556 {
 557         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
 558         struct usbhs_pkt *pkt;
 559
 560         while (1) {
 561                 pkt = usbhs_pkt_pop(pipe, NULL);
 562                 if (!pkt)
 563                         break;
 564
 565                 usbhsg_queue_pop(uep, usbhsg_pkt_to_ureq(pkt), -ESHUTDOWN);
 566         }
 567
 568         usbhs_pipe_disable(pipe);
 569
 570         return 0;
 571 }
 572
 573 /*
 574  *
 575  *              usb_ep_ops
 576  *
 577  */
 578 static int usbhsg_ep_enable(struct usb_ep *ep,
 579                          const struct usb_endpoint_descriptor *desc)
 580 {
 581         struct usbhsg_uep *uep   = usbhsg_ep_to_uep(ep);
 582         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 583         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
 584         struct usbhs_pipe *pipe;
 585         int ret = -EIO;
 586         unsigned long flags;
 587
 588         usbhs_lock(priv, flags);
 589
 590         /*
 591          * if it already have pipe,
 592          * nothing to do
 593          */
 594         if (uep->pipe) {
 595                 usbhs_pipe_clear(uep->pipe);
 596                 usbhs_pipe_sequence_data0(uep->pipe);
 597                 ret = 0;
 598                 goto usbhsg_ep_enable_end;
 599         }
 600
 601         pipe = usbhs_pipe_malloc(priv,
 602                                  usb_endpoint_type(desc),
 603                                  usb_endpoint_dir_in(desc));
 604         if (pipe) {
 605                 uep->pipe               = pipe;
 606                 pipe->mod_private       = uep;
 607
 608                 /* set epnum / maxp */
 609                 usbhs_pipe_config_update(pipe, 0,
 610                                          usb_endpoint_num(desc),
 611                                          usb_endpoint_maxp(desc));
 612
 613                 /*
 614                  * usbhs_fifo_dma_push/pop_handler try to
 615                  * use dmaengine if possible.
 616                  * It will use pio handler if impossible.
 617                  */
 618                 if (usb_endpoint_dir_in(desc)) {
 619                         pipe->handler = &usbhs_fifo_dma_push_handler;
 620                 } else {
 621                         pipe->handler = &usbhs_fifo_dma_pop_handler;
 622                         usbhs_xxxsts_clear(priv, BRDYSTS,
 623                                            usbhs_pipe_number(pipe));
 624                 }
 625
 626                 ret = 0;
 627         }
 628
 629 usbhsg_ep_enable_end:
 630         usbhs_unlock(priv, flags);
 631
 632         return ret;
 633 }
 634
 635 static int usbhsg_ep_disable(struct usb_ep *ep)
 636 {
 637         struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
 638         struct usbhs_pipe *pipe;
 639         unsigned long flags;
 640
 641         spin_lock_irqsave(&uep->lock, flags);
 642         pipe = usbhsg_uep_to_pipe(uep);
 643         if (!pipe)
 644                 goto out;
 645
 646         usbhsg_pipe_disable(uep);
 647         usbhs_pipe_free(pipe);
 648
 649         uep->pipe->mod_private  = NULL;
 650         uep->pipe               = NULL;
 651
 652 out:
 653         spin_unlock_irqrestore(&uep->lock, flags);
 654
 655         return 0;
 656 }
 657
 658 static struct usb_request *usbhsg_ep_alloc_request(struct usb_ep *ep,
 659                                                    gfp_t gfp_flags)
 660 {
 661         struct usbhsg_request *ureq;
 662
 663         ureq = kzalloc(sizeof *ureq, gfp_flags);
 664         if (!ureq)
 665                 return NULL;
 666
 667         usbhs_pkt_init(usbhsg_ureq_to_pkt(ureq));
 668
 669         return &ureq->req;
 670 }
 671
 672 static void usbhsg_ep_free_request(struct usb_ep *ep,
 673                                    struct usb_request *req)
 674 {
 675         struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
 676
 677         WARN_ON(!list_empty(&ureq->pkt.node));
 678         kfree(ureq);
 679 }
 680
 681 static int usbhsg_ep_queue(struct usb_ep *ep, struct usb_request *req,
 682                           gfp_t gfp_flags)
 683 {
 684         struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
 685         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 686         struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
 687         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
 688
 689         /* param check */
 690         if (usbhsg_is_not_connected(gpriv)      ||
 691             unlikely(!gpriv->driver)            ||
 692             unlikely(!pipe))
 693                 return -ESHUTDOWN;
 694
 695         usbhsg_queue_push(uep, ureq);
 696
 697         return 0;
 698 }
 699
 700 static int usbhsg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
 701 {
 702         struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
 703         struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
 704         struct usbhs_pipe *pipe;
 705         unsigned long flags;
 706
 707         spin_lock_irqsave(&uep->lock, flags);
 708         pipe = usbhsg_uep_to_pipe(uep);
 709         if (pipe)
 710                 usbhs_pkt_pop(pipe, usbhsg_ureq_to_pkt(ureq));
 711
 712         /*
 713          * To dequeue a request, this driver should call the usbhsg_queue_pop()
 714          * even if the pipe is NULL.
 715          */
 716         usbhsg_queue_pop(uep, ureq, -ECONNRESET);
 717         spin_unlock_irqrestore(&uep->lock, flags);
 718
 719         return 0;
 720 }
 721
 722 static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge)
 723 {
 724         struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
 725         struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
 726         struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
 727         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
 728         struct device *dev = usbhsg_gpriv_to_dev(gpriv);
 729         unsigned long flags;
 730         int ret = 0;
 731
 732         dev_dbg(dev, "set halt %d (pipe %d)\n",
 733                 halt, usbhs_pipe_number(pipe));
 734
 735         /********************  spin lock ********************/
 736         usbhs_lock(priv, flags);
 737
 738         /*
 739          * According to usb_ep_set_halt()'s description, this function should
 740          * return -EAGAIN if the IN endpoint has any queue or data. Note
 741          * that the usbhs_pipe_is_dir_in() returns false if the pipe is an
 742          * IN endpoint in the gadget mode.
 743          */
 744         if (!usbhs_pipe_is_dir_in(pipe) && (__usbhsf_pkt_get(pipe) ||
 745             usbhs_pipe_contains_transmittable_data(pipe))) {
 746                 ret = -EAGAIN;
 747                 goto out;
 748         }
 749
 750         if (halt)
 751                 usbhs_pipe_stall(pipe);
 752         else
 753                 usbhs_pipe_disable(pipe);
 754
 755         if (halt && wedge)
 756                 usbhsg_status_set(gpriv, USBHSG_STATUS_WEDGE);
 757         else
 758                 usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);
 759
 760 out:
 761         usbhs_unlock(priv, flags);
 762         /********************  spin unlock ******************/
 763
 764         return ret;
 765 }
 766
 767 static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)
 768 {
 769         return __usbhsg_ep_set_halt_wedge(ep, value, 0);
 770 }
 771
 772 static int usbhsg_ep_set_wedge(struct usb_ep *ep)
 773 {
 774         return __usbhsg_ep_set_halt_wedge(ep, 1, 1);
 775 }
 776
 777 static const struct usb_ep_ops usbhsg_ep_ops = {
 778         .enable         = usbhsg_ep_enable,
 779         .disable        = usbhsg_ep_disable,
 780
 781         .alloc_request  = usbhsg_ep_alloc_request,
 782         .free_request   = usbhsg_ep_free_request,
 783
 784         .queue          = usbhsg_ep_queue,
 785         .dequeue        = usbhsg_ep_dequeue,
 786
 787         .set_halt       = usbhsg_ep_set_halt,
 788         .set_wedge      = usbhsg_ep_set_wedge,
 789 };
 790
 791 /*
 792  *              pullup control
 793  */
 794 static int usbhsg_can_pullup(struct usbhs_priv *priv)
 795 {
 796         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 797
 798         return gpriv->driver &&
 799                usbhsg_status_has(gpriv, USBHSG_STATUS_SOFT_CONNECT);
 800 }
 801
 802 static void usbhsg_update_pullup(struct usbhs_priv *priv)
 803 {
 804         if (usbhsg_can_pullup(priv))
 805                 usbhs_sys_function_pullup(priv, 1);
 806         else
 807                 usbhs_sys_function_pullup(priv, 0);
 808 }
 809
 810 /*
 811  *              usb module start/end
 812  */
 813 static int usbhsg_try_start(struct usbhs_priv *priv, u32 status)
 814 {
 815         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 816         struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
 817         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
 818         struct device *dev = usbhs_priv_to_dev(priv);
 819         unsigned long flags;
 820         int ret = 0;
 821
 822         /********************  spin lock ********************/
 823         usbhs_lock(priv, flags);
 824
 825         usbhsg_status_set(gpriv, status);
 826         if (!(usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
 827               usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD)))
 828                 ret = -1; /* not ready */
 829
 830         usbhs_unlock(priv, flags);
 831         /********************  spin unlock ********************/
 832
 833         if (ret < 0)
 834                 return 0; /* not ready is not error */
 835
 836         /*
 837          * enable interrupt and systems if ready
 838          */
 839         dev_dbg(dev, "start gadget\n");
 840
 841         /*
 842          * pipe initialize and enable DCP
 843          */
 844         usbhs_fifo_init(priv);
 845         usbhs_pipe_init(priv,
 846                         usbhsg_dma_map_ctrl);
 847
 848         /* dcp init instead of usbhsg_ep_enable() */
 849         dcp->pipe               = usbhs_dcp_malloc(priv);
 850         dcp->pipe->mod_private  = dcp;
 851         usbhs_pipe_config_update(dcp->pipe, 0, 0, 64);
 852
 853         /*
 854          * system config enble
 855          * - HI speed
 856          * - function
 857          * - usb module
 858          */
 859         usbhs_sys_function_ctrl(priv, 1);
 860         usbhsg_update_pullup(priv);
 861
 862         /*
 863          * enable irq callback
 864          */
 865         mod->irq_dev_state      = usbhsg_irq_dev_state;
 866         mod->irq_ctrl_stage     = usbhsg_irq_ctrl_stage;
 867         usbhs_irq_callback_update(priv, mod);
 868
 869         return 0;
 870 }
 871
 872 static int usbhsg_try_stop(struct usbhs_priv *priv, u32 status)
 873 {
 874         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 875         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
 876         struct usbhsg_uep *uep;
 877         struct device *dev = usbhs_priv_to_dev(priv);
 878         unsigned long flags;
 879         int ret = 0, i;
 880
 881         /********************  spin lock ********************/
 882         usbhs_lock(priv, flags);
 883
 884         usbhsg_status_clr(gpriv, status);
 885         if (!usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
 886             !usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD))
 887                 ret = -1; /* already done */
 888
 889         usbhs_unlock(priv, flags);
 890         /********************  spin unlock ********************/
 891
 892         if (ret < 0)
 893                 return 0; /* already done is not error */
 894
 895         /*
 896          * disable interrupt and systems if 1st try
 897          */
 898         usbhs_fifo_quit(priv);
 899
 900         /* disable all irq */
 901         mod->irq_dev_state      = NULL;
 902         mod->irq_ctrl_stage     = NULL;
 903         usbhs_irq_callback_update(priv, mod);
 904
 905         gpriv->gadget.speed = USB_SPEED_UNKNOWN;
 906
 907         /* disable sys */
 908         usbhs_sys_set_test_mode(priv, 0);
 909         usbhs_sys_function_ctrl(priv, 0);
 910
 911         /* disable all eps */
 912         usbhsg_for_each_uep_with_dcp(uep, gpriv, i)
 913                 usbhsg_ep_disable(&uep->ep);
 914
 915         dev_dbg(dev, "stop gadget\n");
 916
 917         return 0;
 918 }
 919
 920 /*
 921  * VBUS provided by the PHY
 922  */
 923 static int usbhsm_phy_get_vbus(struct platform_device *pdev)
 924 {
 925         struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
 926         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 927
 928         return  gpriv->vbus_active;
 929 }
 930
 931 static void usbhs_mod_phy_mode(struct usbhs_priv *priv)
 932 {
 933         struct usbhs_mod_info *info = &priv->mod_info;
 934
 935         info->irq_vbus          = NULL;
 936         priv->pfunc.get_vbus    = usbhsm_phy_get_vbus;
 937
 938         usbhs_irq_callback_update(priv, NULL);
 939 }
 940
 941 /*
 942  *
 943  *              linux usb function
 944  *
 945  */
 946 static int usbhsg_gadget_start(struct usb_gadget *gadget,
 947                 struct usb_gadget_driver *driver)
 948 {
 949         struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
 950         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
 951         struct device *dev = usbhs_priv_to_dev(priv);
 952         int ret;
 953
 954         if (!driver             ||
 955             !driver->setup      ||
 956             driver->max_speed < USB_SPEED_FULL)
 957                 return -EINVAL;
 958
 959         /* connect to bus through transceiver */
 960         if (!IS_ERR_OR_NULL(gpriv->transceiver)) {
 961                 ret = otg_set_peripheral(gpriv->transceiver->otg,
 962                                         &gpriv->gadget);
 963                 if (ret) {
 964                         dev_err(dev, "%s: can't bind to transceiver\n",
 965                                 gpriv->gadget.name);
 966                         return ret;
 967                 }
 968
 969                 /* get vbus using phy versions */
 970                 usbhs_mod_phy_mode(priv);
 971         }
 972
 973         /* first hook up the driver ... */
 974         gpriv->driver = driver;
 975
 976         return usbhsg_try_start(priv, USBHSG_STATUS_REGISTERD);
 977 }
 978
 979 static int usbhsg_gadget_stop(struct usb_gadget *gadget)
 980 {
 981         struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
 982         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
 983
 984         usbhsg_try_stop(priv, USBHSG_STATUS_REGISTERD);
 985
 986         if (!IS_ERR_OR_NULL(gpriv->transceiver))
 987                 otg_set_peripheral(gpriv->transceiver->otg, NULL);
 988
 989         gpriv->driver = NULL;
 990
 991         return 0;
 992 }
 993
 994 /*
 995  *              usb gadget ops
 996  */
 997 static int usbhsg_get_frame(struct usb_gadget *gadget)
 998 {
 999         struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
1000         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
1001
1002         return usbhs_frame_get_num(priv);
1003 }
1004
1005 static int usbhsg_pullup(struct usb_gadget *gadget, int is_on)
1006 {
1007         struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
1008         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
1009         unsigned long flags;
1010
1011         usbhs_lock(priv, flags);
1012         if (is_on)
1013                 usbhsg_status_set(gpriv, USBHSG_STATUS_SOFT_CONNECT);
1014         else
1015                 usbhsg_status_clr(gpriv, USBHSG_STATUS_SOFT_CONNECT);
1016         usbhsg_update_pullup(priv);
1017         usbhs_unlock(priv, flags);
1018
1019         return 0;
1020 }
1021
1022 static int usbhsg_set_selfpowered(struct usb_gadget *gadget, int is_self)
1023 {
1024         struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
1025
1026         if (is_self)
1027                 usbhsg_status_set(gpriv, USBHSG_STATUS_SELF_POWERED);
1028         else
1029                 usbhsg_status_clr(gpriv, USBHSG_STATUS_SELF_POWERED);
1030
1031         gadget->is_selfpowered = (is_self != 0);
1032
1033         return 0;
1034 }
1035
1036 static int usbhsg_vbus_session(struct usb_gadget *gadget, int is_active)
1037 {
1038         struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
1039         struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
1040         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
1041
1042         gpriv->vbus_active = !!is_active;
1043
1044         renesas_usbhs_call_notify_hotplug(pdev);
1045
1046         return 0;
1047 }
1048
1049 static const struct usb_gadget_ops usbhsg_gadget_ops = {
1050         .get_frame              = usbhsg_get_frame,
1051         .set_selfpowered        = usbhsg_set_selfpowered,
1052         .udc_start              = usbhsg_gadget_start,
1053         .udc_stop               = usbhsg_gadget_stop,
1054         .pullup                 = usbhsg_pullup,
1055         .vbus_session           = usbhsg_vbus_session,
1056 };
1057
1058 static int usbhsg_start(struct usbhs_priv *priv)
1059 {
1060         return usbhsg_try_start(priv, USBHSG_STATUS_STARTED);
1061 }
1062
1063 static int usbhsg_stop(struct usbhs_priv *priv)
1064 {
1065         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
1066
1067         /* cable disconnect */
1068         if (gpriv->driver &&
1069             gpriv->driver->disconnect)
1070                 gpriv->driver->disconnect(&gpriv->gadget);
1071
1072         return usbhsg_try_stop(priv, USBHSG_STATUS_STARTED);
1073 }
1074
1075 int usbhs_mod_gadget_probe(struct usbhs_priv *priv)
1076 {
1077         struct usbhsg_gpriv *gpriv;
1078         struct usbhsg_uep *uep;
1079         struct device *dev = usbhs_priv_to_dev(priv);
1080         struct renesas_usbhs_driver_pipe_config *pipe_configs =
1081                                         usbhs_get_dparam(priv, pipe_configs);
1082         int pipe_size = usbhs_get_dparam(priv, pipe_size);
1083         int i;
1084         int ret;
1085
1086         gpriv = kzalloc(sizeof(struct usbhsg_gpriv), GFP_KERNEL);
1087         if (!gpriv)
1088                 return -ENOMEM;
1089
1090         uep = kcalloc(pipe_size, sizeof(struct usbhsg_uep), GFP_KERNEL);
1091         if (!uep) {
1092                 ret = -ENOMEM;
1093                 goto usbhs_mod_gadget_probe_err_gpriv;
1094         }
1095
1096         gpriv->transceiver = usb_get_phy(USB_PHY_TYPE_UNDEFINED);
1097         dev_info(dev, "%stransceiver found\n",
1098                  !IS_ERR(gpriv->transceiver) ? "" : "no ");
1099
1100         /*
1101          * CAUTION
1102          *
1103          * There is no guarantee that it is possible to access usb module here.
1104          * Don't accesses to it.
1105          * The accesse will be enable after "usbhsg_start"
1106          */
1107
1108         /*
1109          * register itself
1110          */
1111         usbhs_mod_register(priv, &gpriv->mod, USBHS_GADGET);
1112
1113         /* init gpriv */
1114         gpriv->mod.name         = "gadget";
1115         gpriv->mod.start        = usbhsg_start;
1116         gpriv->mod.stop         = usbhsg_stop;
1117         gpriv->uep              = uep;
1118         gpriv->uep_size         = pipe_size;
1119         usbhsg_status_init(gpriv);
1120
1121         /*
1122          * init gadget
1123          */
1124         gpriv->gadget.dev.parent        = dev;
1125         gpriv->gadget.name              = "renesas_usbhs_udc";
1126         gpriv->gadget.ops               = &usbhsg_gadget_ops;
1127         gpriv->gadget.max_speed         = USB_SPEED_HIGH;
1128         gpriv->gadget.quirk_avoids_skb_reserve = usbhs_get_dparam(priv,
1129                                                                 has_usb_dmac);
1130
1131         INIT_LIST_HEAD(&gpriv->gadget.ep_list);
1132
1133         /*
1134          * init usb_ep
1135          */
1136         usbhsg_for_each_uep_with_dcp(uep, gpriv, i) {
1137                 uep->gpriv      = gpriv;
1138                 uep->pipe       = NULL;
1139                 snprintf(uep->ep_name, EP_NAME_SIZE, "ep%d", i);
1140
1141                 uep->ep.name            = uep->ep_name;
1142                 uep->ep.ops             = &usbhsg_ep_ops;
1143                 INIT_LIST_HEAD(&uep->ep.ep_list);
1144                 spin_lock_init(&uep->lock);
1145
1146                 /* init DCP */
1147                 if (usbhsg_is_dcp(uep)) {
1148                         gpriv->gadget.ep0 = &uep->ep;
1149                         usb_ep_set_maxpacket_limit(&uep->ep, 64);
1150                         uep->ep.caps.type_control = true;
1151                 } else {
1152                         /* init normal pipe */
1153                         if (pipe_configs[i].type == USB_ENDPOINT_XFER_ISOC)
1154                                 uep->ep.caps.type_iso = true;
1155                         if (pipe_configs[i].type == USB_ENDPOINT_XFER_BULK)
1156                                 uep->ep.caps.type_bulk = true;
1157                         if (pipe_configs[i].type == USB_ENDPOINT_XFER_INT)
1158                                 uep->ep.caps.type_int = true;
1159                         usb_ep_set_maxpacket_limit(&uep->ep,
1160                                                    pipe_configs[i].bufsize);
1161                         list_add_tail(&uep->ep.ep_list, &gpriv->gadget.ep_list);
1162                 }
1163                 uep->ep.caps.dir_in = true;
1164                 uep->ep.caps.dir_out = true;
1165         }
1166
1167         ret = usb_add_gadget_udc(dev, &gpriv->gadget);
1168         if (ret)
1169                 goto err_add_udc;
1170
1171
1172         dev_info(dev, "gadget probed\n");
1173
1174         return 0;
1175
1176 err_add_udc:
1177         kfree(gpriv->uep);
1178
1179 usbhs_mod_gadget_probe_err_gpriv:
1180         kfree(gpriv);
1181
1182         return ret;
1183 }
1184
1185 void usbhs_mod_gadget_remove(struct usbhs_priv *priv)
1186 {
1187         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
1188
1189         usb_del_gadget_udc(&gpriv->gadget);
1190
1191         kfree(gpriv->uep);
1192         kfree(gpriv);
1193 }