drivers/usb/isp1760/isp1760-udc.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
gadget_to_udc
ep_to_udc_ep
req_to_udc_req
isp1760_udc_read
isp1760_udc_write
isp1760_udc_find_ep
__isp1760_udc_select_ep
isp1760_udc_select_ep
isp1760_udc_ctrl_send_status
isp1760_udc_request_complete
isp1760_udc_ctrl_send_stall
isp1760_udc_receive
isp1760_udc_transmit
isp1760_ep_rx_ready
isp1760_ep_tx_complete
__isp1760_udc_set_halt
isp1760_udc_get_status
isp1760_udc_set_address
isp1760_ep0_setup_standard
isp1760_ep0_setup
isp1760_ep_enable
isp1760_ep_disable
isp1760_ep_alloc_request
isp1760_ep_free_request
isp1760_ep_queue
isp1760_ep_dequeue
__isp1760_ep_set_halt
isp1760_ep_set_halt
isp1760_ep_set_wedge
isp1760_ep_fifo_flush
isp1760_udc_connect
isp1760_udc_disconnect
isp1760_udc_init_hw
isp1760_udc_reset
isp1760_udc_suspend
isp1760_udc_resume
isp1760_udc_get_frame
isp1760_udc_wakeup
isp1760_udc_set_selfpowered
isp1760_udc_pullup
isp1760_udc_start
isp1760_udc_stop
isp1760_udc_irq
isp1760_udc_vbus_poll
isp1760_udc_init_eps
isp1760_udc_init
isp1760_udc_register
isp1760_udc_unregister
   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for the NXP ISP1761 device controller
   4  *
   5  * Copyright 2014 Ideas on Board Oy
   6  *
   7  * Contacts:
   8  *      Laurent Pinchart <laurent.pinchart@ideasonboard.com>
   9  */
  10 
  11 #include <linux/interrupt.h>
  12 #include <linux/io.h>
  13 #include <linux/kernel.h>
  14 #include <linux/list.h>
  15 #include <linux/module.h>
  16 #include <linux/slab.h>
  17 #include <linux/timer.h>
  18 #include <linux/usb.h>
  19 
  20 #include "isp1760-core.h"
  21 #include "isp1760-regs.h"
  22 #include "isp1760-udc.h"
  23 
  24 #define ISP1760_VBUS_POLL_INTERVAL      msecs_to_jiffies(500)
  25 
  26 struct isp1760_request {
  27         struct usb_request req;
  28         struct list_head queue;
  29         struct isp1760_ep *ep;
  30         unsigned int packet_size;
  31 };
  32 
  33 static inline struct isp1760_udc *gadget_to_udc(struct usb_gadget *gadget)
  34 {
  35         return container_of(gadget, struct isp1760_udc, gadget);
  36 }
  37 
  38 static inline struct isp1760_ep *ep_to_udc_ep(struct usb_ep *ep)
  39 {
  40         return container_of(ep, struct isp1760_ep, ep);
  41 }
  42 
  43 static inline struct isp1760_request *req_to_udc_req(struct usb_request *req)
  44 {
  45         return container_of(req, struct isp1760_request, req);
  46 }
  47 
  48 static inline u32 isp1760_udc_read(struct isp1760_udc *udc, u16 reg)
  49 {
  50         return isp1760_read32(udc->regs, reg);
  51 }
  52 
  53 static inline void isp1760_udc_write(struct isp1760_udc *udc, u16 reg, u32 val)
  54 {
  55         isp1760_write32(udc->regs, reg, val);
  56 }
  57 
  58 /* -----------------------------------------------------------------------------
  59  * Endpoint Management
  60  */
  61 
  62 static struct isp1760_ep *isp1760_udc_find_ep(struct isp1760_udc *udc,
  63                                               u16 index)
  64 {
  65         unsigned int i;
  66 
  67         if (index == 0)
  68                 return &udc->ep[0];
  69 
  70         for (i = 1; i < ARRAY_SIZE(udc->ep); ++i) {
  71                 if (udc->ep[i].addr == index)
  72                         return udc->ep[i].desc ? &udc->ep[i] : NULL;
  73         }
  74 
  75         return NULL;
  76 }
  77 
  78 static void __isp1760_udc_select_ep(struct isp1760_ep *ep, int dir)
  79 {
  80         isp1760_udc_write(ep->udc, DC_EPINDEX,
  81                           DC_ENDPIDX(ep->addr & USB_ENDPOINT_NUMBER_MASK) |
  82                           (dir == USB_DIR_IN ? DC_EPDIR : 0));
  83 }
  84 
  85 /**
  86  * isp1760_udc_select_ep - Select an endpoint for register access
  87  * @ep: The endpoint
  88  *
  89  * The ISP1761 endpoint registers are banked. This function selects the target
  90  * endpoint for banked register access. The selection remains valid until the
  91  * next call to this function, the next direct access to the EPINDEX register
  92  * or the next reset, whichever comes first.
  93  *
  94  * Called with the UDC spinlock held.
  95  */
  96 static void isp1760_udc_select_ep(struct isp1760_ep *ep)
  97 {
  98         __isp1760_udc_select_ep(ep, ep->addr & USB_ENDPOINT_DIR_MASK);
  99 }
 100 
 101 /* Called with the UDC spinlock held. */
 102 static void isp1760_udc_ctrl_send_status(struct isp1760_ep *ep, int dir)
 103 {
 104         struct isp1760_udc *udc = ep->udc;
 105 
 106         /*
 107          * Proceed to the status stage. The status stage data packet flows in
 108          * the direction opposite to the data stage data packets, we thus need
 109          * to select the OUT/IN endpoint for IN/OUT transfers.
 110          */
 111         isp1760_udc_write(udc, DC_EPINDEX, DC_ENDPIDX(0) |
 112                           (dir == USB_DIR_IN ? 0 : DC_EPDIR));
 113         isp1760_udc_write(udc, DC_CTRLFUNC, DC_STATUS);
 114 
 115         /*
 116          * The hardware will terminate the request automatically and go back to
 117          * the setup stage without notifying us.
 118          */
 119         udc->ep0_state = ISP1760_CTRL_SETUP;
 120 }
 121 
 122 /* Called without the UDC spinlock held. */
 123 static void isp1760_udc_request_complete(struct isp1760_ep *ep,
 124                                          struct isp1760_request *req,
 125                                          int status)
 126 {
 127         struct isp1760_udc *udc = ep->udc;
 128         unsigned long flags;
 129 
 130         dev_dbg(ep->udc->isp->dev, "completing request %p with status %d\n",
 131                 req, status);
 132 
 133         req->ep = NULL;
 134         req->req.status = status;
 135         req->req.complete(&ep->ep, &req->req);
 136 
 137         spin_lock_irqsave(&udc->lock, flags);
 138 
 139         /*
 140          * When completing control OUT requests, move to the status stage after
 141          * calling the request complete callback. This gives the gadget an
 142          * opportunity to stall the control transfer if needed.
 143          */
 144         if (status == 0 && ep->addr == 0 && udc->ep0_dir == USB_DIR_OUT)
 145                 isp1760_udc_ctrl_send_status(ep, USB_DIR_OUT);
 146 
 147         spin_unlock_irqrestore(&udc->lock, flags);
 148 }
 149 
 150 static void isp1760_udc_ctrl_send_stall(struct isp1760_ep *ep)
 151 {
 152         struct isp1760_udc *udc = ep->udc;
 153         unsigned long flags;
 154 
 155         dev_dbg(ep->udc->isp->dev, "%s(ep%02x)\n", __func__, ep->addr);
 156 
 157         spin_lock_irqsave(&udc->lock, flags);
 158 
 159         /* Stall both the IN and OUT endpoints. */
 160         __isp1760_udc_select_ep(ep, USB_DIR_OUT);
 161         isp1760_udc_write(udc, DC_CTRLFUNC, DC_STALL);
 162         __isp1760_udc_select_ep(ep, USB_DIR_IN);
 163         isp1760_udc_write(udc, DC_CTRLFUNC, DC_STALL);
 164 
 165         /* A protocol stall completes the control transaction. */
 166         udc->ep0_state = ISP1760_CTRL_SETUP;
 167 
 168         spin_unlock_irqrestore(&udc->lock, flags);
 169 }
 170 
 171 /* -----------------------------------------------------------------------------
 172  * Data Endpoints
 173  */
 174 
 175 /* Called with the UDC spinlock held. */
 176 static bool isp1760_udc_receive(struct isp1760_ep *ep,
 177                                 struct isp1760_request *req)
 178 {
 179         struct isp1760_udc *udc = ep->udc;
 180         unsigned int len;
 181         u32 *buf;
 182         int i;
 183 
 184         isp1760_udc_select_ep(ep);
 185         len = isp1760_udc_read(udc, DC_BUFLEN) & DC_DATACOUNT_MASK;
 186 
 187         dev_dbg(udc->isp->dev, "%s: received %u bytes (%u/%u done)\n",
 188                 __func__, len, req->req.actual, req->req.length);
 189 
 190         len = min(len, req->req.length - req->req.actual);
 191 
 192         if (!len) {
 193                 /*
 194                  * There's no data to be read from the FIFO, acknowledge the RX
 195                  * interrupt by clearing the buffer.
 196                  *
 197                  * TODO: What if another packet arrives in the meantime ? The
 198                  * datasheet doesn't clearly document how this should be
 199                  * handled.
 200                  */
 201                 isp1760_udc_write(udc, DC_CTRLFUNC, DC_CLBUF);
 202                 return false;
 203         }
 204 
 205         buf = req->req.buf + req->req.actual;
 206 
 207         /*
 208          * Make sure not to read more than one extra byte, otherwise data from
 209          * the next packet might be removed from the FIFO.
 210          */
 211         for (i = len; i > 2; i -= 4, ++buf)
 212                 *buf = le32_to_cpu(isp1760_udc_read(udc, DC_DATAPORT));
 213         if (i > 0)
 214                 *(u16 *)buf = le16_to_cpu(readw(udc->regs + DC_DATAPORT));
 215 
 216         req->req.actual += len;
 217 
 218         /*
 219          * TODO: The short_not_ok flag isn't supported yet, but isn't used by
 220          * any gadget driver either.
 221          */
 222 
 223         dev_dbg(udc->isp->dev,
 224                 "%s: req %p actual/length %u/%u maxpacket %u packet size %u\n",
 225                 __func__, req, req->req.actual, req->req.length, ep->maxpacket,
 226                 len);
 227 
 228         ep->rx_pending = false;
 229 
 230         /*
 231          * Complete the request if all data has been received or if a short
 232          * packet has been received.
 233          */
 234         if (req->req.actual == req->req.length || len < ep->maxpacket) {
 235                 list_del(&req->queue);
 236                 return true;
 237         }
 238 
 239         return false;
 240 }
 241 
 242 static void isp1760_udc_transmit(struct isp1760_ep *ep,
 243                                  struct isp1760_request *req)
 244 {
 245         struct isp1760_udc *udc = ep->udc;
 246         u32 *buf = req->req.buf + req->req.actual;
 247         int i;
 248 
 249         req->packet_size = min(req->req.length - req->req.actual,
 250                                ep->maxpacket);
 251 
 252         dev_dbg(udc->isp->dev, "%s: transferring %u bytes (%u/%u done)\n",
 253                 __func__, req->packet_size, req->req.actual,
 254                 req->req.length);
 255 
 256         __isp1760_udc_select_ep(ep, USB_DIR_IN);
 257 
 258         if (req->packet_size)
 259                 isp1760_udc_write(udc, DC_BUFLEN, req->packet_size);
 260 
 261         /*
 262          * Make sure not to write more than one extra byte, otherwise extra data
 263          * will stay in the FIFO and will be transmitted during the next control
 264          * request. The endpoint control CLBUF bit is supposed to allow flushing
 265          * the FIFO for this kind of conditions, but doesn't seem to work.
 266          */
 267         for (i = req->packet_size; i > 2; i -= 4, ++buf)
 268                 isp1760_udc_write(udc, DC_DATAPORT, cpu_to_le32(*buf));
 269         if (i > 0)
 270                 writew(cpu_to_le16(*(u16 *)buf), udc->regs + DC_DATAPORT);
 271 
 272         if (ep->addr == 0)
 273                 isp1760_udc_write(udc, DC_CTRLFUNC, DC_DSEN);
 274         if (!req->packet_size)
 275                 isp1760_udc_write(udc, DC_CTRLFUNC, DC_VENDP);
 276 }
 277 
 278 static void isp1760_ep_rx_ready(struct isp1760_ep *ep)
 279 {
 280         struct isp1760_udc *udc = ep->udc;
 281         struct isp1760_request *req;
 282         bool complete;
 283 
 284         spin_lock(&udc->lock);
 285 
 286         if (ep->addr == 0 && udc->ep0_state != ISP1760_CTRL_DATA_OUT) {
 287                 spin_unlock(&udc->lock);
 288                 dev_dbg(udc->isp->dev, "%s: invalid ep0 state %u\n", __func__,
 289                         udc->ep0_state);
 290                 return;
 291         }
 292 
 293         if (ep->addr != 0 && !ep->desc) {
 294                 spin_unlock(&udc->lock);
 295                 dev_dbg(udc->isp->dev, "%s: ep%02x is disabled\n", __func__,
 296                         ep->addr);
 297                 return;
 298         }
 299 
 300         if (list_empty(&ep->queue)) {
 301                 ep->rx_pending = true;
 302                 spin_unlock(&udc->lock);
 303                 dev_dbg(udc->isp->dev, "%s: ep%02x (%p) has no request queued\n",
 304                         __func__, ep->addr, ep);
 305                 return;
 306         }
 307 
 308         req = list_first_entry(&ep->queue, struct isp1760_request,
 309                                queue);
 310         complete = isp1760_udc_receive(ep, req);
 311 
 312         spin_unlock(&udc->lock);
 313 
 314         if (complete)
 315                 isp1760_udc_request_complete(ep, req, 0);
 316 }
 317 
 318 static void isp1760_ep_tx_complete(struct isp1760_ep *ep)
 319 {
 320         struct isp1760_udc *udc = ep->udc;
 321         struct isp1760_request *complete = NULL;
 322         struct isp1760_request *req;
 323         bool need_zlp;
 324 
 325         spin_lock(&udc->lock);
 326 
 327         if (ep->addr == 0 && udc->ep0_state != ISP1760_CTRL_DATA_IN) {
 328                 spin_unlock(&udc->lock);
 329                 dev_dbg(udc->isp->dev, "TX IRQ: invalid endpoint state %u\n",
 330                         udc->ep0_state);
 331                 return;
 332         }
 333 
 334         if (list_empty(&ep->queue)) {
 335                 /*
 336                  * This can happen for the control endpoint when the reply to
 337                  * the GET_STATUS IN control request is sent directly by the
 338                  * setup IRQ handler. Just proceed to the status stage.
 339                  */
 340                 if (ep->addr == 0) {
 341                         isp1760_udc_ctrl_send_status(ep, USB_DIR_IN);
 342                         spin_unlock(&udc->lock);
 343                         return;
 344                 }
 345 
 346                 spin_unlock(&udc->lock);
 347                 dev_dbg(udc->isp->dev, "%s: ep%02x has no request queued\n",
 348                         __func__, ep->addr);
 349                 return;
 350         }
 351 
 352         req = list_first_entry(&ep->queue, struct isp1760_request,
 353                                queue);
 354         req->req.actual += req->packet_size;
 355 
 356         need_zlp = req->req.actual == req->req.length &&
 357                    !(req->req.length % ep->maxpacket) &&
 358                    req->packet_size && req->req.zero;
 359 
 360         dev_dbg(udc->isp->dev,
 361                 "TX IRQ: req %p actual/length %u/%u maxpacket %u packet size %u zero %u need zlp %u\n",
 362                  req, req->req.actual, req->req.length, ep->maxpacket,
 363                  req->packet_size, req->req.zero, need_zlp);
 364 
 365         /*
 366          * Complete the request if all data has been sent and we don't need to
 367          * transmit a zero length packet.
 368          */
 369         if (req->req.actual == req->req.length && !need_zlp) {
 370                 complete = req;
 371                 list_del(&req->queue);
 372 
 373                 if (ep->addr == 0)
 374                         isp1760_udc_ctrl_send_status(ep, USB_DIR_IN);
 375 
 376                 if (!list_empty(&ep->queue))
 377                         req = list_first_entry(&ep->queue,
 378                                                struct isp1760_request, queue);
 379                 else
 380                         req = NULL;
 381         }
 382 
 383         /*
 384          * Transmit the next packet or start the next request, if any.
 385          *
 386          * TODO: If the endpoint is stalled the next request shouldn't be
 387          * started, but what about the next packet ?
 388          */
 389         if (req)
 390                 isp1760_udc_transmit(ep, req);
 391 
 392         spin_unlock(&udc->lock);
 393 
 394         if (complete)
 395                 isp1760_udc_request_complete(ep, complete, 0);
 396 }
 397 
 398 static int __isp1760_udc_set_halt(struct isp1760_ep *ep, bool halt)
 399 {
 400         struct isp1760_udc *udc = ep->udc;
 401 
 402         dev_dbg(udc->isp->dev, "%s: %s halt on ep%02x\n", __func__,
 403                 halt ? "set" : "clear", ep->addr);
 404 
 405         if (ep->desc && usb_endpoint_xfer_isoc(ep->desc)) {
 406                 dev_dbg(udc->isp->dev, "%s: ep%02x is isochronous\n", __func__,
 407                         ep->addr);
 408                 return -EINVAL;
 409         }
 410 
 411         isp1760_udc_select_ep(ep);
 412         isp1760_udc_write(udc, DC_CTRLFUNC, halt ? DC_STALL : 0);
 413 
 414         if (ep->addr == 0) {
 415                 /* When halting the control endpoint, stall both IN and OUT. */
 416                 __isp1760_udc_select_ep(ep, USB_DIR_IN);
 417                 isp1760_udc_write(udc, DC_CTRLFUNC, halt ? DC_STALL : 0);
 418         } else if (!halt) {
 419                 /* Reset the data PID by cycling the endpoint enable bit. */
 420                 u16 eptype = isp1760_udc_read(udc, DC_EPTYPE);
 421 
 422                 isp1760_udc_write(udc, DC_EPTYPE, eptype & ~DC_EPENABLE);
 423                 isp1760_udc_write(udc, DC_EPTYPE, eptype);
 424 
 425                 /*
 426                  * Disabling the endpoint emptied the transmit FIFO, fill it
 427                  * again if a request is pending.
 428                  *
 429                  * TODO: Does the gadget framework require synchronizatino with
 430                  * the TX IRQ handler ?
 431                  */
 432                 if ((ep->addr & USB_DIR_IN) && !list_empty(&ep->queue)) {
 433                         struct isp1760_request *req;
 434 
 435                         req = list_first_entry(&ep->queue,
 436                                                struct isp1760_request, queue);
 437                         isp1760_udc_transmit(ep, req);
 438                 }
 439         }
 440 
 441         ep->halted = halt;
 442 
 443         return 0;
 444 }
 445 
 446 /* -----------------------------------------------------------------------------
 447  * Control Endpoint
 448  */
 449 
 450 static int isp1760_udc_get_status(struct isp1760_udc *udc,
 451                                   const struct usb_ctrlrequest *req)
 452 {
 453         struct isp1760_ep *ep;
 454         u16 status;
 455 
 456         if (req->wLength != cpu_to_le16(2) || req->wValue != cpu_to_le16(0))
 457                 return -EINVAL;
 458 
 459         switch (req->bRequestType) {
 460         case USB_DIR_IN | USB_RECIP_DEVICE:
 461                 status = udc->devstatus;
 462                 break;
 463 
 464         case USB_DIR_IN | USB_RECIP_INTERFACE:
 465                 status = 0;
 466                 break;
 467 
 468         case USB_DIR_IN | USB_RECIP_ENDPOINT:
 469                 ep = isp1760_udc_find_ep(udc, le16_to_cpu(req->wIndex));
 470                 if (!ep)
 471                         return -EINVAL;
 472 
 473                 status = 0;
 474                 if (ep->halted)
 475                         status |= 1 << USB_ENDPOINT_HALT;
 476                 break;
 477 
 478         default:
 479                 return -EINVAL;
 480         }
 481 
 482         isp1760_udc_write(udc, DC_EPINDEX, DC_ENDPIDX(0) | DC_EPDIR);
 483         isp1760_udc_write(udc, DC_BUFLEN, 2);
 484 
 485         writew(cpu_to_le16(status), udc->regs + DC_DATAPORT);
 486 
 487         isp1760_udc_write(udc, DC_CTRLFUNC, DC_DSEN);
 488 
 489         dev_dbg(udc->isp->dev, "%s: status 0x%04x\n", __func__, status);
 490 
 491         return 0;
 492 }
 493 
 494 static int isp1760_udc_set_address(struct isp1760_udc *udc, u16 addr)
 495 {
 496         if (addr > 127) {
 497                 dev_dbg(udc->isp->dev, "invalid device address %u\n", addr);
 498                 return -EINVAL;
 499         }
 500 
 501         if (udc->gadget.state != USB_STATE_DEFAULT &&
 502             udc->gadget.state != USB_STATE_ADDRESS) {
 503                 dev_dbg(udc->isp->dev, "can't set address in state %u\n",
 504                         udc->gadget.state);
 505                 return -EINVAL;
 506         }
 507 
 508         usb_gadget_set_state(&udc->gadget, addr ? USB_STATE_ADDRESS :
 509                              USB_STATE_DEFAULT);
 510 
 511         isp1760_udc_write(udc, DC_ADDRESS, DC_DEVEN | addr);
 512 
 513         spin_lock(&udc->lock);
 514         isp1760_udc_ctrl_send_status(&udc->ep[0], USB_DIR_OUT);
 515         spin_unlock(&udc->lock);
 516 
 517         return 0;
 518 }
 519 
 520 static bool isp1760_ep0_setup_standard(struct isp1760_udc *udc,
 521                                        struct usb_ctrlrequest *req)
 522 {
 523         bool stall;
 524 
 525         switch (req->bRequest) {
 526         case USB_REQ_GET_STATUS:
 527                 return isp1760_udc_get_status(udc, req);
 528 
 529         case USB_REQ_CLEAR_FEATURE:
 530                 switch (req->bRequestType) {
 531                 case USB_DIR_OUT | USB_RECIP_DEVICE: {
 532                         /* TODO: Handle remote wakeup feature. */
 533                         return true;
 534                 }
 535 
 536                 case USB_DIR_OUT | USB_RECIP_ENDPOINT: {
 537                         u16 index = le16_to_cpu(req->wIndex);
 538                         struct isp1760_ep *ep;
 539 
 540                         if (req->wLength != cpu_to_le16(0) ||
 541                             req->wValue != cpu_to_le16(USB_ENDPOINT_HALT))
 542                                 return true;
 543 
 544                         ep = isp1760_udc_find_ep(udc, index);
 545                         if (!ep)
 546                                 return true;
 547 
 548                         spin_lock(&udc->lock);
 549 
 550                         /*
 551                          * If the endpoint is wedged only the gadget can clear
 552                          * the halt feature. Pretend success in that case, but
 553                          * keep the endpoint halted.
 554                          */
 555                         if (!ep->wedged)
 556                                 stall = __isp1760_udc_set_halt(ep, false);
 557                         else
 558                                 stall = false;
 559 
 560                         if (!stall)
 561                                 isp1760_udc_ctrl_send_status(&udc->ep[0],
 562                                                              USB_DIR_OUT);
 563 
 564                         spin_unlock(&udc->lock);
 565                         return stall;
 566                 }
 567 
 568                 default:
 569                         return true;
 570                 }
 571                 break;
 572 
 573         case USB_REQ_SET_FEATURE:
 574                 switch (req->bRequestType) {
 575                 case USB_DIR_OUT | USB_RECIP_DEVICE: {
 576                         /* TODO: Handle remote wakeup and test mode features */
 577                         return true;
 578                 }
 579 
 580                 case USB_DIR_OUT | USB_RECIP_ENDPOINT: {
 581                         u16 index = le16_to_cpu(req->wIndex);
 582                         struct isp1760_ep *ep;
 583 
 584                         if (req->wLength != cpu_to_le16(0) ||
 585                             req->wValue != cpu_to_le16(USB_ENDPOINT_HALT))
 586                                 return true;
 587 
 588                         ep = isp1760_udc_find_ep(udc, index);
 589                         if (!ep)
 590                                 return true;
 591 
 592                         spin_lock(&udc->lock);
 593 
 594                         stall = __isp1760_udc_set_halt(ep, true);
 595                         if (!stall)
 596                                 isp1760_udc_ctrl_send_status(&udc->ep[0],
 597                                                              USB_DIR_OUT);
 598 
 599                         spin_unlock(&udc->lock);
 600                         return stall;
 601                 }
 602 
 603                 default:
 604                         return true;
 605                 }
 606                 break;
 607 
 608         case USB_REQ_SET_ADDRESS:
 609                 if (req->bRequestType != (USB_DIR_OUT | USB_RECIP_DEVICE))
 610                         return true;
 611 
 612                 return isp1760_udc_set_address(udc, le16_to_cpu(req->wValue));
 613 
 614         case USB_REQ_SET_CONFIGURATION:
 615                 if (req->bRequestType != (USB_DIR_OUT | USB_RECIP_DEVICE))
 616                         return true;
 617 
 618                 if (udc->gadget.state != USB_STATE_ADDRESS &&
 619                     udc->gadget.state != USB_STATE_CONFIGURED)
 620                         return true;
 621 
 622                 stall = udc->driver->setup(&udc->gadget, req) < 0;
 623                 if (stall)
 624                         return true;
 625 
 626                 usb_gadget_set_state(&udc->gadget, req->wValue ?
 627                                      USB_STATE_CONFIGURED : USB_STATE_ADDRESS);
 628 
 629                 /*
 630                  * SET_CONFIGURATION (and SET_INTERFACE) must reset the halt
 631                  * feature on all endpoints. There is however no need to do so
 632                  * explicitly here as the gadget driver will disable and
 633                  * reenable endpoints, clearing the halt feature.
 634                  */
 635                 return false;
 636 
 637         default:
 638                 return udc->driver->setup(&udc->gadget, req) < 0;
 639         }
 640 }
 641 
 642 static void isp1760_ep0_setup(struct isp1760_udc *udc)
 643 {
 644         union {
 645                 struct usb_ctrlrequest r;
 646                 u32 data[2];
 647         } req;
 648         unsigned int count;
 649         bool stall = false;
 650 
 651         spin_lock(&udc->lock);
 652 
 653         isp1760_udc_write(udc, DC_EPINDEX, DC_EP0SETUP);
 654 
 655         count = isp1760_udc_read(udc, DC_BUFLEN) & DC_DATACOUNT_MASK;
 656         if (count != sizeof(req)) {
 657                 spin_unlock(&udc->lock);
 658 
 659                 dev_err(udc->isp->dev, "invalid length %u for setup packet\n",
 660                         count);
 661 
 662                 isp1760_udc_ctrl_send_stall(&udc->ep[0]);
 663                 return;
 664         }
 665 
 666         req.data[0] = isp1760_udc_read(udc, DC_DATAPORT);
 667         req.data[1] = isp1760_udc_read(udc, DC_DATAPORT);
 668 
 669         if (udc->ep0_state != ISP1760_CTRL_SETUP) {
 670                 spin_unlock(&udc->lock);
 671                 dev_dbg(udc->isp->dev, "unexpected SETUP packet\n");
 672                 return;
 673         }
 674 
 675         /* Move to the data stage. */
 676         if (!req.r.wLength)
 677                 udc->ep0_state = ISP1760_CTRL_STATUS;
 678         else if (req.r.bRequestType & USB_DIR_IN)
 679                 udc->ep0_state = ISP1760_CTRL_DATA_IN;
 680         else
 681                 udc->ep0_state = ISP1760_CTRL_DATA_OUT;
 682 
 683         udc->ep0_dir = req.r.bRequestType & USB_DIR_IN;
 684         udc->ep0_length = le16_to_cpu(req.r.wLength);
 685 
 686         spin_unlock(&udc->lock);
 687 
 688         dev_dbg(udc->isp->dev,
 689                 "%s: bRequestType 0x%02x bRequest 0x%02x wValue 0x%04x wIndex 0x%04x wLength 0x%04x\n",
 690                 __func__, req.r.bRequestType, req.r.bRequest,
 691                 le16_to_cpu(req.r.wValue), le16_to_cpu(req.r.wIndex),
 692                 le16_to_cpu(req.r.wLength));
 693 
 694         if ((req.r.bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
 695                 stall = isp1760_ep0_setup_standard(udc, &req.r);
 696         else
 697                 stall = udc->driver->setup(&udc->gadget, &req.r) < 0;
 698 
 699         if (stall)
 700                 isp1760_udc_ctrl_send_stall(&udc->ep[0]);
 701 }
 702 
 703 /* -----------------------------------------------------------------------------
 704  * Gadget Endpoint Operations
 705  */
 706 
 707 static int isp1760_ep_enable(struct usb_ep *ep,
 708                              const struct usb_endpoint_descriptor *desc)
 709 {
 710         struct isp1760_ep *uep = ep_to_udc_ep(ep);
 711         struct isp1760_udc *udc = uep->udc;
 712         unsigned long flags;
 713         unsigned int type;
 714 
 715         dev_dbg(uep->udc->isp->dev, "%s\n", __func__);
 716 
 717         /*
 718          * Validate the descriptor. The control endpoint can't be enabled
 719          * manually.
 720          */
 721         if (desc->bDescriptorType != USB_DT_ENDPOINT ||
 722             desc->bEndpointAddress == 0 ||
 723             desc->bEndpointAddress != uep->addr ||
 724             le16_to_cpu(desc->wMaxPacketSize) > ep->maxpacket) {
 725                 dev_dbg(udc->isp->dev,
 726                         "%s: invalid descriptor type %u addr %02x ep addr %02x max packet size %u/%u\n",
 727                         __func__, desc->bDescriptorType,
 728                         desc->bEndpointAddress, uep->addr,
 729                         le16_to_cpu(desc->wMaxPacketSize), ep->maxpacket);
 730                 return -EINVAL;
 731         }
 732 
 733         switch (usb_endpoint_type(desc)) {
 734         case USB_ENDPOINT_XFER_ISOC:
 735                 type = DC_ENDPTYP_ISOC;
 736                 break;
 737         case USB_ENDPOINT_XFER_BULK:
 738                 type = DC_ENDPTYP_BULK;
 739                 break;
 740         case USB_ENDPOINT_XFER_INT:
 741                 type = DC_ENDPTYP_INTERRUPT;
 742                 break;
 743         case USB_ENDPOINT_XFER_CONTROL:
 744         default:
 745                 dev_dbg(udc->isp->dev, "%s: control endpoints unsupported\n",
 746                         __func__);
 747                 return -EINVAL;
 748         }
 749 
 750         spin_lock_irqsave(&udc->lock, flags);
 751 
 752         uep->desc = desc;
 753         uep->maxpacket = le16_to_cpu(desc->wMaxPacketSize);
 754         uep->rx_pending = false;
 755         uep->halted = false;
 756         uep->wedged = false;
 757 
 758         isp1760_udc_select_ep(uep);
 759         isp1760_udc_write(udc, DC_EPMAXPKTSZ, uep->maxpacket);
 760         isp1760_udc_write(udc, DC_BUFLEN, uep->maxpacket);
 761         isp1760_udc_write(udc, DC_EPTYPE, DC_EPENABLE | type);
 762 
 763         spin_unlock_irqrestore(&udc->lock, flags);
 764 
 765         return 0;
 766 }
 767 
 768 static int isp1760_ep_disable(struct usb_ep *ep)
 769 {
 770         struct isp1760_ep *uep = ep_to_udc_ep(ep);
 771         struct isp1760_udc *udc = uep->udc;
 772         struct isp1760_request *req, *nreq;
 773         LIST_HEAD(req_list);
 774         unsigned long flags;
 775 
 776         dev_dbg(udc->isp->dev, "%s\n", __func__);
 777 
 778         spin_lock_irqsave(&udc->lock, flags);
 779 
 780         if (!uep->desc) {
 781                 dev_dbg(udc->isp->dev, "%s: endpoint not enabled\n", __func__);
 782                 spin_unlock_irqrestore(&udc->lock, flags);
 783                 return -EINVAL;
 784         }
 785 
 786         uep->desc = NULL;
 787         uep->maxpacket = 0;
 788 
 789         isp1760_udc_select_ep(uep);
 790         isp1760_udc_write(udc, DC_EPTYPE, 0);
 791 
 792         /* TODO Synchronize with the IRQ handler */
 793 
 794         list_splice_init(&uep->queue, &req_list);
 795 
 796         spin_unlock_irqrestore(&udc->lock, flags);
 797 
 798         list_for_each_entry_safe(req, nreq, &req_list, queue) {
 799                 list_del(&req->queue);
 800                 isp1760_udc_request_complete(uep, req, -ESHUTDOWN);
 801         }
 802 
 803         return 0;
 804 }
 805 
 806 static struct usb_request *isp1760_ep_alloc_request(struct usb_ep *ep,
 807                                                     gfp_t gfp_flags)
 808 {
 809         struct isp1760_request *req;
 810 
 811         req = kzalloc(sizeof(*req), gfp_flags);
 812         if (!req)
 813                 return NULL;
 814 
 815         return &req->req;
 816 }
 817 
 818 static void isp1760_ep_free_request(struct usb_ep *ep, struct usb_request *_req)
 819 {
 820         struct isp1760_request *req = req_to_udc_req(_req);
 821 
 822         kfree(req);
 823 }
 824 
 825 static int isp1760_ep_queue(struct usb_ep *ep, struct usb_request *_req,
 826                             gfp_t gfp_flags)
 827 {
 828         struct isp1760_request *req = req_to_udc_req(_req);
 829         struct isp1760_ep *uep = ep_to_udc_ep(ep);
 830         struct isp1760_udc *udc = uep->udc;
 831         bool complete = false;
 832         unsigned long flags;
 833         int ret = 0;
 834 
 835         _req->status = -EINPROGRESS;
 836         _req->actual = 0;
 837 
 838         spin_lock_irqsave(&udc->lock, flags);
 839 
 840         dev_dbg(udc->isp->dev,
 841                 "%s: req %p (%u bytes%s) ep %p(0x%02x)\n", __func__, _req,
 842                 _req->length, _req->zero ? " (zlp)" : "", uep, uep->addr);
 843 
 844         req->ep = uep;
 845 
 846         if (uep->addr == 0) {
 847                 if (_req->length != udc->ep0_length &&
 848                     udc->ep0_state != ISP1760_CTRL_DATA_IN) {
 849                         dev_dbg(udc->isp->dev,
 850                                 "%s: invalid length %u for req %p\n",
 851                                 __func__, _req->length, req);
 852                         ret = -EINVAL;
 853                         goto done;
 854                 }
 855 
 856                 switch (udc->ep0_state) {
 857                 case ISP1760_CTRL_DATA_IN:
 858                         dev_dbg(udc->isp->dev, "%s: transmitting req %p\n",
 859                                 __func__, req);
 860 
 861                         list_add_tail(&req->queue, &uep->queue);
 862                         isp1760_udc_transmit(uep, req);
 863                         break;
 864 
 865                 case ISP1760_CTRL_DATA_OUT:
 866                         list_add_tail(&req->queue, &uep->queue);
 867                         __isp1760_udc_select_ep(uep, USB_DIR_OUT);
 868                         isp1760_udc_write(udc, DC_CTRLFUNC, DC_DSEN);
 869                         break;
 870 
 871                 case ISP1760_CTRL_STATUS:
 872                         complete = true;
 873                         break;
 874 
 875                 default:
 876                         dev_dbg(udc->isp->dev, "%s: invalid ep0 state\n",
 877                                 __func__);
 878                         ret = -EINVAL;
 879                         break;
 880                 }
 881         } else if (uep->desc) {
 882                 bool empty = list_empty(&uep->queue);
 883 
 884                 list_add_tail(&req->queue, &uep->queue);
 885                 if ((uep->addr & USB_DIR_IN) && !uep->halted && empty)
 886                         isp1760_udc_transmit(uep, req);
 887                 else if (!(uep->addr & USB_DIR_IN) && uep->rx_pending)
 888                         complete = isp1760_udc_receive(uep, req);
 889         } else {
 890                 dev_dbg(udc->isp->dev,
 891                         "%s: can't queue request to disabled ep%02x\n",
 892                         __func__, uep->addr);
 893                 ret = -ESHUTDOWN;
 894         }
 895 
 896 done:
 897         if (ret < 0)
 898                 req->ep = NULL;
 899 
 900         spin_unlock_irqrestore(&udc->lock, flags);
 901 
 902         if (complete)
 903                 isp1760_udc_request_complete(uep, req, 0);
 904 
 905         return ret;
 906 }
 907 
 908 static int isp1760_ep_dequeue(struct usb_ep *ep, struct usb_request *_req)
 909 {
 910         struct isp1760_request *req = req_to_udc_req(_req);
 911         struct isp1760_ep *uep = ep_to_udc_ep(ep);
 912         struct isp1760_udc *udc = uep->udc;
 913         unsigned long flags;
 914 
 915         dev_dbg(uep->udc->isp->dev, "%s(ep%02x)\n", __func__, uep->addr);
 916 
 917         spin_lock_irqsave(&udc->lock, flags);
 918 
 919         if (req->ep != uep)
 920                 req = NULL;
 921         else
 922                 list_del(&req->queue);
 923 
 924         spin_unlock_irqrestore(&udc->lock, flags);
 925 
 926         if (!req)
 927                 return -EINVAL;
 928 
 929         isp1760_udc_request_complete(uep, req, -ECONNRESET);
 930         return 0;
 931 }
 932 
 933 static int __isp1760_ep_set_halt(struct isp1760_ep *uep, bool stall, bool wedge)
 934 {
 935         struct isp1760_udc *udc = uep->udc;
 936         int ret;
 937 
 938         if (!uep->addr) {
 939                 /*
 940                  * Halting the control endpoint is only valid as a delayed error
 941                  * response to a SETUP packet. Make sure EP0 is in the right
 942                  * stage and that the gadget isn't trying to clear the halt
 943                  * condition.
 944                  */
 945                 if (WARN_ON(udc->ep0_state == ISP1760_CTRL_SETUP || !stall ||
 946                              wedge)) {
 947                         return -EINVAL;
 948                 }
 949         }
 950 
 951         if (uep->addr && !uep->desc) {
 952                 dev_dbg(udc->isp->dev, "%s: ep%02x is disabled\n", __func__,
 953                         uep->addr);
 954                 return -EINVAL;
 955         }
 956 
 957         if (uep->addr & USB_DIR_IN) {
 958                 /* Refuse to halt IN endpoints with active transfers. */
 959                 if (!list_empty(&uep->queue)) {
 960                         dev_dbg(udc->isp->dev,
 961                                 "%s: ep%02x has request pending\n", __func__,
 962                                 uep->addr);
 963                         return -EAGAIN;
 964                 }
 965         }
 966 
 967         ret = __isp1760_udc_set_halt(uep, stall);
 968         if (ret < 0)
 969                 return ret;
 970 
 971         if (!uep->addr) {
 972                 /*
 973                  * Stalling EP0 completes the control transaction, move back to
 974                  * the SETUP state.
 975                  */
 976                 udc->ep0_state = ISP1760_CTRL_SETUP;
 977                 return 0;
 978         }
 979 
 980         if (wedge)
 981                 uep->wedged = true;
 982         else if (!stall)
 983                 uep->wedged = false;
 984 
 985         return 0;
 986 }
 987 
 988 static int isp1760_ep_set_halt(struct usb_ep *ep, int value)
 989 {
 990         struct isp1760_ep *uep = ep_to_udc_ep(ep);
 991         unsigned long flags;
 992         int ret;
 993 
 994         dev_dbg(uep->udc->isp->dev, "%s: %s halt on ep%02x\n", __func__,
 995                 value ? "set" : "clear", uep->addr);
 996 
 997         spin_lock_irqsave(&uep->udc->lock, flags);
 998         ret = __isp1760_ep_set_halt(uep, value, false);
 999         spin_unlock_irqrestore(&uep->udc->lock, flags);
1000 
1001         return ret;
1002 }
1003 
1004 static int isp1760_ep_set_wedge(struct usb_ep *ep)
1005 {
1006         struct isp1760_ep *uep = ep_to_udc_ep(ep);
1007         unsigned long flags;
1008         int ret;
1009 
1010         dev_dbg(uep->udc->isp->dev, "%s: set wedge on ep%02x)\n", __func__,
1011                 uep->addr);
1012 
1013         spin_lock_irqsave(&uep->udc->lock, flags);
1014         ret = __isp1760_ep_set_halt(uep, true, true);
1015         spin_unlock_irqrestore(&uep->udc->lock, flags);
1016 
1017         return ret;
1018 }
1019 
1020 static void isp1760_ep_fifo_flush(struct usb_ep *ep)
1021 {
1022         struct isp1760_ep *uep = ep_to_udc_ep(ep);
1023         struct isp1760_udc *udc = uep->udc;
1024         unsigned long flags;
1025 
1026         spin_lock_irqsave(&udc->lock, flags);
1027 
1028         isp1760_udc_select_ep(uep);
1029 
1030         /*
1031          * Set the CLBUF bit twice to flush both buffers in case double
1032          * buffering is enabled.
1033          */
1034         isp1760_udc_write(udc, DC_CTRLFUNC, DC_CLBUF);
1035         isp1760_udc_write(udc, DC_CTRLFUNC, DC_CLBUF);
1036 
1037         spin_unlock_irqrestore(&udc->lock, flags);
1038 }
1039 
1040 static const struct usb_ep_ops isp1760_ep_ops = {
1041         .enable = isp1760_ep_enable,
1042         .disable = isp1760_ep_disable,
1043         .alloc_request = isp1760_ep_alloc_request,
1044         .free_request = isp1760_ep_free_request,
1045         .queue = isp1760_ep_queue,
1046         .dequeue = isp1760_ep_dequeue,
1047         .set_halt = isp1760_ep_set_halt,
1048         .set_wedge = isp1760_ep_set_wedge,
1049         .fifo_flush = isp1760_ep_fifo_flush,
1050 };
1051 
1052 /* -----------------------------------------------------------------------------
1053  * Device States
1054  */
1055 
1056 /* Called with the UDC spinlock held. */
1057 static void isp1760_udc_connect(struct isp1760_udc *udc)
1058 {
1059         usb_gadget_set_state(&udc->gadget, USB_STATE_POWERED);
1060         mod_timer(&udc->vbus_timer, jiffies + ISP1760_VBUS_POLL_INTERVAL);
1061 }
1062 
1063 /* Called with the UDC spinlock held. */
1064 static void isp1760_udc_disconnect(struct isp1760_udc *udc)
1065 {
1066         if (udc->gadget.state < USB_STATE_POWERED)
1067                 return;
1068 
1069         dev_dbg(udc->isp->dev, "Device disconnected in state %u\n",
1070                  udc->gadget.state);
1071 
1072         udc->gadget.speed = USB_SPEED_UNKNOWN;
1073         usb_gadget_set_state(&udc->gadget, USB_STATE_ATTACHED);
1074 
1075         if (udc->driver->disconnect)
1076                 udc->driver->disconnect(&udc->gadget);
1077 
1078         del_timer(&udc->vbus_timer);
1079 
1080         /* TODO Reset all endpoints ? */
1081 }
1082 
1083 static void isp1760_udc_init_hw(struct isp1760_udc *udc)
1084 {
1085         /*
1086          * The device controller currently shares its interrupt with the host
1087          * controller, the DC_IRQ polarity and signaling mode are ignored. Set
1088          * the to active-low level-triggered.
1089          *
1090          * Configure the control, in and out pipes to generate interrupts on
1091          * ACK tokens only (and NYET for the out pipe). The default
1092          * configuration also generates an interrupt on the first NACK token.
1093          */
1094         isp1760_udc_write(udc, DC_INTCONF, DC_CDBGMOD_ACK | DC_DDBGMODIN_ACK |
1095                           DC_DDBGMODOUT_ACK_NYET);
1096 
1097         isp1760_udc_write(udc, DC_INTENABLE, DC_IEPRXTX(7) | DC_IEPRXTX(6) |
1098                           DC_IEPRXTX(5) | DC_IEPRXTX(4) | DC_IEPRXTX(3) |
1099                           DC_IEPRXTX(2) | DC_IEPRXTX(1) | DC_IEPRXTX(0) |
1100                           DC_IEP0SETUP | DC_IEVBUS | DC_IERESM | DC_IESUSP |
1101                           DC_IEHS_STA | DC_IEBRST);
1102 
1103         if (udc->connected)
1104                 isp1760_set_pullup(udc->isp, true);
1105 
1106         isp1760_udc_write(udc, DC_ADDRESS, DC_DEVEN);
1107 }
1108 
1109 static void isp1760_udc_reset(struct isp1760_udc *udc)
1110 {
1111         unsigned long flags;
1112 
1113         spin_lock_irqsave(&udc->lock, flags);
1114 
1115         /*
1116          * The bus reset has reset most registers to their default value,
1117          * reinitialize the UDC hardware.
1118          */
1119         isp1760_udc_init_hw(udc);
1120 
1121         udc->ep0_state = ISP1760_CTRL_SETUP;
1122         udc->gadget.speed = USB_SPEED_FULL;
1123 
1124         usb_gadget_udc_reset(&udc->gadget, udc->driver);
1125 
1126         spin_unlock_irqrestore(&udc->lock, flags);
1127 }
1128 
1129 static void isp1760_udc_suspend(struct isp1760_udc *udc)
1130 {
1131         if (udc->gadget.state < USB_STATE_DEFAULT)
1132                 return;
1133 
1134         if (udc->driver->suspend)
1135                 udc->driver->suspend(&udc->gadget);
1136 }
1137 
1138 static void isp1760_udc_resume(struct isp1760_udc *udc)
1139 {
1140         if (udc->gadget.state < USB_STATE_DEFAULT)
1141                 return;
1142 
1143         if (udc->driver->resume)
1144                 udc->driver->resume(&udc->gadget);
1145 }
1146 
1147 /* -----------------------------------------------------------------------------
1148  * Gadget Operations
1149  */
1150 
1151 static int isp1760_udc_get_frame(struct usb_gadget *gadget)
1152 {
1153         struct isp1760_udc *udc = gadget_to_udc(gadget);
1154 
1155         return isp1760_udc_read(udc, DC_FRAMENUM) & ((1 << 11) - 1);
1156 }
1157 
1158 static int isp1760_udc_wakeup(struct usb_gadget *gadget)
1159 {
1160         struct isp1760_udc *udc = gadget_to_udc(gadget);
1161 
1162         dev_dbg(udc->isp->dev, "%s\n", __func__);
1163         return -ENOTSUPP;
1164 }
1165 
1166 static int isp1760_udc_set_selfpowered(struct usb_gadget *gadget,
1167                                        int is_selfpowered)
1168 {
1169         struct isp1760_udc *udc = gadget_to_udc(gadget);
1170 
1171         if (is_selfpowered)
1172                 udc->devstatus |= 1 << USB_DEVICE_SELF_POWERED;
1173         else
1174                 udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
1175 
1176         return 0;
1177 }
1178 
1179 static int isp1760_udc_pullup(struct usb_gadget *gadget, int is_on)
1180 {
1181         struct isp1760_udc *udc = gadget_to_udc(gadget);
1182 
1183         isp1760_set_pullup(udc->isp, is_on);
1184         udc->connected = is_on;
1185 
1186         return 0;
1187 }
1188 
1189 static int isp1760_udc_start(struct usb_gadget *gadget,
1190                              struct usb_gadget_driver *driver)
1191 {
1192         struct isp1760_udc *udc = gadget_to_udc(gadget);
1193         unsigned long flags;
1194 
1195         /* The hardware doesn't support low speed. */
1196         if (driver->max_speed < USB_SPEED_FULL) {
1197                 dev_err(udc->isp->dev, "Invalid gadget driver\n");
1198                 return -EINVAL;
1199         }
1200 
1201         spin_lock_irqsave(&udc->lock, flags);
1202 
1203         if (udc->driver) {
1204                 dev_err(udc->isp->dev, "UDC already has a gadget driver\n");
1205                 spin_unlock_irqrestore(&udc->lock, flags);
1206                 return -EBUSY;
1207         }
1208 
1209         udc->driver = driver;
1210 
1211         spin_unlock_irqrestore(&udc->lock, flags);
1212 
1213         dev_dbg(udc->isp->dev, "starting UDC with driver %s\n",
1214                 driver->function);
1215 
1216         udc->devstatus = 0;
1217         udc->connected = true;
1218 
1219         usb_gadget_set_state(&udc->gadget, USB_STATE_ATTACHED);
1220 
1221         /* DMA isn't supported yet, don't enable the DMA clock. */
1222         isp1760_udc_write(udc, DC_MODE, DC_GLINTENA);
1223 
1224         isp1760_udc_init_hw(udc);
1225 
1226         dev_dbg(udc->isp->dev, "UDC started with driver %s\n",
1227                 driver->function);
1228 
1229         return 0;
1230 }
1231 
1232 static int isp1760_udc_stop(struct usb_gadget *gadget)
1233 {
1234         struct isp1760_udc *udc = gadget_to_udc(gadget);
1235         unsigned long flags;
1236 
1237         dev_dbg(udc->isp->dev, "%s\n", __func__);
1238 
1239         del_timer_sync(&udc->vbus_timer);
1240 
1241         isp1760_udc_write(udc, DC_MODE, 0);
1242 
1243         spin_lock_irqsave(&udc->lock, flags);
1244         udc->driver = NULL;
1245         spin_unlock_irqrestore(&udc->lock, flags);
1246 
1247         return 0;
1248 }
1249 
1250 static const struct usb_gadget_ops isp1760_udc_ops = {
1251         .get_frame = isp1760_udc_get_frame,
1252         .wakeup = isp1760_udc_wakeup,
1253         .set_selfpowered = isp1760_udc_set_selfpowered,
1254         .pullup = isp1760_udc_pullup,
1255         .udc_start = isp1760_udc_start,
1256         .udc_stop = isp1760_udc_stop,
1257 };
1258 
1259 /* -----------------------------------------------------------------------------
1260  * Interrupt Handling
1261  */
1262 
1263 static irqreturn_t isp1760_udc_irq(int irq, void *dev)
1264 {
1265         struct isp1760_udc *udc = dev;
1266         unsigned int i;
1267         u32 status;
1268 
1269         status = isp1760_udc_read(udc, DC_INTERRUPT)
1270                & isp1760_udc_read(udc, DC_INTENABLE);
1271         isp1760_udc_write(udc, DC_INTERRUPT, status);
1272 
1273         if (status & DC_IEVBUS) {
1274                 dev_dbg(udc->isp->dev, "%s(VBUS)\n", __func__);
1275                 /* The VBUS interrupt is only triggered when VBUS appears. */
1276                 spin_lock(&udc->lock);
1277                 isp1760_udc_connect(udc);
1278                 spin_unlock(&udc->lock);
1279         }
1280 
1281         if (status & DC_IEBRST) {
1282                 dev_dbg(udc->isp->dev, "%s(BRST)\n", __func__);
1283 
1284                 isp1760_udc_reset(udc);
1285         }
1286 
1287         for (i = 0; i <= 7; ++i) {
1288                 struct isp1760_ep *ep = &udc->ep[i*2];
1289 
1290                 if (status & DC_IEPTX(i)) {
1291                         dev_dbg(udc->isp->dev, "%s(EPTX%u)\n", __func__, i);
1292                         isp1760_ep_tx_complete(ep);
1293                 }
1294 
1295                 if (status & DC_IEPRX(i)) {
1296                         dev_dbg(udc->isp->dev, "%s(EPRX%u)\n", __func__, i);
1297                         isp1760_ep_rx_ready(i ? ep - 1 : ep);
1298                 }
1299         }
1300 
1301         if (status & DC_IEP0SETUP) {
1302                 dev_dbg(udc->isp->dev, "%s(EP0SETUP)\n", __func__);
1303 
1304                 isp1760_ep0_setup(udc);
1305         }
1306 
1307         if (status & DC_IERESM) {
1308                 dev_dbg(udc->isp->dev, "%s(RESM)\n", __func__);
1309                 isp1760_udc_resume(udc);
1310         }
1311 
1312         if (status & DC_IESUSP) {
1313                 dev_dbg(udc->isp->dev, "%s(SUSP)\n", __func__);
1314 
1315                 spin_lock(&udc->lock);
1316                 if (!(isp1760_udc_read(udc, DC_MODE) & DC_VBUSSTAT))
1317                         isp1760_udc_disconnect(udc);
1318                 else
1319                         isp1760_udc_suspend(udc);
1320                 spin_unlock(&udc->lock);
1321         }
1322 
1323         if (status & DC_IEHS_STA) {
1324                 dev_dbg(udc->isp->dev, "%s(HS_STA)\n", __func__);
1325                 udc->gadget.speed = USB_SPEED_HIGH;
1326         }
1327 
1328         return status ? IRQ_HANDLED : IRQ_NONE;
1329 }
1330 
1331 static void isp1760_udc_vbus_poll(struct timer_list *t)
1332 {
1333         struct isp1760_udc *udc = from_timer(udc, t, vbus_timer);
1334         unsigned long flags;
1335 
1336         spin_lock_irqsave(&udc->lock, flags);
1337 
1338         if (!(isp1760_udc_read(udc, DC_MODE) & DC_VBUSSTAT))
1339                 isp1760_udc_disconnect(udc);
1340         else if (udc->gadget.state >= USB_STATE_POWERED)
1341                 mod_timer(&udc->vbus_timer,
1342                           jiffies + ISP1760_VBUS_POLL_INTERVAL);
1343 
1344         spin_unlock_irqrestore(&udc->lock, flags);
1345 }
1346 
1347 /* -----------------------------------------------------------------------------
1348  * Registration
1349  */
1350 
1351 static void isp1760_udc_init_eps(struct isp1760_udc *udc)
1352 {
1353         unsigned int i;
1354 
1355         INIT_LIST_HEAD(&udc->gadget.ep_list);
1356 
1357         for (i = 0; i < ARRAY_SIZE(udc->ep); ++i) {
1358                 struct isp1760_ep *ep = &udc->ep[i];
1359                 unsigned int ep_num = (i + 1) / 2;
1360                 bool is_in = !(i & 1);
1361 
1362                 ep->udc = udc;
1363 
1364                 INIT_LIST_HEAD(&ep->queue);
1365 
1366                 ep->addr = (ep_num && is_in ? USB_DIR_IN : USB_DIR_OUT)
1367                          | ep_num;
1368                 ep->desc = NULL;
1369 
1370                 sprintf(ep->name, "ep%u%s", ep_num,
1371                         ep_num ? (is_in ? "in" : "out") : "");
1372 
1373                 ep->ep.ops = &isp1760_ep_ops;
1374                 ep->ep.name = ep->name;
1375 
1376                 /*
1377                  * Hardcode the maximum packet sizes for now, to 64 bytes for
1378                  * the control endpoint and 512 bytes for all other endpoints.
1379                  * This fits in the 8kB FIFO without double-buffering.
1380                  */
1381                 if (ep_num == 0) {
1382                         usb_ep_set_maxpacket_limit(&ep->ep, 64);
1383                         ep->ep.caps.type_control = true;
1384                         ep->ep.caps.dir_in = true;
1385                         ep->ep.caps.dir_out = true;
1386                         ep->maxpacket = 64;
1387                         udc->gadget.ep0 = &ep->ep;
1388                 } else {
1389                         usb_ep_set_maxpacket_limit(&ep->ep, 512);
1390                         ep->ep.caps.type_iso = true;
1391                         ep->ep.caps.type_bulk = true;
1392                         ep->ep.caps.type_int = true;
1393                         ep->maxpacket = 0;
1394                         list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
1395                 }
1396 
1397                 if (is_in)
1398                         ep->ep.caps.dir_in = true;
1399                 else
1400                         ep->ep.caps.dir_out = true;
1401         }
1402 }
1403 
1404 static int isp1760_udc_init(struct isp1760_udc *udc)
1405 {
1406         u16 scratch;
1407         u32 chipid;
1408 
1409         /*
1410          * Check that the controller is present by writing to the scratch
1411          * register, modifying the bus pattern by reading from the chip ID
1412          * register, and reading the scratch register value back. The chip ID
1413          * and scratch register contents must match the expected values.
1414          */
1415         isp1760_udc_write(udc, DC_SCRATCH, 0xbabe);
1416         chipid = isp1760_udc_read(udc, DC_CHIPID);
1417         scratch = isp1760_udc_read(udc, DC_SCRATCH);
1418 
1419         if (scratch != 0xbabe) {
1420                 dev_err(udc->isp->dev,
1421                         "udc: scratch test failed (0x%04x/0x%08x)\n",
1422                         scratch, chipid);
1423                 return -ENODEV;
1424         }
1425 
1426         if (chipid != 0x00011582 && chipid != 0x00158210) {
1427                 dev_err(udc->isp->dev, "udc: invalid chip ID 0x%08x\n", chipid);
1428                 return -ENODEV;
1429         }
1430 
1431         /* Reset the device controller. */
1432         isp1760_udc_write(udc, DC_MODE, DC_SFRESET);
1433         usleep_range(10000, 11000);
1434         isp1760_udc_write(udc, DC_MODE, 0);
1435         usleep_range(10000, 11000);
1436 
1437         return 0;
1438 }
1439 
1440 int isp1760_udc_register(struct isp1760_device *isp, int irq,
1441                          unsigned long irqflags)
1442 {
1443         struct isp1760_udc *udc = &isp->udc;
1444         int ret;
1445 
1446         udc->irq = -1;
1447         udc->isp = isp;
1448         udc->regs = isp->regs;
1449 
1450         spin_lock_init(&udc->lock);
1451         timer_setup(&udc->vbus_timer, isp1760_udc_vbus_poll, 0);
1452 
1453         ret = isp1760_udc_init(udc);
1454         if (ret < 0)
1455                 return ret;
1456 
1457         udc->irqname = kasprintf(GFP_KERNEL, "%s (udc)", dev_name(isp->dev));
1458         if (!udc->irqname)
1459                 return -ENOMEM;
1460 
1461         ret = request_irq(irq, isp1760_udc_irq, IRQF_SHARED | irqflags,
1462                           udc->irqname, udc);
1463         if (ret < 0)
1464                 goto error;
1465 
1466         udc->irq = irq;
1467 
1468         /*
1469          * Initialize the gadget static fields and register its device. Gadget
1470          * fields that vary during the life time of the gadget are initialized
1471          * by the UDC core.
1472          */
1473         udc->gadget.ops = &isp1760_udc_ops;
1474         udc->gadget.speed = USB_SPEED_UNKNOWN;
1475         udc->gadget.max_speed = USB_SPEED_HIGH;
1476         udc->gadget.name = "isp1761_udc";
1477 
1478         isp1760_udc_init_eps(udc);
1479 
1480         ret = usb_add_gadget_udc(isp->dev, &udc->gadget);
1481         if (ret < 0)
1482                 goto error;
1483 
1484         return 0;
1485 
1486 error:
1487         if (udc->irq >= 0)
1488                 free_irq(udc->irq, udc);
1489         kfree(udc->irqname);
1490 
1491         return ret;
1492 }
1493 
1494 void isp1760_udc_unregister(struct isp1760_device *isp)
1495 {
1496         struct isp1760_udc *udc = &isp->udc;
1497 
1498         if (!udc->isp)
1499                 return;
1500 
1501         usb_del_gadget_udc(&udc->gadget);
1502 
1503         free_irq(udc->irq, udc);
1504         kfree(udc->irqname);
1505 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/usb/isp1760/isp1760-udc.c

DEFINITIONS
