target/linux/ramips/patches-3.10/0512-USB-add-xhci-support-for-mt7621.patch

   1 --- a/drivers/usb/core/hub.c
   2 +++ b/drivers/usb/core/hub.c
   3 @@ -1254,7 +1254,7 @@ static void hub_quiesce(struct usb_hub *
   4         if (type != HUB_SUSPEND) {
   5                 /* Disconnect all the children */
   6                 for (i = 0; i < hdev->maxchild; ++i) {
   7 -                       if (hub->ports[i]->child)
   8 +                       if (hub->ports[i] && hub->ports[i]->child)
   9                                 usb_disconnect(&hub->ports[i]->child);
  10                 }
  11         }
  12 --- a/drivers/usb/core/port.c
  13 +++ b/drivers/usb/core/port.c
  14 @@ -193,6 +193,7 @@ exit:
  15  void usb_hub_remove_port_device(struct usb_hub *hub,
  16                                        int port1)
  17  {
  18 -       device_unregister(&hub->ports[port1 - 1]->dev);
  19 +       if (hub->ports[port1 - 1])
  20 +               device_unregister(&hub->ports[port1 - 1]->dev);
  21  }
  22
  23 --- a/drivers/usb/host/Kconfig
  24 +++ b/drivers/usb/host/Kconfig
  25 @@ -28,7 +28,11 @@ config USB_XHCI_HCD
  26  if USB_XHCI_HCD
  27
  28  config USB_XHCI_PLATFORM
  29 -       tristate
  30 +       bool "xHCI platform"
  31 +
  32 +config USB_MT7621_XHCI_PLATFORM
  33 +       bool "MTK MT7621 xHCI"
  34 +       depends on USB_XHCI_PLATFORM
  35
  36  config USB_XHCI_HCD_DEBUGGING
  37         bool "Debugging for the xHCI host controller"
  38 --- a/drivers/usb/host/Makefile
  39 +++ b/drivers/usb/host/Makefile
  40 @@ -13,15 +13,23 @@ fhci-$(CONFIG_FHCI_DEBUG) += fhci-dbg.o
  41
  42  xhci-hcd-y := xhci.o xhci-mem.o
  43  xhci-hcd-y += xhci-ring.o xhci-hub.o xhci-dbg.o
  44 +ifndef CONFIG_USB_MT7621_XHCI_PLATFORM
  45  xhci-hcd-$(CONFIG_PCI) += xhci-pci.o
  46 +endif
  47 +
  48 +ifdef CONFIG_USB_MT7621_XHCI_PLATFORM
  49 +xhci-hcd-y += mtk-phy.o xhci-mtk-scheduler.o xhci-mtk-power.o xhci-mtk.o mtk-phy-7621.o mtk-phy-ahb.o
  50 +endif
  51
  52  ifneq ($(CONFIG_USB_XHCI_PLATFORM), )
  53 -       xhci-hcd-y              += xhci-plat.o
  54 +xhci-hcd-y             += xhci-plat.o
  55  endif
  56
  57  obj-$(CONFIG_USB_WHCI_HCD)     += whci/
  58
  59 +ifndef CONFIG_USB_MT7621_XHCI_PLATFORM
  60  obj-$(CONFIG_PCI)              += pci-quirks.o
  61 +endif
  62
  63  obj-$(CONFIG_USB_EHCI_HCD)     += ehci-hcd.o
  64  obj-$(CONFIG_USB_EHCI_PCI)     += ehci-pci.o
  65 --- a/drivers/usb/host/pci-quirks.h
  66 +++ b/drivers/usb/host/pci-quirks.h
  67 @@ -1,7 +1,7 @@
  68  #ifndef __LINUX_USB_PCI_QUIRKS_H
  69  #define __LINUX_USB_PCI_QUIRKS_H
  70
  71 -#ifdef CONFIG_PCI
  72 +#if defined (CONFIG_PCI) && !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
  73  void uhci_reset_hc(struct pci_dev *pdev, unsigned long base);
  74  int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base);
  75  #endif  /* CONFIG_PCI */
  76 --- a/drivers/usb/host/xhci.c
  77 +++ b/drivers/usb/host/xhci.c
  78 @@ -30,6 +30,16 @@
  79
  80  #include "xhci.h"
  81
  82 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
  83 +#include <asm/uaccess.h>
  84 +#include <linux/dma-mapping.h>
  85 +#include <linux/platform_device.h>
  86 +#include "mtk-phy.h"
  87 +#include "xhci-mtk-scheduler.h"
  88 +#include "xhci-mtk-power.h"
  89 +#include "xhci-mtk.h"
  90 +#endif
  91 +
  92  #define DRIVER_AUTHOR "Sarah Sharp"
  93  #define DRIVER_DESC "'eXtensible' Host Controller (xHC) Driver"
  94
  95 @@ -38,6 +48,18 @@ static int link_quirk;
  96  module_param(link_quirk, int, S_IRUGO | S_IWUSR);
  97  MODULE_PARM_DESC(link_quirk, "Don't clear the chain bit on a link TRB");
  98
  99 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 100 +long xhci_mtk_test_unlock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 101 +static struct file_operations xhci_mtk_test_fops = {
 102 +    .owner =           THIS_MODULE,
 103 +    .read =            xhci_mtk_test_read,
 104 +    .write =           xhci_mtk_test_write,
 105 +    .unlocked_ioctl =  xhci_mtk_test_unlock_ioctl,
 106 +    .open =            xhci_mtk_test_open,
 107 +    .release =         xhci_mtk_test_release,
 108 +};
 109 +#endif
 110 +
 111  /* TODO: copied from ehci-hcd.c - can this be refactored? */
 112  /*
 113   * xhci_handshake - spin reading hc until handshake completes or fails
 114 @@ -189,7 +211,7 @@ int xhci_reset(struct xhci_hcd *xhci)
 115         return ret;
 116  }
 117
 118 -#ifdef CONFIG_PCI
 119 +#if defined (CONFIG_PCI) && !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 120  static int xhci_free_msi(struct xhci_hcd *xhci)
 121  {
 122         int i;
 123 @@ -389,6 +411,7 @@ static int xhci_try_enable_msi(struct us
 124                 return ret;
 125         }
 126         hcd->irq = pdev->irq;
 127 +
 128         return 0;
 129  }
 130
 131 @@ -430,6 +453,11 @@ static void compliance_mode_recovery(uns
 132                         xhci_dbg(xhci, "Attempting compliance mode recovery\n");
 133                         hcd = xhci->shared_hcd;
 134
 135 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 136 +                       temp |= (1 << 31);
 137 +                       xhci_writel(xhci, temp, xhci->usb3_ports[i]);
 138 +#endif
 139 +
 140                         if (hcd->state == HC_STATE_SUSPENDED)
 141                                 usb_hcd_resume_root_hub(hcd);
 142
 143 @@ -478,6 +506,9 @@ bool xhci_compliance_mode_recovery_timer
 144  {
 145         const char *dmi_product_name, *dmi_sys_vendor;
 146
 147 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 148 +       return true;
 149 +#endif
 150         dmi_product_name = dmi_get_system_info(DMI_PRODUCT_NAME);
 151         dmi_sys_vendor = dmi_get_system_info(DMI_SYS_VENDOR);
 152         if (!dmi_product_name || !dmi_sys_vendor)
 153 @@ -521,6 +552,10 @@ int xhci_init(struct usb_hcd *hcd)
 154         } else {
 155                 xhci_dbg(xhci, "xHCI doesn't need link TRB QUIRK\n");
 156         }
 157 +
 158 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 159 +       mtk_xhci_scheduler_init();
 160 +#endif
 161         retval = xhci_mem_init(xhci, GFP_KERNEL);
 162         xhci_dbg(xhci, "Finished xhci_init\n");
 163
 164 @@ -664,7 +699,11 @@ int xhci_run(struct usb_hcd *hcd)
 165         xhci_dbg(xhci, "// Set the interrupt modulation register\n");
 166         temp = xhci_readl(xhci, &xhci->ir_set->irq_control);
 167         temp &= ~ER_IRQ_INTERVAL_MASK;
 168 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 169 +       temp |= (u32) 16;
 170 +#else
 171         temp |= (u32) 160;
 172 +#endif
 173         xhci_writel(xhci, temp, &xhci->ir_set->irq_control);
 174
 175         /* Set the HCD state before we enable the irqs */
 176 @@ -685,6 +724,9 @@ int xhci_run(struct usb_hcd *hcd)
 177                 xhci_queue_vendor_command(xhci, 0, 0, 0,
 178                                 TRB_TYPE(TRB_NEC_GET_FW));
 179
 180 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 181 +       enableXhciAllPortPower(xhci);
 182 +#endif
 183         xhci_dbg(xhci, "Finished xhci_run for USB2 roothub\n");
 184         return 0;
 185  }
 186 @@ -1002,7 +1044,6 @@ int xhci_resume(struct xhci_hcd *xhci, b
 187
 188         /* If restore operation fails, re-initialize the HC during resume */
 189         if ((temp & STS_SRE) || hibernated) {
 190 -
 191                 if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) &&
 192                                 !(xhci_all_ports_seen_u0(xhci))) {
 193                         del_timer_sync(&xhci->comp_mode_recovery_timer);
 194 @@ -1586,6 +1627,13 @@ int xhci_drop_endpoint(struct usb_hcd *h
 195         u32 drop_flag;
 196         u32 new_add_flags, new_drop_flags, new_slot_info;
 197         int ret;
 198 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 199 +#if MTK_SCH_NEW
 200 +       struct sch_ep *sch_ep = NULL;
 201 +       int isTT;
 202 +       int ep_type;
 203 +#endif
 204 +#endif
 205
 206         ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
 207         if (ret <= 0)
 208 @@ -1637,6 +1685,40 @@ int xhci_drop_endpoint(struct usb_hcd *h
 209
 210         xhci_endpoint_zero(xhci, xhci->devs[udev->slot_id], ep);
 211
 212 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 213 +#if MTK_SCH_NEW
 214 +       slot_ctx = xhci_get_slot_ctx(xhci, xhci->devs[udev->slot_id]->out_ctx);
 215 +       if ((slot_ctx->tt_info & 0xff) > 0) {
 216 +               isTT = 1;
 217 +       }
 218 +       else {
 219 +               isTT = 0;
 220 +       }
 221 +       if (usb_endpoint_xfer_int(&ep->desc)) {
 222 +               ep_type = USB_EP_INT;
 223 +       }
 224 +       else if (usb_endpoint_xfer_isoc(&ep->desc)) {
 225 +               ep_type = USB_EP_ISOC;
 226 +       }
 227 +       else if (usb_endpoint_xfer_bulk(&ep->desc)) {
 228 +               ep_type = USB_EP_BULK;
 229 +       }
 230 +       else
 231 +               ep_type = USB_EP_CONTROL;
 232 +
 233 +       sch_ep = mtk_xhci_scheduler_remove_ep(udev->speed, usb_endpoint_dir_in(&ep->desc)
 234 +               , isTT, ep_type, (mtk_u32 *)ep);
 235 +       if (sch_ep != NULL) {
 236 +               kfree(sch_ep);
 237 +       }
 238 +       else {
 239 +               xhci_dbg(xhci, "[MTK]Doesn't find ep_sch instance when removing endpoint\n");
 240 +       }
 241 +#else
 242 +       mtk_xhci_scheduler_remove_ep(xhci, udev, ep);
 243 +#endif
 244 +#endif
 245 +
 246         xhci_dbg(xhci, "drop ep 0x%x, slot id %d, new drop flags = %#x, new add flags = %#x, new slot info = %#x\n",
 247                         (unsigned int) ep->desc.bEndpointAddress,
 248                         udev->slot_id,
 249 @@ -1672,6 +1754,18 @@ int xhci_add_endpoint(struct usb_hcd *hc
 250         u32 new_add_flags, new_drop_flags, new_slot_info;
 251         struct xhci_virt_device *virt_dev;
 252         int ret = 0;
 253 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 254 +       struct xhci_ep_ctx *in_ep_ctx;
 255 +#if MTK_SCH_NEW
 256 +       struct sch_ep *sch_ep;
 257 +       int isTT;
 258 +       int ep_type;
 259 +       int maxp = 0;
 260 +       int burst = 0;
 261 +       int mult = 0;
 262 +       int interval;
 263 +#endif
 264 +#endif
 265
 266         ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
 267         if (ret <= 0) {
 268 @@ -1734,6 +1828,56 @@ int xhci_add_endpoint(struct usb_hcd *hc
 269                 return -ENOMEM;
 270         }
 271
 272 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 273 +       in_ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index);
 274 +#if MTK_SCH_NEW
 275 +       slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx);
 276 +       if ((slot_ctx->tt_info & 0xff) > 0) {
 277 +               isTT = 1;
 278 +       }
 279 +       else {
 280 +               isTT = 0;
 281 +       }
 282 +       if (usb_endpoint_xfer_int(&ep->desc)) {
 283 +               ep_type = USB_EP_INT;
 284 +       }
 285 +       else if (usb_endpoint_xfer_isoc(&ep->desc)) {
 286 +               ep_type = USB_EP_ISOC;
 287 +       }
 288 +       else if (usb_endpoint_xfer_bulk(&ep->desc)) {
 289 +               ep_type = USB_EP_BULK;
 290 +       }
 291 +       else
 292 +               ep_type = USB_EP_CONTROL;
 293 +
 294 +       if (udev->speed == USB_SPEED_FULL || udev->speed == USB_SPEED_HIGH
 295 +               || udev->speed == USB_SPEED_LOW) {
 296 +               maxp = ep->desc.wMaxPacketSize & 0x7FF;
 297 +               burst = ep->desc.wMaxPacketSize >> 11;
 298 +               mult = 0;
 299 +       }
 300 +       else if (udev->speed == USB_SPEED_SUPER) {
 301 +               maxp = ep->desc.wMaxPacketSize & 0x7FF;
 302 +               burst = ep->ss_ep_comp.bMaxBurst;
 303 +               mult = ep->ss_ep_comp.bmAttributes & 0x3;
 304 +       }
 305 +       interval = (1 << ((in_ep_ctx->ep_info >> 16) & 0xff));
 306 +       sch_ep = kmalloc(sizeof(struct sch_ep), GFP_KERNEL);
 307 +       if (mtk_xhci_scheduler_add_ep(udev->speed, usb_endpoint_dir_in(&ep->desc),
 308 +               isTT, ep_type, maxp, interval, burst, mult, (mtk_u32 *)ep
 309 +               , (mtk_u32 *)in_ep_ctx, sch_ep) != SCH_SUCCESS) {
 310 +               xhci_err(xhci, "[MTK] not enough bandwidth\n");
 311 +
 312 +               return -ENOSPC;
 313 +       }
 314 +#else
 315 +       if (mtk_xhci_scheduler_add_ep(xhci, udev, ep, in_ep_ctx) != SCH_SUCCESS) {
 316 +               xhci_err(xhci, "[MTK] not enough bandwidth\n");
 317 +
 318 +               return -ENOSPC;
 319 +       }
 320 +#endif
 321 +#endif
 322         ctrl_ctx->add_flags |= cpu_to_le32(added_ctxs);
 323         new_add_flags = le32_to_cpu(ctrl_ctx->add_flags);
 324
 325 @@ -2697,7 +2841,7 @@ int xhci_check_bandwidth(struct usb_hcd
 326         if (ctrl_ctx->add_flags == cpu_to_le32(SLOT_FLAG) &&
 327                         ctrl_ctx->drop_flags == 0)
 328                 return 0;
 329 -
 330 +
 331         xhci_dbg(xhci, "New Input Control Context:\n");
 332         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
 333         xhci_dbg_ctx(xhci, virt_dev->in_ctx,
 334 @@ -4233,10 +4377,14 @@ static u16 xhci_call_host_update_timeout
 335                 u16 *timeout)
 336  {
 337         if (state == USB3_LPM_U1) {
 338 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 339                 if (xhci->quirks & XHCI_INTEL_HOST)
 340 +#endif
 341                         return xhci_calculate_intel_u1_timeout(udev, desc);
 342         } else {
 343 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 344                 if (xhci->quirks & XHCI_INTEL_HOST)
 345 +#endif
 346                         return xhci_calculate_intel_u2_timeout(udev, desc);
 347         }
 348
 349 @@ -4662,7 +4810,9 @@ int xhci_gen_setup(struct usb_hcd *hcd,
 350         /* Accept arbitrarily long scatter-gather lists */
 351         hcd->self.sg_tablesize = ~0;
 352         /* XHCI controllers don't stop the ep queue on short packets :| */
 353 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 354         hcd->self.no_stop_on_short = 1;
 355 +#endif
 356
 357         if (usb_hcd_is_primary_hcd(hcd)) {
 358                 xhci = kzalloc(sizeof(struct xhci_hcd), GFP_KERNEL);
 359 @@ -4731,6 +4881,10 @@ int xhci_gen_setup(struct usb_hcd *hcd,
 360                 goto error;
 361         xhci_dbg(xhci, "Reset complete\n");
 362
 363 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 364 +       setInitialReg();
 365 +#endif
 366 +
 367         temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
 368         if (HCC_64BIT_ADDR(temp)) {
 369                 xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
 370 @@ -4755,8 +4909,21 @@ MODULE_DESCRIPTION(DRIVER_DESC);
 371  MODULE_AUTHOR(DRIVER_AUTHOR);
 372  MODULE_LICENSE("GPL");
 373
 374 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 375 +static struct platform_device xhci_platform_dev = {
 376 +       .name = "xhci-hcd",
 377 +       .id   = -1,
 378 +       .dev  = {
 379 +               .coherent_dma_mask = 0xffffffff,
 380 +        },
 381 +};
 382 +#endif
 383 +
 384  static int __init xhci_hcd_init(void)
 385  {
 386 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 387 +       struct platform_device *pPlatformDev;
 388 +#endif
 389         int retval;
 390
 391         retval = xhci_register_pci();
 392 @@ -4769,6 +4936,33 @@ static int __init xhci_hcd_init(void)
 393                 printk(KERN_DEBUG "Problem registering platform driver.");
 394                 goto unreg_pci;
 395         }
 396 +
 397 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 398 +       retval = register_chrdev(XHCI_MTK_TEST_MAJOR, DEVICE_NAME, &xhci_mtk_test_fops);
 399 +
 400 +       u3phy_init();
 401 +       if (u3phy_ops->u2_slew_rate_calibration) {
 402 +                u3phy_ops->u2_slew_rate_calibration(u3phy);
 403 +                u3phy_ops->u2_slew_rate_calibration(u3phy_p1);
 404 +        }
 405 +        else{
 406 +                printk(KERN_ERR "WARN: PHY doesn't implement u2 slew rate calibration function\n");
 407 +        }
 408 +        u3phy_ops->init(u3phy);
 409 +       reinitIP();
 410 +
 411 +       pPlatformDev = &xhci_platform_dev;
 412 +       memset(pPlatformDev, 0, sizeof(struct platform_device));
 413 +       pPlatformDev->name = "xhci-hcd";
 414 +       pPlatformDev->id = -1;
 415 +       pPlatformDev->dev.coherent_dma_mask = 0xffffffff;
 416 +       pPlatformDev->dev.dma_mask = &pPlatformDev->dev.coherent_dma_mask;
 417 +
 418 +       retval = platform_device_register(&xhci_platform_dev);
 419 +       if (retval < 0)
 420 +               xhci_unregister_plat();
 421 +#endif
 422 +
 423         /*
 424          * Check the compiler generated sizes of structures that must be laid
 425          * out in specific ways for hardware access.
 426 @@ -4786,6 +4980,7 @@ static int __init xhci_hcd_init(void)
 427         BUILD_BUG_ON(sizeof(struct xhci_intr_reg) != 8*32/8);
 428         /* xhci_run_regs has eight fields and embeds 128 xhci_intr_regs */
 429         BUILD_BUG_ON(sizeof(struct xhci_run_regs) != (8+8*128)*32/8);
 430 +
 431         return 0;
 432  unreg_pci:
 433         xhci_unregister_pci();
 434 --- a/drivers/usb/host/xhci-dbg.c
 435 +++ b/drivers/usb/host/xhci-dbg.c
 436 @@ -21,6 +21,9 @@
 437   */
 438
 439  #include "xhci.h"
 440 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 441 +#include "xhci-mtk.h"
 442 +#endif
 443
 444  #define XHCI_INIT_VALUE 0x0
 445
 446 --- a/drivers/usb/host/xhci.h
 447 +++ b/drivers/usb/host/xhci.h
 448 @@ -29,9 +29,24 @@
 449  #include <linux/usb/hcd.h>
 450
 451  /* Code sharing between pci-quirks and xhci hcd */
 452 -#include       "xhci-ext-caps.h"
 453 +#include "xhci-ext-caps.h"
 454  #include "pci-quirks.h"
 455
 456 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 457 +#define XHC_IRQ (22 + 8)
 458 +#define XHC_IO_START 0x1E1C0000
 459 +#define XHC_IO_LENGTH 0x10000
 460 +/* mtk scheduler bitmasks */
 461 +#define BPKTS(p)       ((p) & 0x3f)
 462 +#define BCSCOUNT(p)    (((p) & 0x7) << 8)
 463 +#define BBM(p)         ((p) << 11)
 464 +#define BOFFSET(p)     ((p) & 0x3fff)
 465 +#define BREPEAT(p)     (((p) & 0x7fff) << 16)
 466 +#endif
 467 +
 468 +
 469 +
 470 +
 471  /* xHCI PCI Configuration Registers */
 472  #define XHCI_SBRN_OFFSET       (0x60)
 473
 474 @@ -1536,8 +1551,12 @@ struct xhci_hcd {
 475         /* Compliance Mode Recovery Data */
 476         struct timer_list       comp_mode_recovery_timer;
 477         u32                     port_status_u0;
 478 +#ifdef CONFIG_USB_MT7621_XHCI_PLATFORM
 479 +#define COMP_MODE_RCVRY_MSECS 5000
 480 +#else
 481  /* Compliance Mode Timer Triggered every 2 seconds */
 482  #define COMP_MODE_RCVRY_MSECS 2000
 483 +#endif
 484  };
 485
 486  /* convert between an HCD pointer and the corresponding EHCI_HCD */
 487 @@ -1703,7 +1722,7 @@ void xhci_urb_free_priv(struct xhci_hcd
 488  void xhci_free_command(struct xhci_hcd *xhci,
 489                 struct xhci_command *command);
 490
 491 -#ifdef CONFIG_PCI
 492 +#if defined (CONFIG_PCI) && !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 493  /* xHCI PCI glue */
 494  int xhci_register_pci(void);
 495  void xhci_unregister_pci(void);
 496 --- a/drivers/usb/host/xhci-mem.c
 497 +++ b/drivers/usb/host/xhci-mem.c
 498 @@ -65,6 +65,9 @@ static struct xhci_segment *xhci_segment
 499
 500  static void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg)
 501  {
 502 +       if (!seg)
 503 +               return;
 504 +
 505         if (seg->trbs) {
 506                 dma_pool_free(xhci->segment_pool, seg->trbs, seg->dma);
 507                 seg->trbs = NULL;
 508 @@ -1446,9 +1449,17 @@ int xhci_endpoint_init(struct xhci_hcd *
 509                         max_burst = (usb_endpoint_maxp(&ep->desc)
 510                                      & 0x1800) >> 11;
 511                 }
 512 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 513 +               if ((max_packet % 4 == 2) && (max_packet % 16 != 14) && (max_burst == 0) && usb_endpoint_dir_in(&ep->desc))
 514 +               max_packet += 2;
 515 +#endif
 516                 break;
 517         case USB_SPEED_FULL:
 518         case USB_SPEED_LOW:
 519 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 520 +               if ((max_packet % 4 == 2) && (max_packet % 16 != 14) && (max_burst == 0) && usb_endpoint_dir_in(&ep->desc))
 521 +               max_packet += 2;
 522 +#endif
 523                 break;
 524         default:
 525                 BUG();
 526 --- a/drivers/usb/host/xhci-plat.c
 527 +++ b/drivers/usb/host/xhci-plat.c
 528 @@ -25,6 +25,13 @@ static void xhci_plat_quirks(struct devi
 529          * dev struct in order to setup MSI
 530          */
 531         xhci->quirks |= XHCI_PLAT;
 532 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 533 +       /* MTK host controller gives a spurious successful event after a
 534 +        * short transfer. Ignore it.
 535 +        */
 536 +       xhci->quirks |= XHCI_SPURIOUS_SUCCESS;
 537 +       xhci->quirks |= XHCI_LPM_SUPPORT;
 538 +#endif
 539  }
 540
 541  /* called during probe() after chip reset completes */
 542 @@ -96,20 +103,32 @@ static int xhci_plat_probe(struct platfo
 543
 544         driver = &xhci_plat_xhci_driver;
 545
 546 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 547 +       irq = XHC_IRQ;
 548 +#else
 549         irq = platform_get_irq(pdev, 0);
 550 +#endif
 551 +
 552         if (irq < 0)
 553                 return -ENODEV;
 554
 555 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 556         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 557         if (!res)
 558                 return -ENODEV;
 559 +#endif
 560
 561         hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
 562         if (!hcd)
 563                 return -ENOMEM;
 564
 565 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 566 +       hcd->rsrc_start = (uint32_t)XHC_IO_START;
 567 +       hcd->rsrc_len = XHC_IO_LENGTH;
 568 +#else
 569         hcd->rsrc_start = res->start;
 570         hcd->rsrc_len = resource_size(res);
 571 +#endif
 572
 573         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
 574                                 driver->description)) {
 575 --- a/drivers/usb/host/xhci-ring.c
 576 +++ b/drivers/usb/host/xhci-ring.c
 577 @@ -236,7 +236,6 @@ static void inc_enq(struct xhci_hcd *xhc
 578                          */
 579                         if (!chain && !more_trbs_coming)
 580                                 break;
 581 -
 582                         /* If we're not dealing with 0.95 hardware or
 583                          * isoc rings on AMD 0.96 host,
 584                          * carry over the chain bit of the previous TRB
 585 @@ -273,16 +272,20 @@ static void inc_enq(struct xhci_hcd *xhc
 586  static inline int room_on_ring(struct xhci_hcd *xhci, struct xhci_ring *ring,
 587                 unsigned int num_trbs)
 588  {
 589 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 590         int num_trbs_in_deq_seg;
 591 +#endif
 592
 593         if (ring->num_trbs_free < num_trbs)
 594                 return 0;
 595
 596 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 597         if (ring->type != TYPE_COMMAND && ring->type != TYPE_EVENT) {
 598                 num_trbs_in_deq_seg = ring->dequeue - ring->deq_seg->trbs;
 599                 if (ring->num_trbs_free < num_trbs + num_trbs_in_deq_seg)
 600                         return 0;
 601         }
 602 +#endif
 603
 604         return 1;
 605  }
 606 @@ -2910,6 +2913,7 @@ static int prepare_ring(struct xhci_hcd
 607                 next = ring->enqueue;
 608
 609                 while (last_trb(xhci, ring, ring->enq_seg, next)) {
 610 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 611                         /* If we're not dealing with 0.95 hardware or isoc rings
 612                          * on AMD 0.96 host, clear the chain bit.
 613                          */
 614 @@ -2919,7 +2923,9 @@ static int prepare_ring(struct xhci_hcd
 615                                 next->link.control &= cpu_to_le32(~TRB_CHAIN);
 616                         else
 617                                 next->link.control |= cpu_to_le32(TRB_CHAIN);
 618 -
 619 +#else
 620 +                       next->link.control &= cpu_to_le32(~TRB_CHAIN);
 621 +#endif
 622                         wmb();
 623                         next->link.control ^= cpu_to_le32(TRB_CYCLE);
 624
 625 @@ -3049,6 +3055,9 @@ static void giveback_first_trb(struct xh
 626                 start_trb->field[3] |= cpu_to_le32(start_cycle);
 627         else
 628                 start_trb->field[3] &= cpu_to_le32(~TRB_CYCLE);
 629 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 630 +       wmb();
 631 +#endif
 632         xhci_ring_ep_doorbell(xhci, slot_id, ep_index, stream_id);
 633  }
 634
 635 @@ -3108,6 +3117,29 @@ static u32 xhci_td_remainder(unsigned in
 636                 return (remainder >> 10) << 17;
 637  }
 638
 639 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 640 +static u32 mtk_xhci_td_remainder(unsigned int td_transfer_size, unsigned int td_running_total, unsigned int maxp, unsigned trb_buffer_length)
 641 +{
 642 +       u32 max = 31;
 643 +       int remainder, td_packet_count, packet_transferred;
 644 +
 645 +       //0 for the last TRB
 646 +       //FIXME: need to workaround if there is ZLP in this TD
 647 +       if (td_running_total + trb_buffer_length == td_transfer_size)
 648 +               return 0;
 649 +
 650 +       //FIXME: need to take care of high-bandwidth (MAX_ESIT)
 651 +       packet_transferred = (td_running_total /*+ trb_buffer_length*/) / maxp;
 652 +       td_packet_count = DIV_ROUND_UP(td_transfer_size, maxp);
 653 +       remainder = td_packet_count - packet_transferred;
 654 +
 655 +       if (remainder > max)
 656 +               return max << 17;
 657 +       else
 658 +               return remainder << 17;
 659 +}
 660 +#endif
 661 +
 662  /*
 663   * For xHCI 1.0 host controllers, TD size is the number of max packet sized
 664   * packets remaining in the TD (*not* including this TRB).
 665 @@ -3245,6 +3277,7 @@ static int queue_bulk_sg_tx(struct xhci_
 666                 }
 667
 668                 /* Set the TRB length, TD size, and interrupter fields. */
 669 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 670                 if (xhci->hci_version < 0x100) {
 671                         remainder = xhci_td_remainder(
 672                                         urb->transfer_buffer_length -
 673 @@ -3254,6 +3287,13 @@ static int queue_bulk_sg_tx(struct xhci_
 674                                         trb_buff_len, total_packet_count, urb,
 675                                         num_trbs - 1);
 676                 }
 677 +#else
 678 +               if (num_trbs > 1)
 679 +                       remainder = mtk_xhci_td_remainder(urb->transfer_buffer_length,
 680 +                               running_total, urb->ep->desc.wMaxPacketSize, trb_buff_len);
 681 +#endif
 682 +
 683 +
 684                 length_field = TRB_LEN(trb_buff_len) |
 685                         remainder |
 686                         TRB_INTR_TARGET(0);
 687 @@ -3316,6 +3356,9 @@ int xhci_queue_bulk_tx(struct xhci_hcd *
 688         int running_total, trb_buff_len, ret;
 689         unsigned int total_packet_count;
 690         u64 addr;
 691 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 692 +       int max_packet;
 693 +#endif
 694
 695         if (urb->num_sgs)
 696                 return queue_bulk_sg_tx(xhci, mem_flags, urb, slot_id, ep_index);
 697 @@ -3341,6 +3384,25 @@ int xhci_queue_bulk_tx(struct xhci_hcd *
 698                 running_total += TRB_MAX_BUFF_SIZE;
 699         }
 700         /* FIXME: this doesn't deal with URB_ZERO_PACKET - need one more */
 701 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 702 +       switch(urb->dev->speed){
 703 +               case USB_SPEED_SUPER:
 704 +                       max_packet = urb->ep->desc.wMaxPacketSize;
 705 +                       break;
 706 +               case USB_SPEED_HIGH:
 707 +               case USB_SPEED_FULL:
 708 +               case USB_SPEED_LOW:
 709 +               case USB_SPEED_WIRELESS:
 710 +               case USB_SPEED_UNKNOWN:
 711 +               default:
 712 +                       max_packet = urb->ep->desc.wMaxPacketSize & 0x7ff;
 713 +                       break;
 714 +       }
 715 +       if((urb->transfer_flags & URB_ZERO_PACKET)
 716 +               && ((urb->transfer_buffer_length % max_packet) == 0)){
 717 +               num_trbs++;
 718 +       }
 719 +#endif
 720
 721         ret = prepare_transfer(xhci, xhci->devs[slot_id],
 722                         ep_index, urb->stream_id,
 723 @@ -3400,6 +3462,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *
 724                         field |= TRB_ISP;
 725
 726                 /* Set the TRB length, TD size, and interrupter fields. */
 727 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 728                 if (xhci->hci_version < 0x100) {
 729                         remainder = xhci_td_remainder(
 730                                         urb->transfer_buffer_length -
 731 @@ -3409,6 +3472,10 @@ int xhci_queue_bulk_tx(struct xhci_hcd *
 732                                         trb_buff_len, total_packet_count, urb,
 733                                         num_trbs - 1);
 734                 }
 735 +#else
 736 +               remainder = mtk_xhci_td_remainder(urb->transfer_buffer_length, running_total, max_packet, trb_buff_len);
 737 +#endif
 738 +
 739                 length_field = TRB_LEN(trb_buff_len) |
 740                         remainder |
 741                         TRB_INTR_TARGET(0);
 742 @@ -3498,7 +3565,11 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *
 743                 field |= 0x1;
 744
 745         /* xHCI 1.0 6.4.1.2.1: Transfer Type field */
 746 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 747 +       if (1) {
 748 +#else
 749         if (xhci->hci_version == 0x100) {
 750 +#endif
 751                 if (urb->transfer_buffer_length > 0) {
 752                         if (setup->bRequestType & USB_DIR_IN)
 753                                 field |= TRB_TX_TYPE(TRB_DATA_IN);
 754 @@ -3522,7 +3593,12 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *
 755                 field = TRB_TYPE(TRB_DATA);
 756
 757         length_field = TRB_LEN(urb->transfer_buffer_length) |
 758 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 759                 xhci_td_remainder(urb->transfer_buffer_length) |
 760 +#else
 761 +               //CC: MTK style, no scatter-gather for control transfer
 762 +               0 |
 763 +#endif
 764                 TRB_INTR_TARGET(0);
 765         if (urb->transfer_buffer_length > 0) {
 766                 if (setup->bRequestType & USB_DIR_IN)
 767 @@ -3533,7 +3609,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *
 768                                 length_field,
 769                                 field | ep_ring->cycle_state);
 770         }
 771 -
 772 +
 773         /* Save the DMA address of the last TRB in the TD */
 774         td->last_trb = ep_ring->enqueue;
 775
 776 @@ -3645,6 +3721,9 @@ static int xhci_queue_isoc_tx(struct xhc
 777         u64 start_addr, addr;
 778         int i, j;
 779         bool more_trbs_coming;
 780 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 781 +       int max_packet;
 782 +#endif
 783
 784         ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
 785
 786 @@ -3658,6 +3737,21 @@ static int xhci_queue_isoc_tx(struct xhc
 787         start_trb = &ep_ring->enqueue->generic;
 788         start_cycle = ep_ring->cycle_state;
 789
 790 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 791 +       switch(urb->dev->speed){
 792 +               case USB_SPEED_SUPER:
 793 +                       max_packet = urb->ep->desc.wMaxPacketSize;
 794 +                       break;
 795 +               case USB_SPEED_HIGH:
 796 +               case USB_SPEED_FULL:
 797 +               case USB_SPEED_LOW:
 798 +               case USB_SPEED_WIRELESS:
 799 +               case USB_SPEED_UNKNOWN:
 800 +                       max_packet = urb->ep->desc.wMaxPacketSize & 0x7ff;
 801 +                       break;
 802 +       }
 803 +#endif
 804 +
 805         urb_priv = urb->hcpriv;
 806         /* Queue the first TRB, even if it's zero-length */
 807         for (i = 0; i < num_tds; i++) {
 808 @@ -3729,9 +3823,13 @@ static int xhci_queue_isoc_tx(struct xhc
 809                         } else {
 810                                 td->last_trb = ep_ring->enqueue;
 811                                 field |= TRB_IOC;
 812 +#if defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 813 +                               if (!(xhci->quirks & XHCI_AVOID_BEI)) {
 814 +#else
 815                                 if (xhci->hci_version == 0x100 &&
 816                                                 !(xhci->quirks &
 817                                                         XHCI_AVOID_BEI)) {
 818 +#endif
 819                                         /* Set BEI bit except for the last td */
 820                                         if (i < num_tds - 1)
 821                                                 field |= TRB_BEI;
 822 @@ -3746,6 +3844,7 @@ static int xhci_queue_isoc_tx(struct xhc
 823                                 trb_buff_len = td_remain_len;
 824
 825                         /* Set the TRB length, TD size, & interrupter fields. */
 826 +#if !defined (CONFIG_USB_MT7621_XHCI_PLATFORM)
 827                         if (xhci->hci_version < 0x100) {
 828                                 remainder = xhci_td_remainder(
 829                                                 td_len - running_total);
 830 @@ -3755,6 +3854,10 @@ static int xhci_queue_isoc_tx(struct xhc
 831                                                 total_packet_count, urb,
 832                                                 (trbs_per_td - j - 1));
 833                         }
 834 +#else
 835 +                       remainder = mtk_xhci_td_remainder(urb->transfer_buffer_length, running_total, max_packet, trb_buff_len);
 836 +#endif
 837 +
 838                         length_field = TRB_LEN(trb_buff_len) |
 839                                 remainder |
 840                                 TRB_INTR_TARGET(0);