drivers/usb/gadget/udc/fusb300_udc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Fusb300 UDC (USB gadget)
   4  *
   5  * Copyright (C) 2010 Faraday Technology Corp.
   6  *
   7  * Author : Yuan-hsin Chen <yhchen@faraday-tech.com>
   8  */
   9 #include <linux/dma-mapping.h>
  10 #include <linux/err.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/io.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/usb/ch9.h>
  16 #include <linux/usb/gadget.h>
  17
  18 #include "fusb300_udc.h"
  19
  20 MODULE_DESCRIPTION("FUSB300  USB gadget driver");
  21 MODULE_LICENSE("GPL");
  22 MODULE_AUTHOR("Yuan-Hsin Chen, Feng-Hsin Chiang <john453@faraday-tech.com>");
  23 MODULE_ALIAS("platform:fusb300_udc");
  24
  25 #define DRIVER_VERSION  "20 October 2010"
  26
  27 static const char udc_name[] = "fusb300_udc";
  28 static const char * const fusb300_ep_name[] = {
  29         "ep0", "ep1", "ep2", "ep3", "ep4", "ep5", "ep6", "ep7", "ep8", "ep9",
  30         "ep10", "ep11", "ep12", "ep13", "ep14", "ep15"
  31 };
  32
  33 static void done(struct fusb300_ep *ep, struct fusb300_request *req,
  34                  int status);
  35
  36 static void fusb300_enable_bit(struct fusb300 *fusb300, u32 offset,
  37                                u32 value)
  38 {
  39         u32 reg = ioread32(fusb300->reg + offset);
  40
  41         reg |= value;
  42         iowrite32(reg, fusb300->reg + offset);
  43 }
  44
  45 static void fusb300_disable_bit(struct fusb300 *fusb300, u32 offset,
  46                                 u32 value)
  47 {
  48         u32 reg = ioread32(fusb300->reg + offset);
  49
  50         reg &= ~value;
  51         iowrite32(reg, fusb300->reg + offset);
  52 }
  53
  54
  55 static void fusb300_ep_setting(struct fusb300_ep *ep,
  56                                struct fusb300_ep_info info)
  57 {
  58         ep->epnum = info.epnum;
  59         ep->type = info.type;
  60 }
  61
  62 static int fusb300_ep_release(struct fusb300_ep *ep)
  63 {
  64         if (!ep->epnum)
  65                 return 0;
  66         ep->epnum = 0;
  67         ep->stall = 0;
  68         ep->wedged = 0;
  69         return 0;
  70 }
  71
  72 static void fusb300_set_fifo_entry(struct fusb300 *fusb300,
  73                                    u32 ep)
  74 {
  75         u32 val = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
  76
  77         val &= ~FUSB300_EPSET1_FIFOENTRY_MSK;
  78         val |= FUSB300_EPSET1_FIFOENTRY(FUSB300_FIFO_ENTRY_NUM);
  79         iowrite32(val, fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
  80 }
  81
  82 static void fusb300_set_start_entry(struct fusb300 *fusb300,
  83                                     u8 ep)
  84 {
  85         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
  86         u32 start_entry = fusb300->fifo_entry_num * FUSB300_FIFO_ENTRY_NUM;
  87
  88         reg &= ~FUSB300_EPSET1_START_ENTRY_MSK  ;
  89         reg |= FUSB300_EPSET1_START_ENTRY(start_entry);
  90         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
  91         if (fusb300->fifo_entry_num == FUSB300_MAX_FIFO_ENTRY) {
  92                 fusb300->fifo_entry_num = 0;
  93                 fusb300->addrofs = 0;
  94                 pr_err("fifo entry is over the maximum number!\n");
  95         } else
  96                 fusb300->fifo_entry_num++;
  97 }
  98
  99 /* set fusb300_set_start_entry first before fusb300_set_epaddrofs */
 100 static void fusb300_set_epaddrofs(struct fusb300 *fusb300,
 101                                   struct fusb300_ep_info info)
 102 {
 103         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET2(info.epnum));
 104
 105         reg &= ~FUSB300_EPSET2_ADDROFS_MSK;
 106         reg |= FUSB300_EPSET2_ADDROFS(fusb300->addrofs);
 107         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET2(info.epnum));
 108         fusb300->addrofs += (info.maxpacket + 7) / 8 * FUSB300_FIFO_ENTRY_NUM;
 109 }
 110
 111 static void ep_fifo_setting(struct fusb300 *fusb300,
 112                             struct fusb300_ep_info info)
 113 {
 114         fusb300_set_fifo_entry(fusb300, info.epnum);
 115         fusb300_set_start_entry(fusb300, info.epnum);
 116         fusb300_set_epaddrofs(fusb300, info);
 117 }
 118
 119 static void fusb300_set_eptype(struct fusb300 *fusb300,
 120                                struct fusb300_ep_info info)
 121 {
 122         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
 123
 124         reg &= ~FUSB300_EPSET1_TYPE_MSK;
 125         reg |= FUSB300_EPSET1_TYPE(info.type);
 126         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
 127 }
 128
 129 static void fusb300_set_epdir(struct fusb300 *fusb300,
 130                               struct fusb300_ep_info info)
 131 {
 132         u32 reg;
 133
 134         if (!info.dir_in)
 135                 return;
 136         reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
 137         reg &= ~FUSB300_EPSET1_DIR_MSK;
 138         reg |= FUSB300_EPSET1_DIRIN;
 139         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
 140 }
 141
 142 static void fusb300_set_ep_active(struct fusb300 *fusb300,
 143                           u8 ep)
 144 {
 145         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
 146
 147         reg |= FUSB300_EPSET1_ACTEN;
 148         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(ep));
 149 }
 150
 151 static void fusb300_set_epmps(struct fusb300 *fusb300,
 152                               struct fusb300_ep_info info)
 153 {
 154         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET2(info.epnum));
 155
 156         reg &= ~FUSB300_EPSET2_MPS_MSK;
 157         reg |= FUSB300_EPSET2_MPS(info.maxpacket);
 158         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET2(info.epnum));
 159 }
 160
 161 static void fusb300_set_interval(struct fusb300 *fusb300,
 162                                  struct fusb300_ep_info info)
 163 {
 164         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
 165
 166         reg &= ~FUSB300_EPSET1_INTERVAL(0x7);
 167         reg |= FUSB300_EPSET1_INTERVAL(info.interval);
 168         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
 169 }
 170
 171 static void fusb300_set_bwnum(struct fusb300 *fusb300,
 172                               struct fusb300_ep_info info)
 173 {
 174         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
 175
 176         reg &= ~FUSB300_EPSET1_BWNUM(0x3);
 177         reg |= FUSB300_EPSET1_BWNUM(info.bw_num);
 178         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET1(info.epnum));
 179 }
 180
 181 static void set_ep_reg(struct fusb300 *fusb300,
 182                       struct fusb300_ep_info info)
 183 {
 184         fusb300_set_eptype(fusb300, info);
 185         fusb300_set_epdir(fusb300, info);
 186         fusb300_set_epmps(fusb300, info);
 187
 188         if (info.interval)
 189                 fusb300_set_interval(fusb300, info);
 190
 191         if (info.bw_num)
 192                 fusb300_set_bwnum(fusb300, info);
 193
 194         fusb300_set_ep_active(fusb300, info.epnum);
 195 }
 196
 197 static int config_ep(struct fusb300_ep *ep,
 198                      const struct usb_endpoint_descriptor *desc)
 199 {
 200         struct fusb300 *fusb300 = ep->fusb300;
 201         struct fusb300_ep_info info;
 202
 203         ep->ep.desc = desc;
 204
 205         info.interval = 0;
 206         info.addrofs = 0;
 207         info.bw_num = 0;
 208
 209         info.type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
 210         info.dir_in = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? 1 : 0;
 211         info.maxpacket = usb_endpoint_maxp(desc);
 212         info.epnum = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 213
 214         if ((info.type == USB_ENDPOINT_XFER_INT) ||
 215            (info.type == USB_ENDPOINT_XFER_ISOC)) {
 216                 info.interval = desc->bInterval;
 217                 if (info.type == USB_ENDPOINT_XFER_ISOC)
 218                         info.bw_num = usb_endpoint_maxp_mult(desc);
 219         }
 220
 221         ep_fifo_setting(fusb300, info);
 222
 223         set_ep_reg(fusb300, info);
 224
 225         fusb300_ep_setting(ep, info);
 226
 227         fusb300->ep[info.epnum] = ep;
 228
 229         return 0;
 230 }
 231
 232 static int fusb300_enable(struct usb_ep *_ep,
 233                           const struct usb_endpoint_descriptor *desc)
 234 {
 235         struct fusb300_ep *ep;
 236
 237         ep = container_of(_ep, struct fusb300_ep, ep);
 238
 239         if (ep->fusb300->reenum) {
 240                 ep->fusb300->fifo_entry_num = 0;
 241                 ep->fusb300->addrofs = 0;
 242                 ep->fusb300->reenum = 0;
 243         }
 244
 245         return config_ep(ep, desc);
 246 }
 247
 248 static int fusb300_disable(struct usb_ep *_ep)
 249 {
 250         struct fusb300_ep *ep;
 251         struct fusb300_request *req;
 252         unsigned long flags;
 253
 254         ep = container_of(_ep, struct fusb300_ep, ep);
 255
 256         BUG_ON(!ep);
 257
 258         while (!list_empty(&ep->queue)) {
 259                 req = list_entry(ep->queue.next, struct fusb300_request, queue);
 260                 spin_lock_irqsave(&ep->fusb300->lock, flags);
 261                 done(ep, req, -ECONNRESET);
 262                 spin_unlock_irqrestore(&ep->fusb300->lock, flags);
 263         }
 264
 265         return fusb300_ep_release(ep);
 266 }
 267
 268 static struct usb_request *fusb300_alloc_request(struct usb_ep *_ep,
 269                                                 gfp_t gfp_flags)
 270 {
 271         struct fusb300_request *req;
 272
 273         req = kzalloc(sizeof(struct fusb300_request), gfp_flags);
 274         if (!req)
 275                 return NULL;
 276         INIT_LIST_HEAD(&req->queue);
 277
 278         return &req->req;
 279 }
 280
 281 static void fusb300_free_request(struct usb_ep *_ep, struct usb_request *_req)
 282 {
 283         struct fusb300_request *req;
 284
 285         req = container_of(_req, struct fusb300_request, req);
 286         kfree(req);
 287 }
 288
 289 static int enable_fifo_int(struct fusb300_ep *ep)
 290 {
 291         struct fusb300 *fusb300 = ep->fusb300;
 292
 293         if (ep->epnum) {
 294                 fusb300_enable_bit(fusb300, FUSB300_OFFSET_IGER0,
 295                         FUSB300_IGER0_EEPn_FIFO_INT(ep->epnum));
 296         } else {
 297                 pr_err("can't enable_fifo_int ep0\n");
 298                 return -EINVAL;
 299         }
 300
 301         return 0;
 302 }
 303
 304 static int disable_fifo_int(struct fusb300_ep *ep)
 305 {
 306         struct fusb300 *fusb300 = ep->fusb300;
 307
 308         if (ep->epnum) {
 309                 fusb300_disable_bit(fusb300, FUSB300_OFFSET_IGER0,
 310                         FUSB300_IGER0_EEPn_FIFO_INT(ep->epnum));
 311         } else {
 312                 pr_err("can't disable_fifo_int ep0\n");
 313                 return -EINVAL;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static void fusb300_set_cxlen(struct fusb300 *fusb300, u32 length)
 320 {
 321         u32 reg;
 322
 323         reg = ioread32(fusb300->reg + FUSB300_OFFSET_CSR);
 324         reg &= ~FUSB300_CSR_LEN_MSK;
 325         reg |= FUSB300_CSR_LEN(length);
 326         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_CSR);
 327 }
 328
 329 /* write data to cx fifo */
 330 static void fusb300_wrcxf(struct fusb300_ep *ep,
 331                    struct fusb300_request *req)
 332 {
 333         int i = 0;
 334         u8 *tmp;
 335         u32 data;
 336         struct fusb300 *fusb300 = ep->fusb300;
 337         u32 length = req->req.length - req->req.actual;
 338
 339         tmp = req->req.buf + req->req.actual;
 340
 341         if (length > SS_CTL_MAX_PACKET_SIZE) {
 342                 fusb300_set_cxlen(fusb300, SS_CTL_MAX_PACKET_SIZE);
 343                 for (i = (SS_CTL_MAX_PACKET_SIZE >> 2); i > 0; i--) {
 344                         data = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16 |
 345                                 *(tmp + 3) << 24;
 346                         iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
 347                         tmp += 4;
 348                 }
 349                 req->req.actual += SS_CTL_MAX_PACKET_SIZE;
 350         } else { /* length is less than max packet size */
 351                 fusb300_set_cxlen(fusb300, length);
 352                 for (i = length >> 2; i > 0; i--) {
 353                         data = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16 |
 354                                 *(tmp + 3) << 24;
 355                         printk(KERN_DEBUG "    0x%x\n", data);
 356                         iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
 357                         tmp = tmp + 4;
 358                 }
 359                 switch (length % 4) {
 360                 case 1:
 361                         data = *tmp;
 362                         printk(KERN_DEBUG "    0x%x\n", data);
 363                         iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
 364                         break;
 365                 case 2:
 366                         data = *tmp | *(tmp + 1) << 8;
 367                         printk(KERN_DEBUG "    0x%x\n", data);
 368                         iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
 369                         break;
 370                 case 3:
 371                         data = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16;
 372                         printk(KERN_DEBUG "    0x%x\n", data);
 373                         iowrite32(data, fusb300->reg + FUSB300_OFFSET_CXPORT);
 374                         break;
 375                 default:
 376                         break;
 377                 }
 378                 req->req.actual += length;
 379         }
 380 }
 381
 382 static void fusb300_set_epnstall(struct fusb300 *fusb300, u8 ep)
 383 {
 384         fusb300_enable_bit(fusb300, FUSB300_OFFSET_EPSET0(ep),
 385                 FUSB300_EPSET0_STL);
 386 }
 387
 388 static void fusb300_clear_epnstall(struct fusb300 *fusb300, u8 ep)
 389 {
 390         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET0(ep));
 391
 392         if (reg & FUSB300_EPSET0_STL) {
 393                 printk(KERN_DEBUG "EP%d stall... Clear!!\n", ep);
 394                 reg |= FUSB300_EPSET0_STL_CLR;
 395                 iowrite32(reg, fusb300->reg + FUSB300_OFFSET_EPSET0(ep));
 396         }
 397 }
 398
 399 static void ep0_queue(struct fusb300_ep *ep, struct fusb300_request *req)
 400 {
 401         if (ep->fusb300->ep0_dir) { /* if IN */
 402                 if (req->req.length) {
 403                         fusb300_wrcxf(ep, req);
 404                 } else
 405                         printk(KERN_DEBUG "%s : req->req.length = 0x%x\n",
 406                                 __func__, req->req.length);
 407                 if ((req->req.length == req->req.actual) ||
 408                     (req->req.actual < ep->ep.maxpacket))
 409                         done(ep, req, 0);
 410         } else { /* OUT */
 411                 if (!req->req.length)
 412                         done(ep, req, 0);
 413                 else
 414                         fusb300_enable_bit(ep->fusb300, FUSB300_OFFSET_IGER1,
 415                                 FUSB300_IGER1_CX_OUT_INT);
 416         }
 417 }
 418
 419 static int fusb300_queue(struct usb_ep *_ep, struct usb_request *_req,
 420                          gfp_t gfp_flags)
 421 {
 422         struct fusb300_ep *ep;
 423         struct fusb300_request *req;
 424         unsigned long flags;
 425         int request  = 0;
 426
 427         ep = container_of(_ep, struct fusb300_ep, ep);
 428         req = container_of(_req, struct fusb300_request, req);
 429
 430         if (ep->fusb300->gadget.speed == USB_SPEED_UNKNOWN)
 431                 return -ESHUTDOWN;
 432
 433         spin_lock_irqsave(&ep->fusb300->lock, flags);
 434
 435         if (list_empty(&ep->queue))
 436                 request = 1;
 437
 438         list_add_tail(&req->queue, &ep->queue);
 439
 440         req->req.actual = 0;
 441         req->req.status = -EINPROGRESS;
 442
 443         if (ep->ep.desc == NULL) /* ep0 */
 444                 ep0_queue(ep, req);
 445         else if (request && !ep->stall)
 446                 enable_fifo_int(ep);
 447
 448         spin_unlock_irqrestore(&ep->fusb300->lock, flags);
 449
 450         return 0;
 451 }
 452
 453 static int fusb300_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 454 {
 455         struct fusb300_ep *ep;
 456         struct fusb300_request *req;
 457         unsigned long flags;
 458
 459         ep = container_of(_ep, struct fusb300_ep, ep);
 460         req = container_of(_req, struct fusb300_request, req);
 461
 462         spin_lock_irqsave(&ep->fusb300->lock, flags);
 463         if (!list_empty(&ep->queue))
 464                 done(ep, req, -ECONNRESET);
 465         spin_unlock_irqrestore(&ep->fusb300->lock, flags);
 466
 467         return 0;
 468 }
 469
 470 static int fusb300_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedge)
 471 {
 472         struct fusb300_ep *ep;
 473         struct fusb300 *fusb300;
 474         unsigned long flags;
 475         int ret = 0;
 476
 477         ep = container_of(_ep, struct fusb300_ep, ep);
 478
 479         fusb300 = ep->fusb300;
 480
 481         spin_lock_irqsave(&ep->fusb300->lock, flags);
 482
 483         if (!list_empty(&ep->queue)) {
 484                 ret = -EAGAIN;
 485                 goto out;
 486         }
 487
 488         if (value) {
 489                 fusb300_set_epnstall(fusb300, ep->epnum);
 490                 ep->stall = 1;
 491                 if (wedge)
 492                         ep->wedged = 1;
 493         } else {
 494                 fusb300_clear_epnstall(fusb300, ep->epnum);
 495                 ep->stall = 0;
 496                 ep->wedged = 0;
 497         }
 498
 499 out:
 500         spin_unlock_irqrestore(&ep->fusb300->lock, flags);
 501         return ret;
 502 }
 503
 504 static int fusb300_set_halt(struct usb_ep *_ep, int value)
 505 {
 506         return fusb300_set_halt_and_wedge(_ep, value, 0);
 507 }
 508
 509 static int fusb300_set_wedge(struct usb_ep *_ep)
 510 {
 511         return fusb300_set_halt_and_wedge(_ep, 1, 1);
 512 }
 513
 514 static void fusb300_fifo_flush(struct usb_ep *_ep)
 515 {
 516 }
 517
 518 static const struct usb_ep_ops fusb300_ep_ops = {
 519         .enable         = fusb300_enable,
 520         .disable        = fusb300_disable,
 521
 522         .alloc_request  = fusb300_alloc_request,
 523         .free_request   = fusb300_free_request,
 524
 525         .queue          = fusb300_queue,
 526         .dequeue        = fusb300_dequeue,
 527
 528         .set_halt       = fusb300_set_halt,
 529         .fifo_flush     = fusb300_fifo_flush,
 530         .set_wedge      = fusb300_set_wedge,
 531 };
 532
 533 /*****************************************************************************/
 534 static void fusb300_clear_int(struct fusb300 *fusb300, u32 offset,
 535                        u32 value)
 536 {
 537         iowrite32(value, fusb300->reg + offset);
 538 }
 539
 540 static void fusb300_reset(void)
 541 {
 542 }
 543
 544 static void fusb300_set_cxstall(struct fusb300 *fusb300)
 545 {
 546         fusb300_enable_bit(fusb300, FUSB300_OFFSET_CSR,
 547                            FUSB300_CSR_STL);
 548 }
 549
 550 static void fusb300_set_cxdone(struct fusb300 *fusb300)
 551 {
 552         fusb300_enable_bit(fusb300, FUSB300_OFFSET_CSR,
 553                            FUSB300_CSR_DONE);
 554 }
 555
 556 /* read data from cx fifo */
 557 static void fusb300_rdcxf(struct fusb300 *fusb300,
 558                    u8 *buffer, u32 length)
 559 {
 560         int i = 0;
 561         u8 *tmp;
 562         u32 data;
 563
 564         tmp = buffer;
 565
 566         for (i = (length >> 2); i > 0; i--) {
 567                 data = ioread32(fusb300->reg + FUSB300_OFFSET_CXPORT);
 568                 printk(KERN_DEBUG "    0x%x\n", data);
 569                 *tmp = data & 0xFF;
 570                 *(tmp + 1) = (data >> 8) & 0xFF;
 571                 *(tmp + 2) = (data >> 16) & 0xFF;
 572                 *(tmp + 3) = (data >> 24) & 0xFF;
 573                 tmp = tmp + 4;
 574         }
 575
 576         switch (length % 4) {
 577         case 1:
 578                 data = ioread32(fusb300->reg + FUSB300_OFFSET_CXPORT);
 579                 printk(KERN_DEBUG "    0x%x\n", data);
 580                 *tmp = data & 0xFF;
 581                 break;
 582         case 2:
 583                 data = ioread32(fusb300->reg + FUSB300_OFFSET_CXPORT);
 584                 printk(KERN_DEBUG "    0x%x\n", data);
 585                 *tmp = data & 0xFF;
 586                 *(tmp + 1) = (data >> 8) & 0xFF;
 587                 break;
 588         case 3:
 589                 data = ioread32(fusb300->reg + FUSB300_OFFSET_CXPORT);
 590                 printk(KERN_DEBUG "    0x%x\n", data);
 591                 *tmp = data & 0xFF;
 592                 *(tmp + 1) = (data >> 8) & 0xFF;
 593                 *(tmp + 2) = (data >> 16) & 0xFF;
 594                 break;
 595         default:
 596                 break;
 597         }
 598 }
 599
 600 static void fusb300_rdfifo(struct fusb300_ep *ep,
 601                           struct fusb300_request *req,
 602                           u32 length)
 603 {
 604         int i = 0;
 605         u8 *tmp;
 606         u32 data, reg;
 607         struct fusb300 *fusb300 = ep->fusb300;
 608
 609         tmp = req->req.buf + req->req.actual;
 610         req->req.actual += length;
 611
 612         if (req->req.actual > req->req.length)
 613                 printk(KERN_DEBUG "req->req.actual > req->req.length\n");
 614
 615         for (i = (length >> 2); i > 0; i--) {
 616                 data = ioread32(fusb300->reg +
 617                         FUSB300_OFFSET_EPPORT(ep->epnum));
 618                 *tmp = data & 0xFF;
 619                 *(tmp + 1) = (data >> 8) & 0xFF;
 620                 *(tmp + 2) = (data >> 16) & 0xFF;
 621                 *(tmp + 3) = (data >> 24) & 0xFF;
 622                 tmp = tmp + 4;
 623         }
 624
 625         switch (length % 4) {
 626         case 1:
 627                 data = ioread32(fusb300->reg +
 628                         FUSB300_OFFSET_EPPORT(ep->epnum));
 629                 *tmp = data & 0xFF;
 630                 break;
 631         case 2:
 632                 data = ioread32(fusb300->reg +
 633                         FUSB300_OFFSET_EPPORT(ep->epnum));
 634                 *tmp = data & 0xFF;
 635                 *(tmp + 1) = (data >> 8) & 0xFF;
 636                 break;
 637         case 3:
 638                 data = ioread32(fusb300->reg +
 639                         FUSB300_OFFSET_EPPORT(ep->epnum));
 640                 *tmp = data & 0xFF;
 641                 *(tmp + 1) = (data >> 8) & 0xFF;
 642                 *(tmp + 2) = (data >> 16) & 0xFF;
 643                 break;
 644         default:
 645                 break;
 646         }
 647
 648         do {
 649                 reg = ioread32(fusb300->reg + FUSB300_OFFSET_IGR1);
 650                 reg &= FUSB300_IGR1_SYNF0_EMPTY_INT;
 651                 if (i)
 652                         printk(KERN_INFO "sync fifo is not empty!\n");
 653                 i++;
 654         } while (!reg);
 655 }
 656
 657 static u8 fusb300_get_epnstall(struct fusb300 *fusb300, u8 ep)
 658 {
 659         u8 value;
 660         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPSET0(ep));
 661
 662         value = reg & FUSB300_EPSET0_STL;
 663
 664         return value;
 665 }
 666
 667 static u8 fusb300_get_cxstall(struct fusb300 *fusb300)
 668 {
 669         u8 value;
 670         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_CSR);
 671
 672         value = (reg & FUSB300_CSR_STL) >> 1;
 673
 674         return value;
 675 }
 676
 677 static void request_error(struct fusb300 *fusb300)
 678 {
 679         fusb300_set_cxstall(fusb300);
 680         printk(KERN_DEBUG "request error!!\n");
 681 }
 682
 683 static void get_status(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
 684 __releases(fusb300->lock)
 685 __acquires(fusb300->lock)
 686 {
 687         u8 ep;
 688         u16 status = 0;
 689         u16 w_index = ctrl->wIndex;
 690
 691         switch (ctrl->bRequestType & USB_RECIP_MASK) {
 692         case USB_RECIP_DEVICE:
 693                 status = 1 << USB_DEVICE_SELF_POWERED;
 694                 break;
 695         case USB_RECIP_INTERFACE:
 696                 status = 0;
 697                 break;
 698         case USB_RECIP_ENDPOINT:
 699                 ep = w_index & USB_ENDPOINT_NUMBER_MASK;
 700                 if (ep) {
 701                         if (fusb300_get_epnstall(fusb300, ep))
 702                                 status = 1 << USB_ENDPOINT_HALT;
 703                 } else {
 704                         if (fusb300_get_cxstall(fusb300))
 705                                 status = 0;
 706                 }
 707                 break;
 708
 709         default:
 710                 request_error(fusb300);
 711                 return;         /* exit */
 712         }
 713
 714         fusb300->ep0_data = cpu_to_le16(status);
 715         fusb300->ep0_req->buf = &fusb300->ep0_data;
 716         fusb300->ep0_req->length = 2;
 717
 718         spin_unlock(&fusb300->lock);
 719         fusb300_queue(fusb300->gadget.ep0, fusb300->ep0_req, GFP_KERNEL);
 720         spin_lock(&fusb300->lock);
 721 }
 722
 723 static void set_feature(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
 724 {
 725         u8 ep;
 726
 727         switch (ctrl->bRequestType & USB_RECIP_MASK) {
 728         case USB_RECIP_DEVICE:
 729                 fusb300_set_cxdone(fusb300);
 730                 break;
 731         case USB_RECIP_INTERFACE:
 732                 fusb300_set_cxdone(fusb300);
 733                 break;
 734         case USB_RECIP_ENDPOINT: {
 735                 u16 w_index = le16_to_cpu(ctrl->wIndex);
 736
 737                 ep = w_index & USB_ENDPOINT_NUMBER_MASK;
 738                 if (ep)
 739                         fusb300_set_epnstall(fusb300, ep);
 740                 else
 741                         fusb300_set_cxstall(fusb300);
 742                 fusb300_set_cxdone(fusb300);
 743                 }
 744                 break;
 745         default:
 746                 request_error(fusb300);
 747                 break;
 748         }
 749 }
 750
 751 static void fusb300_clear_seqnum(struct fusb300 *fusb300, u8 ep)
 752 {
 753         fusb300_enable_bit(fusb300, FUSB300_OFFSET_EPSET0(ep),
 754                             FUSB300_EPSET0_CLRSEQNUM);
 755 }
 756
 757 static void clear_feature(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
 758 {
 759         struct fusb300_ep *ep =
 760                 fusb300->ep[ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK];
 761
 762         switch (ctrl->bRequestType & USB_RECIP_MASK) {
 763         case USB_RECIP_DEVICE:
 764                 fusb300_set_cxdone(fusb300);
 765                 break;
 766         case USB_RECIP_INTERFACE:
 767                 fusb300_set_cxdone(fusb300);
 768                 break;
 769         case USB_RECIP_ENDPOINT:
 770                 if (ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK) {
 771                         if (ep->wedged) {
 772                                 fusb300_set_cxdone(fusb300);
 773                                 break;
 774                         }
 775                         if (ep->stall) {
 776                                 ep->stall = 0;
 777                                 fusb300_clear_seqnum(fusb300, ep->epnum);
 778                                 fusb300_clear_epnstall(fusb300, ep->epnum);
 779                                 if (!list_empty(&ep->queue))
 780                                         enable_fifo_int(ep);
 781                         }
 782                 }
 783                 fusb300_set_cxdone(fusb300);
 784                 break;
 785         default:
 786                 request_error(fusb300);
 787                 break;
 788         }
 789 }
 790
 791 static void fusb300_set_dev_addr(struct fusb300 *fusb300, u16 addr)
 792 {
 793         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_DAR);
 794
 795         reg &= ~FUSB300_DAR_DRVADDR_MSK;
 796         reg |= FUSB300_DAR_DRVADDR(addr);
 797
 798         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_DAR);
 799 }
 800
 801 static void set_address(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
 802 {
 803         if (ctrl->wValue >= 0x0100)
 804                 request_error(fusb300);
 805         else {
 806                 fusb300_set_dev_addr(fusb300, ctrl->wValue);
 807                 fusb300_set_cxdone(fusb300);
 808         }
 809 }
 810
 811 #define UVC_COPY_DESCRIPTORS(mem, src) \
 812         do { \
 813                 const struct usb_descriptor_header * const *__src; \
 814                 for (__src = src; *__src; ++__src) { \
 815                         memcpy(mem, *__src, (*__src)->bLength); \
 816                         mem += (*__src)->bLength; \
 817                 } \
 818         } while (0)
 819
 820 static int setup_packet(struct fusb300 *fusb300, struct usb_ctrlrequest *ctrl)
 821 {
 822         u8 *p = (u8 *)ctrl;
 823         u8 ret = 0;
 824         u8 i = 0;
 825
 826         fusb300_rdcxf(fusb300, p, 8);
 827         fusb300->ep0_dir = ctrl->bRequestType & USB_DIR_IN;
 828         fusb300->ep0_length = ctrl->wLength;
 829
 830         /* check request */
 831         if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
 832                 switch (ctrl->bRequest) {
 833                 case USB_REQ_GET_STATUS:
 834                         get_status(fusb300, ctrl);
 835                         break;
 836                 case USB_REQ_CLEAR_FEATURE:
 837                         clear_feature(fusb300, ctrl);
 838                         break;
 839                 case USB_REQ_SET_FEATURE:
 840                         set_feature(fusb300, ctrl);
 841                         break;
 842                 case USB_REQ_SET_ADDRESS:
 843                         set_address(fusb300, ctrl);
 844                         break;
 845                 case USB_REQ_SET_CONFIGURATION:
 846                         fusb300_enable_bit(fusb300, FUSB300_OFFSET_DAR,
 847                                            FUSB300_DAR_SETCONFG);
 848                         /* clear sequence number */
 849                         for (i = 1; i <= FUSB300_MAX_NUM_EP; i++)
 850                                 fusb300_clear_seqnum(fusb300, i);
 851                         fusb300->reenum = 1;
 852                         ret = 1;
 853                         break;
 854                 default:
 855                         ret = 1;
 856                         break;
 857                 }
 858         } else
 859                 ret = 1;
 860
 861         return ret;
 862 }
 863
 864 static void done(struct fusb300_ep *ep, struct fusb300_request *req,
 865                  int status)
 866 {
 867         list_del_init(&req->queue);
 868
 869         /* don't modify queue heads during completion callback */
 870         if (ep->fusb300->gadget.speed == USB_SPEED_UNKNOWN)
 871                 req->req.status = -ESHUTDOWN;
 872         else
 873                 req->req.status = status;
 874
 875         spin_unlock(&ep->fusb300->lock);
 876         usb_gadget_giveback_request(&ep->ep, &req->req);
 877         spin_lock(&ep->fusb300->lock);
 878
 879         if (ep->epnum) {
 880                 disable_fifo_int(ep);
 881                 if (!list_empty(&ep->queue))
 882                         enable_fifo_int(ep);
 883         } else
 884                 fusb300_set_cxdone(ep->fusb300);
 885 }
 886
 887 static void fusb300_fill_idma_prdtbl(struct fusb300_ep *ep, dma_addr_t d,
 888                 u32 len)
 889 {
 890         u32 value;
 891         u32 reg;
 892
 893         /* wait SW owner */
 894         do {
 895                 reg = ioread32(ep->fusb300->reg +
 896                         FUSB300_OFFSET_EPPRD_W0(ep->epnum));
 897                 reg &= FUSB300_EPPRD0_H;
 898         } while (reg);
 899
 900         iowrite32(d, ep->fusb300->reg + FUSB300_OFFSET_EPPRD_W1(ep->epnum));
 901
 902         value = FUSB300_EPPRD0_BTC(len) | FUSB300_EPPRD0_H |
 903                 FUSB300_EPPRD0_F | FUSB300_EPPRD0_L | FUSB300_EPPRD0_I;
 904         iowrite32(value, ep->fusb300->reg + FUSB300_OFFSET_EPPRD_W0(ep->epnum));
 905
 906         iowrite32(0x0, ep->fusb300->reg + FUSB300_OFFSET_EPPRD_W2(ep->epnum));
 907
 908         fusb300_enable_bit(ep->fusb300, FUSB300_OFFSET_EPPRDRDY,
 909                 FUSB300_EPPRDR_EP_PRD_RDY(ep->epnum));
 910 }
 911
 912 static void fusb300_wait_idma_finished(struct fusb300_ep *ep)
 913 {
 914         u32 reg;
 915
 916         do {
 917                 reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_IGR1);
 918                 if ((reg & FUSB300_IGR1_VBUS_CHG_INT) ||
 919                     (reg & FUSB300_IGR1_WARM_RST_INT) ||
 920                     (reg & FUSB300_IGR1_HOT_RST_INT) ||
 921                     (reg & FUSB300_IGR1_USBRST_INT)
 922                 )
 923                         goto IDMA_RESET;
 924                 reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_IGR0);
 925                 reg &= FUSB300_IGR0_EPn_PRD_INT(ep->epnum);
 926         } while (!reg);
 927
 928         fusb300_clear_int(ep->fusb300, FUSB300_OFFSET_IGR0,
 929                 FUSB300_IGR0_EPn_PRD_INT(ep->epnum));
 930         return;
 931
 932 IDMA_RESET:
 933         reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_IGER0);
 934         reg &= ~FUSB300_IGER0_EEPn_PRD_INT(ep->epnum);
 935         iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_IGER0);
 936 }
 937
 938 static void fusb300_set_idma(struct fusb300_ep *ep,
 939                         struct fusb300_request *req)
 940 {
 941         int ret;
 942
 943         ret = usb_gadget_map_request(&ep->fusb300->gadget,
 944                         &req->req, DMA_TO_DEVICE);
 945         if (ret)
 946                 return;
 947
 948         fusb300_enable_bit(ep->fusb300, FUSB300_OFFSET_IGER0,
 949                 FUSB300_IGER0_EEPn_PRD_INT(ep->epnum));
 950
 951         fusb300_fill_idma_prdtbl(ep, req->req.dma, req->req.length);
 952         /* check idma is done */
 953         fusb300_wait_idma_finished(ep);
 954
 955         usb_gadget_unmap_request(&ep->fusb300->gadget,
 956                         &req->req, DMA_TO_DEVICE);
 957 }
 958
 959 static void in_ep_fifo_handler(struct fusb300_ep *ep)
 960 {
 961         struct fusb300_request *req = list_entry(ep->queue.next,
 962                                         struct fusb300_request, queue);
 963
 964         if (req->req.length)
 965                 fusb300_set_idma(ep, req);
 966         done(ep, req, 0);
 967 }
 968
 969 static void out_ep_fifo_handler(struct fusb300_ep *ep)
 970 {
 971         struct fusb300 *fusb300 = ep->fusb300;
 972         struct fusb300_request *req = list_entry(ep->queue.next,
 973                                                  struct fusb300_request, queue);
 974         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_EPFFR(ep->epnum));
 975         u32 length = reg & FUSB300_FFR_BYCNT;
 976
 977         fusb300_rdfifo(ep, req, length);
 978
 979         /* finish out transfer */
 980         if ((req->req.length == req->req.actual) || (length < ep->ep.maxpacket))
 981                 done(ep, req, 0);
 982 }
 983
 984 static void check_device_mode(struct fusb300 *fusb300)
 985 {
 986         u32 reg = ioread32(fusb300->reg + FUSB300_OFFSET_GCR);
 987
 988         switch (reg & FUSB300_GCR_DEVEN_MSK) {
 989         case FUSB300_GCR_DEVEN_SS:
 990                 fusb300->gadget.speed = USB_SPEED_SUPER;
 991                 break;
 992         case FUSB300_GCR_DEVEN_HS:
 993                 fusb300->gadget.speed = USB_SPEED_HIGH;
 994                 break;
 995         case FUSB300_GCR_DEVEN_FS:
 996                 fusb300->gadget.speed = USB_SPEED_FULL;
 997                 break;
 998         default:
 999                 fusb300->gadget.speed = USB_SPEED_UNKNOWN;
1000                 break;
1001         }
1002         printk(KERN_INFO "dev_mode = %d\n", (reg & FUSB300_GCR_DEVEN_MSK));
1003 }
1004
1005
1006 static void fusb300_ep0out(struct fusb300 *fusb300)
1007 {
1008         struct fusb300_ep *ep = fusb300->ep[0];
1009         u32 reg;
1010
1011         if (!list_empty(&ep->queue)) {
1012                 struct fusb300_request *req;
1013
1014                 req = list_first_entry(&ep->queue,
1015                         struct fusb300_request, queue);
1016                 if (req->req.length)
1017                         fusb300_rdcxf(ep->fusb300, req->req.buf,
1018                                 req->req.length);
1019                 done(ep, req, 0);
1020                 reg = ioread32(fusb300->reg + FUSB300_OFFSET_IGER1);
1021                 reg &= ~FUSB300_IGER1_CX_OUT_INT;
1022                 iowrite32(reg, fusb300->reg + FUSB300_OFFSET_IGER1);
1023         } else
1024                 pr_err("%s : empty queue\n", __func__);
1025 }
1026
1027 static void fusb300_ep0in(struct fusb300 *fusb300)
1028 {
1029         struct fusb300_request *req;
1030         struct fusb300_ep *ep = fusb300->ep[0];
1031
1032         if ((!list_empty(&ep->queue)) && (fusb300->ep0_dir)) {
1033                 req = list_entry(ep->queue.next,
1034                                 struct fusb300_request, queue);
1035                 if (req->req.length)
1036                         fusb300_wrcxf(ep, req);
1037                 if ((req->req.length - req->req.actual) < ep->ep.maxpacket)
1038                         done(ep, req, 0);
1039         } else
1040                 fusb300_set_cxdone(fusb300);
1041 }
1042
1043 static void fusb300_grp2_handler(void)
1044 {
1045 }
1046
1047 static void fusb300_grp3_handler(void)
1048 {
1049 }
1050
1051 static void fusb300_grp4_handler(void)
1052 {
1053 }
1054
1055 static void fusb300_grp5_handler(void)
1056 {
1057 }
1058
1059 static irqreturn_t fusb300_irq(int irq, void *_fusb300)
1060 {
1061         struct fusb300 *fusb300 = _fusb300;
1062         u32 int_grp1 = ioread32(fusb300->reg + FUSB300_OFFSET_IGR1);
1063         u32 int_grp1_en = ioread32(fusb300->reg + FUSB300_OFFSET_IGER1);
1064         u32 int_grp0 = ioread32(fusb300->reg + FUSB300_OFFSET_IGR0);
1065         u32 int_grp0_en = ioread32(fusb300->reg + FUSB300_OFFSET_IGER0);
1066         struct usb_ctrlrequest ctrl;
1067         u8 in;
1068         u32 reg;
1069         int i;
1070
1071         spin_lock(&fusb300->lock);
1072
1073         int_grp1 &= int_grp1_en;
1074         int_grp0 &= int_grp0_en;
1075
1076         if (int_grp1 & FUSB300_IGR1_WARM_RST_INT) {
1077                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1078                                   FUSB300_IGR1_WARM_RST_INT);
1079                 printk(KERN_INFO"fusb300_warmreset\n");
1080                 fusb300_reset();
1081         }
1082
1083         if (int_grp1 & FUSB300_IGR1_HOT_RST_INT) {
1084                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1085                                   FUSB300_IGR1_HOT_RST_INT);
1086                 printk(KERN_INFO"fusb300_hotreset\n");
1087                 fusb300_reset();
1088         }
1089
1090         if (int_grp1 & FUSB300_IGR1_USBRST_INT) {
1091                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1092                                   FUSB300_IGR1_USBRST_INT);
1093                 fusb300_reset();
1094         }
1095         /* COMABT_INT has a highest priority */
1096
1097         if (int_grp1 & FUSB300_IGR1_CX_COMABT_INT) {
1098                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1099                                   FUSB300_IGR1_CX_COMABT_INT);
1100                 printk(KERN_INFO"fusb300_ep0abt\n");
1101         }
1102
1103         if (int_grp1 & FUSB300_IGR1_VBUS_CHG_INT) {
1104                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1105                                   FUSB300_IGR1_VBUS_CHG_INT);
1106                 printk(KERN_INFO"fusb300_vbus_change\n");
1107         }
1108
1109         if (int_grp1 & FUSB300_IGR1_U3_EXIT_FAIL_INT) {
1110                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1111                                   FUSB300_IGR1_U3_EXIT_FAIL_INT);
1112         }
1113
1114         if (int_grp1 & FUSB300_IGR1_U2_EXIT_FAIL_INT) {
1115                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1116                                   FUSB300_IGR1_U2_EXIT_FAIL_INT);
1117         }
1118
1119         if (int_grp1 & FUSB300_IGR1_U1_EXIT_FAIL_INT) {
1120                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1121                                   FUSB300_IGR1_U1_EXIT_FAIL_INT);
1122         }
1123
1124         if (int_grp1 & FUSB300_IGR1_U2_ENTRY_FAIL_INT) {
1125                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1126                                   FUSB300_IGR1_U2_ENTRY_FAIL_INT);
1127         }
1128
1129         if (int_grp1 & FUSB300_IGR1_U1_ENTRY_FAIL_INT) {
1130                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1131                                   FUSB300_IGR1_U1_ENTRY_FAIL_INT);
1132         }
1133
1134         if (int_grp1 & FUSB300_IGR1_U3_EXIT_INT) {
1135                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1136                                   FUSB300_IGR1_U3_EXIT_INT);
1137                 printk(KERN_INFO "FUSB300_IGR1_U3_EXIT_INT\n");
1138         }
1139
1140         if (int_grp1 & FUSB300_IGR1_U2_EXIT_INT) {
1141                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1142                                   FUSB300_IGR1_U2_EXIT_INT);
1143                 printk(KERN_INFO "FUSB300_IGR1_U2_EXIT_INT\n");
1144         }
1145
1146         if (int_grp1 & FUSB300_IGR1_U1_EXIT_INT) {
1147                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1148                                   FUSB300_IGR1_U1_EXIT_INT);
1149                 printk(KERN_INFO "FUSB300_IGR1_U1_EXIT_INT\n");
1150         }
1151
1152         if (int_grp1 & FUSB300_IGR1_U3_ENTRY_INT) {
1153                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1154                                   FUSB300_IGR1_U3_ENTRY_INT);
1155                 printk(KERN_INFO "FUSB300_IGR1_U3_ENTRY_INT\n");
1156                 fusb300_enable_bit(fusb300, FUSB300_OFFSET_SSCR1,
1157                                    FUSB300_SSCR1_GO_U3_DONE);
1158         }
1159
1160         if (int_grp1 & FUSB300_IGR1_U2_ENTRY_INT) {
1161                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1162                                   FUSB300_IGR1_U2_ENTRY_INT);
1163                 printk(KERN_INFO "FUSB300_IGR1_U2_ENTRY_INT\n");
1164         }
1165
1166         if (int_grp1 & FUSB300_IGR1_U1_ENTRY_INT) {
1167                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1168                                   FUSB300_IGR1_U1_ENTRY_INT);
1169                 printk(KERN_INFO "FUSB300_IGR1_U1_ENTRY_INT\n");
1170         }
1171
1172         if (int_grp1 & FUSB300_IGR1_RESM_INT) {
1173                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1174                                   FUSB300_IGR1_RESM_INT);
1175                 printk(KERN_INFO "fusb300_resume\n");
1176         }
1177
1178         if (int_grp1 & FUSB300_IGR1_SUSP_INT) {
1179                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1180                                   FUSB300_IGR1_SUSP_INT);
1181                 printk(KERN_INFO "fusb300_suspend\n");
1182         }
1183
1184         if (int_grp1 & FUSB300_IGR1_HS_LPM_INT) {
1185                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1186                                   FUSB300_IGR1_HS_LPM_INT);
1187                 printk(KERN_INFO "fusb300_HS_LPM_INT\n");
1188         }
1189
1190         if (int_grp1 & FUSB300_IGR1_DEV_MODE_CHG_INT) {
1191                 fusb300_clear_int(fusb300, FUSB300_OFFSET_IGR1,
1192                                   FUSB300_IGR1_DEV_MODE_CHG_INT);
1193                 check_device_mode(fusb300);
1194         }
1195
1196         if (int_grp1 & FUSB300_IGR1_CX_COMFAIL_INT) {
1197                 fusb300_set_cxstall(fusb300);
1198                 printk(KERN_INFO "fusb300_ep0fail\n");
1199         }
1200
1201         if (int_grp1 & FUSB300_IGR1_CX_SETUP_INT) {
1202                 printk(KERN_INFO "fusb300_ep0setup\n");
1203                 if (setup_packet(fusb300, &ctrl)) {
1204                         spin_unlock(&fusb300->lock);
1205                         if (fusb300->driver->setup(&fusb300->gadget, &ctrl) < 0)
1206                                 fusb300_set_cxstall(fusb300);
1207                         spin_lock(&fusb300->lock);
1208                 }
1209         }
1210
1211         if (int_grp1 & FUSB300_IGR1_CX_CMDEND_INT)
1212                 printk(KERN_INFO "fusb300_cmdend\n");
1213
1214
1215         if (int_grp1 & FUSB300_IGR1_CX_OUT_INT) {
1216                 printk(KERN_INFO "fusb300_cxout\n");
1217                 fusb300_ep0out(fusb300);
1218         }
1219
1220         if (int_grp1 & FUSB300_IGR1_CX_IN_INT) {
1221                 printk(KERN_INFO "fusb300_cxin\n");
1222                 fusb300_ep0in(fusb300);
1223         }
1224
1225         if (int_grp1 & FUSB300_IGR1_INTGRP5)
1226                 fusb300_grp5_handler();
1227
1228         if (int_grp1 & FUSB300_IGR1_INTGRP4)
1229                 fusb300_grp4_handler();
1230
1231         if (int_grp1 & FUSB300_IGR1_INTGRP3)
1232                 fusb300_grp3_handler();
1233
1234         if (int_grp1 & FUSB300_IGR1_INTGRP2)
1235                 fusb300_grp2_handler();
1236
1237         if (int_grp0) {
1238                 for (i = 1; i < FUSB300_MAX_NUM_EP; i++) {
1239                         if (int_grp0 & FUSB300_IGR0_EPn_FIFO_INT(i)) {
1240                                 reg = ioread32(fusb300->reg +
1241                                         FUSB300_OFFSET_EPSET1(i));
1242                                 in = (reg & FUSB300_EPSET1_DIRIN) ? 1 : 0;
1243                                 if (in)
1244                                         in_ep_fifo_handler(fusb300->ep[i]);
1245                                 else
1246                                         out_ep_fifo_handler(fusb300->ep[i]);
1247                         }
1248                 }
1249         }
1250
1251         spin_unlock(&fusb300->lock);
1252
1253         return IRQ_HANDLED;
1254 }
1255
1256 static void fusb300_set_u2_timeout(struct fusb300 *fusb300,
1257                                    u32 time)
1258 {
1259         u32 reg;
1260
1261         reg = ioread32(fusb300->reg + FUSB300_OFFSET_TT);
1262         reg &= ~0xff;
1263         reg |= FUSB300_SSCR2_U2TIMEOUT(time);
1264
1265         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_TT);
1266 }
1267
1268 static void fusb300_set_u1_timeout(struct fusb300 *fusb300,
1269                                    u32 time)
1270 {
1271         u32 reg;
1272
1273         reg = ioread32(fusb300->reg + FUSB300_OFFSET_TT);
1274         reg &= ~(0xff << 8);
1275         reg |= FUSB300_SSCR2_U1TIMEOUT(time);
1276
1277         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_TT);
1278 }
1279
1280 static void init_controller(struct fusb300 *fusb300)
1281 {
1282         u32 reg;
1283         u32 mask = 0;
1284         u32 val = 0;
1285
1286         /* split on */
1287         mask = val = FUSB300_AHBBCR_S0_SPLIT_ON | FUSB300_AHBBCR_S1_SPLIT_ON;
1288         reg = ioread32(fusb300->reg + FUSB300_OFFSET_AHBCR);
1289         reg &= ~mask;
1290         reg |= val;
1291         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_AHBCR);
1292
1293         /* enable high-speed LPM */
1294         mask = val = FUSB300_HSCR_HS_LPM_PERMIT;
1295         reg = ioread32(fusb300->reg + FUSB300_OFFSET_HSCR);
1296         reg &= ~mask;
1297         reg |= val;
1298         iowrite32(reg, fusb300->reg + FUSB300_OFFSET_HSCR);
1299
1300         /*set u1 u2 timmer*/
1301         fusb300_set_u2_timeout(fusb300, 0xff);
1302         fusb300_set_u1_timeout(fusb300, 0xff);
1303
1304         /* enable all grp1 interrupt */
1305         iowrite32(0xcfffff9f, fusb300->reg + FUSB300_OFFSET_IGER1);
1306 }
1307 /*------------------------------------------------------------------------*/
1308 static int fusb300_udc_start(struct usb_gadget *g,
1309                 struct usb_gadget_driver *driver)
1310 {
1311         struct fusb300 *fusb300 = to_fusb300(g);
1312
1313         /* hook up the driver */
1314         driver->driver.bus = NULL;
1315         fusb300->driver = driver;
1316
1317         return 0;
1318 }
1319
1320 static int fusb300_udc_stop(struct usb_gadget *g)
1321 {
1322         struct fusb300 *fusb300 = to_fusb300(g);
1323
1324         init_controller(fusb300);
1325         fusb300->driver = NULL;
1326
1327         return 0;
1328 }
1329 /*--------------------------------------------------------------------------*/
1330
1331 static int fusb300_udc_pullup(struct usb_gadget *_gadget, int is_active)
1332 {
1333         return 0;
1334 }
1335
1336 static const struct usb_gadget_ops fusb300_gadget_ops = {
1337         .pullup         = fusb300_udc_pullup,
1338         .udc_start      = fusb300_udc_start,
1339         .udc_stop       = fusb300_udc_stop,
1340 };
1341
1342 static int fusb300_remove(struct platform_device *pdev)
1343 {
1344         struct fusb300 *fusb300 = platform_get_drvdata(pdev);
1345         int i;
1346
1347         usb_del_gadget_udc(&fusb300->gadget);
1348         iounmap(fusb300->reg);
1349         free_irq(platform_get_irq(pdev, 0), fusb300);
1350
1351         fusb300_free_request(&fusb300->ep[0]->ep, fusb300->ep0_req);
1352         for (i = 0; i < FUSB300_MAX_NUM_EP; i++)
1353                 kfree(fusb300->ep[i]);
1354         kfree(fusb300);
1355
1356         return 0;
1357 }
1358
1359 static int fusb300_probe(struct platform_device *pdev)
1360 {
1361         struct resource *res, *ires, *ires1;
1362         void __iomem *reg = NULL;
1363         struct fusb300 *fusb300 = NULL;
1364         struct fusb300_ep *_ep[FUSB300_MAX_NUM_EP];
1365         int ret = 0;
1366         int i;
1367
1368         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1369         if (!res) {
1370                 ret = -ENODEV;
1371                 pr_err("platform_get_resource error.\n");
1372                 goto clean_up;
1373         }
1374
1375         ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1376         if (!ires) {
1377                 ret = -ENODEV;
1378                 dev_err(&pdev->dev,
1379                         "platform_get_resource IORESOURCE_IRQ error.\n");
1380                 goto clean_up;
1381         }
1382
1383         ires1 = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
1384         if (!ires1) {
1385                 ret = -ENODEV;
1386                 dev_err(&pdev->dev,
1387                         "platform_get_resource IORESOURCE_IRQ 1 error.\n");
1388                 goto clean_up;
1389         }
1390
1391         reg = ioremap(res->start, resource_size(res));
1392         if (reg == NULL) {
1393                 ret = -ENOMEM;
1394                 pr_err("ioremap error.\n");
1395                 goto clean_up;
1396         }
1397
1398         /* initialize udc */
1399         fusb300 = kzalloc(sizeof(struct fusb300), GFP_KERNEL);
1400         if (fusb300 == NULL) {
1401                 ret = -ENOMEM;
1402                 goto clean_up;
1403         }
1404
1405         for (i = 0; i < FUSB300_MAX_NUM_EP; i++) {
1406                 _ep[i] = kzalloc(sizeof(struct fusb300_ep), GFP_KERNEL);
1407                 if (_ep[i] == NULL) {
1408                         ret = -ENOMEM;
1409                         goto clean_up;
1410                 }
1411                 fusb300->ep[i] = _ep[i];
1412         }
1413
1414         spin_lock_init(&fusb300->lock);
1415
1416         platform_set_drvdata(pdev, fusb300);
1417
1418         fusb300->gadget.ops = &fusb300_gadget_ops;
1419
1420         fusb300->gadget.max_speed = USB_SPEED_HIGH;
1421         fusb300->gadget.name = udc_name;
1422         fusb300->reg = reg;
1423
1424         ret = request_irq(ires->start, fusb300_irq, IRQF_SHARED,
1425                           udc_name, fusb300);
1426         if (ret < 0) {
1427                 pr_err("request_irq error (%d)\n", ret);
1428                 goto clean_up;
1429         }
1430
1431         ret = request_irq(ires1->start, fusb300_irq,
1432                         IRQF_SHARED, udc_name, fusb300);
1433         if (ret < 0) {
1434                 pr_err("request_irq1 error (%d)\n", ret);
1435                 goto clean_up;
1436         }
1437
1438         INIT_LIST_HEAD(&fusb300->gadget.ep_list);
1439
1440         for (i = 0; i < FUSB300_MAX_NUM_EP ; i++) {
1441                 struct fusb300_ep *ep = fusb300->ep[i];
1442
1443                 if (i != 0) {
1444                         INIT_LIST_HEAD(&fusb300->ep[i]->ep.ep_list);
1445                         list_add_tail(&fusb300->ep[i]->ep.ep_list,
1446                                      &fusb300->gadget.ep_list);
1447                 }
1448                 ep->fusb300 = fusb300;
1449                 INIT_LIST_HEAD(&ep->queue);
1450                 ep->ep.name = fusb300_ep_name[i];
1451                 ep->ep.ops = &fusb300_ep_ops;
1452                 usb_ep_set_maxpacket_limit(&ep->ep, HS_BULK_MAX_PACKET_SIZE);
1453
1454                 if (i == 0) {
1455                         ep->ep.caps.type_control = true;
1456                 } else {
1457                         ep->ep.caps.type_iso = true;
1458                         ep->ep.caps.type_bulk = true;
1459                         ep->ep.caps.type_int = true;
1460                 }
1461
1462                 ep->ep.caps.dir_in = true;
1463                 ep->ep.caps.dir_out = true;
1464         }
1465         usb_ep_set_maxpacket_limit(&fusb300->ep[0]->ep, HS_CTL_MAX_PACKET_SIZE);
1466         fusb300->ep[0]->epnum = 0;
1467         fusb300->gadget.ep0 = &fusb300->ep[0]->ep;
1468         INIT_LIST_HEAD(&fusb300->gadget.ep0->ep_list);
1469
1470         fusb300->ep0_req = fusb300_alloc_request(&fusb300->ep[0]->ep,
1471                                 GFP_KERNEL);
1472         if (fusb300->ep0_req == NULL) {
1473                 ret = -ENOMEM;
1474                 goto clean_up3;
1475         }
1476
1477         init_controller(fusb300);
1478         ret = usb_add_gadget_udc(&pdev->dev, &fusb300->gadget);
1479         if (ret)
1480                 goto err_add_udc;
1481
1482         dev_info(&pdev->dev, "version %s\n", DRIVER_VERSION);
1483
1484         return 0;
1485
1486 err_add_udc:
1487         fusb300_free_request(&fusb300->ep[0]->ep, fusb300->ep0_req);
1488
1489 clean_up3:
1490         free_irq(ires->start, fusb300);
1491
1492 clean_up:
1493         if (fusb300) {
1494                 if (fusb300->ep0_req)
1495                         fusb300_free_request(&fusb300->ep[0]->ep,
1496                                 fusb300->ep0_req);
1497                 for (i = 0; i < FUSB300_MAX_NUM_EP; i++)
1498                         kfree(fusb300->ep[i]);
1499                 kfree(fusb300);
1500         }
1501         if (reg)
1502                 iounmap(reg);
1503
1504         return ret;
1505 }
1506
1507 static struct platform_driver fusb300_driver = {
1508         .remove =       fusb300_remove,
1509         .driver         = {
1510                 .name = (char *) udc_name,
1511         },
1512 };
1513
1514 module_platform_driver_probe(fusb300_driver, fusb300_probe);