diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c old mode 100644 new mode 100755 index 9e7742f..277b91a --- a/arch/arm/mm/dma-mapping.c +++ b/arch/arm/mm/dma-mapping.c @@ -381,7 +381,8 @@ EXPORT_SYMBOL(dma_mmap_writecombine); */ void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr, dma_addr_t handle) { - WARN_ON(irqs_disabled()); +/// HCD_LOCAL_MEM: WARNING: at arch/arm/mm/dma-mapping.c:408 dma_free_coherent +/// WARN_ON(irqs_disabled()); if (dma_release_from_coherent(dev, get_order(size), cpu_addr)) return; diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig index 6a58cb1..726c1cc 100644 --- a/drivers/usb/Kconfig +++ b/drivers/usb/Kconfig @@ -60,6 +60,9 @@ config USB_ARCH_HAS_EHCI default y if PPC_83xx default y if SOC_AU1200 default y if ARCH_IXP4XX + default y if ARCH_MSM7XXX + default y if ARCH_MSM + default y if ARCH_MSM7X00A default y if ARCH_W90X900 default y if ARCH_AT91SAM9G45 default y if ARCH_MXC diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig index f865be2..a0eeb9f 100644 --- a/drivers/usb/host/Kconfig +++ b/drivers/usb/host/Kconfig @@ -123,6 +123,13 @@ config USB_EHCI_MXC ---help--- Variation of ARC USB block used in some Freescale chips. +config USB_EHCI_MSM7201 + bool "Support for Qualcomm MSM7201/QSD8X50 on-chip EHCI USB controller" + depends on USB_EHCI_HCD && (ARCH_MSM7XXX || ARCH_MSM || ARCH_MSM7X00A) && (!USB_FUNCTION) + select USB_EHCI_ROOT_HUB_TT + ---help--- + Variation of ARC USB block used in Qualcomm MSM7201/QSD8X50 chips. + config USB_EHCI_HCD_PPC_OF bool "EHCI support for PPC USB controller on OF platform bus" depends on USB_EHCI_HCD && PPC_OF diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c old mode 100644 new mode 100755 index a3ef2a9..4f0c111 --- a/drivers/usb/host/ehci-hcd.c +++ b/drivers/usb/host/ehci-hcd.c @@ -1148,6 +1148,18 @@ MODULE_LICENSE ("GPL"); #define PLATFORM_DRIVER ixp4xx_ehci_driver #endif + +#ifdef CONFIG_USB_EHCI_MSM7201 +#include "ehci-msm7201.c" +#define PLATFORM_DRIVER ehci_msm7201_driver + +#ifdef DEBUG +#undef DEBUG +#endif + +#endif + + #ifdef CONFIG_USB_W90X900_EHCI #include "ehci-w90x900.c" #define PLATFORM_DRIVER ehci_hcd_w90x900_driver diff --git a/drivers/usb/host/ehci-msm7201.c b/drivers/usb/host/ehci-msm7201.c new file mode 100644 index 0000000..af30ab3 --- /dev/null +++ b/drivers/usb/host/ehci-msm7201.c @@ -0,0 +1,399 @@ +/* + * Nexus One support added by Sven Killig + * + * Copyright (c) 2010 Andrew de Quincey + * + * (heavily) based on ehci-fsl.c, which is: + * + * Copyright (c) 2005 MontaVista Software + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * Ported to 834x by Randy Vinson using code provided + * by Hunter Wu. + */ + +#include +#include +#include + +#include "ehci-msm7201.h" + + +static void ulpi_write(struct usb_hcd *hcd, unsigned val, unsigned reg) +{ + unsigned timeout = 10000; + + /* initiate write operation */ + writel(ULPI_RUN | ULPI_WRITE | + ULPI_ADDR(reg) | ULPI_DATA(val), + USB_ULPI_VIEWPORT); + + /* wait for completion */ + while ((readl(USB_ULPI_VIEWPORT) & ULPI_RUN) && (--timeout)) ; + + if (timeout == 0) + printk(KERN_WARNING "%s: timeout: reg: 0x%X, var: 0x%X\n", + __func__, reg, val); +} + +static void msm7201_setup_phy(struct usb_hcd *hcd) +{ + struct msm7201_usb_priv *msm7201 = hcd_to_msm7201(hcd); + + int *seq = msm7201->phy_init_seq; + + if (!seq) + return; + + while (seq[0] >= 0) { + ulpi_write(hcd, seq[0], seq[1]); + seq += 2; + } +} + +static void msm7201_shutdown_phy(struct usb_hcd *hcd) +{ + struct msm7201_usb_priv *msm7201 = hcd_to_msm7201(hcd); + + if (msm7201->phy_shutdown) + msm7201->phy_shutdown(); + + /* disable interface protect circuit to drop current consumption */ + ulpi_write(hcd, (1 << 7), 0x08); + /* clear the SuspendM bit -> suspend the PHY */ + ulpi_write(hcd, ULPI_FUNC_SUSPENDM, ULPI_FUNC_CTRL_CLR); +} + +static void msm7201_usb_setup(struct usb_hcd *hcd) +{ + struct msm7201_usb_priv *msm7201 = hcd_to_msm7201(hcd); + +#ifdef CONFIG_ARCH_QSD8X50 + /* bursts of unspecified length. */ + writel(0x0, USB_AHBBURST); + /* Use the AHB transactor */ + writel(0x0, USB_AHBMODE); +#else + /* INCR8 BURST mode */ + writel(0x02, USB_SBUSCFG); /*boost performance to fix CRC error.*/ +#endif + + /* select ULPI phy */ + writel(0x80000000, USB_PORTSC); + + if (msm7201->phy_reset) + msm7201->phy_reset(); + msm7201_setup_phy(hcd); +} + +/* called after powerup, by probe or system-pm "wakeup" */ +static int ehci_msm7201_reinit(struct ehci_hcd *ehci) +{ + msm7201_usb_setup(ehci_to_hcd(ehci)); + ehci_port_power(ehci, 0); + + return 0; +} + +/* called during probe() after chip reset completes */ +static int ehci_msm7201_setup(struct usb_hcd *hcd) +{ + struct ehci_hcd *ehci = hcd_to_ehci(hcd); + int retval; + + ehci->caps = USB_CAPLENGTH; + ehci->regs = USB_CAPLENGTH + + HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase)); + + /* configure other settings */ + ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params); + hcd->has_tt = 1; + ehci->sbrn = HCD_USB2; + + /* reset and halt controller */ + ehci_reset(ehci); + retval = ehci_halt(ehci); + if (retval) + return retval; + + /* data structure init */ + retval = ehci_init(hcd); + if (retval) + return retval; + + ehci_reset(ehci); + + retval = ehci_msm7201_reinit(ehci); + return retval; +} + + +// mainly a copy of ehci_run(), can perhaps be reduced: +static int ehci_msm_run(struct usb_hcd *hcd) +{ + struct ehci_hcd *ehci = hcd_to_ehci(hcd); + int retval = 0; + int port = HCS_N_PORTS(ehci->hcs_params); + u32 __iomem *reg_ptr; + u32 hcc_params; + + hcd->uses_new_polling = 1; + hcd->poll_rh = 0; + + /* set hostmode */ + reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE); + ehci_writel(ehci, (USBMODE_VBUS | USBMODE_SDIS), reg_ptr); + + /* port configuration - phy, port speed, port power, port enable */ + while (port--) + ehci_writel(ehci, (PORTSC_PTS_ULPI | PORT_POWER | + PORT_PE), &ehci->regs->port_status[port]); + + ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list); + ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next); + + hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params); + if (HCC_64BIT_ADDR(hcc_params)) + ehci_writel(ehci, 0, &ehci->regs->segment); + + ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET); + ehci->command |= CMD_RUN; + ehci_writel(ehci, ehci->command, &ehci->regs->command); + + /* + * Start, enabling full USB 2.0 functionality ... usb 1.1 devices + * are explicitly handed to companion controller(s), so no TT is + * involved with the root hub. (Except where one is integrated, + * and there's no companion controller unless maybe for USB OTG.) + * + * Turning on the CF flag will transfer ownership of all ports + * from the companions to the EHCI controller. If any of the + * companions are in the middle of a port reset at the time, it + * could cause trouble. Write-locking ehci_cf_port_reset_rwsem + * guarantees that no resets are in progress. After we set CF, + * a short delay lets the hardware catch up; new resets shouldn't + * be started before the port switching actions could complete. + */ + + down_write(&ehci_cf_port_reset_rwsem); + hcd->state = HC_STATE_RUNNING; + ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag); + ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */ + msleep(5); + up_write(&ehci_cf_port_reset_rwsem); + + /*Enable appropriate Interrupts*/ + ehci_writel(ehci, INTR_MASK, + &ehci->regs->intr_enable); + + return retval; +} + + +static const struct hc_driver ehci_msm7201_hc_driver = { + .description = hcd_name, + .product_desc = "Qualcomm MSM7201/QSD8X50 On-Chip EHCI Host Controller", + .hcd_priv_size = sizeof(struct ehci_hcd) + sizeof(struct msm7201_usb_priv), + + /* + * generic hardware linkage + */ + .irq = ehci_irq, + .flags = HCD_USB2 | HCD_MEMORY | HCD_LOCAL_MEM, + + /* + * basic lifecycle operations + */ + .reset = ehci_msm7201_setup, + .start = ehci_msm_run, + .stop = ehci_stop, + .shutdown = ehci_shutdown, + + /* + * managing i/o requests and associated device resources + */ + .urb_enqueue = ehci_urb_enqueue, + .urb_dequeue = ehci_urb_dequeue, + .endpoint_disable = ehci_endpoint_disable, + + /* + * scheduling support + */ + .get_frame_number = ehci_get_frame, + + /* + * root hub support + */ + .hub_status_data = ehci_hub_status_data, + .hub_control = ehci_hub_control, + .bus_suspend = ehci_bus_suspend, + .bus_resume = ehci_bus_resume, + .relinquish_port = ehci_relinquish_port, + .port_handed_over = ehci_port_handed_over, + // maybe neccessary: + //.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, +}; + +/** + * usb_hcd_msm7201_remove - shutdown processing for MSM7201-based HCDs + * @pdev: USB Host Controller being removed + * Context: !in_interrupt() + * + * Reverses the effect of usb_hcd_msm7201_probe(). + * + */ +static int usb_hcd_msm7201_remove(struct platform_device *pdev) +{ + struct usb_hcd *hcd = platform_get_drvdata(pdev); + struct msm7201_usb_priv *msm7201 = hcd_to_msm7201(hcd); + + usb_remove_hcd(hcd); + msm7201_shutdown_phy(hcd); + clk_put(msm7201->clk); + clk_put(msm7201->pclk); + iounmap(hcd->regs); + release_mem_region(hcd->rsrc_start, hcd->rsrc_len); + usb_put_hcd(hcd); + + return 0; +} + +/** + * usb_hcd_msm7201_probe - initialize MSM7201-based HCDs + * @pdev: USB Host Controller being probed + * Context: !in_interrupt() + * + * Allocates basic resources for this USB host controller. + * + */ +static int usb_hcd_msm7201_probe(struct platform_device *pdev) +{ + struct usb_hcd *hcd; + struct resource *res; + struct msm7201_usb_priv *msm7201; + int irq; + int retval; + const struct hc_driver *driver = &ehci_msm7201_hc_driver; + struct msm_hsusb_platform_data *pdata = pdev->dev.platform_data; + + if (usb_disabled()) + return -ENODEV; + + pr_debug("initializing MSM7201/QSD8X50 USB Controller\n"); + + irq = platform_get_irq(pdev, 0); + if (irq < 0) { + dev_err(&pdev->dev, "irq < 0. Check %s setup!\n", dev_name(&pdev->dev)); + return -ENODEV; + } + + hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev)); + if (!hcd) { + retval = -ENOMEM; + goto err1; + } + + msm7201 = hcd_to_msm7201(hcd); + if (pdata) { + msm7201->phy_reset = pdata->phy_reset; +#ifndef CONFIG_ARCH_QSD8X50 + msm7201->phy_shutdown = pdata->phy_shutdown; +#endif + msm7201->phy_init_seq = pdata->phy_init_seq; + } + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!res) { + dev_err(&pdev->dev, + "Found HC with no register addr. Check %s setup!\n", + dev_name(&pdev->dev)); + retval = -ENODEV; + goto err2; + } + hcd->rsrc_start = res->start; + hcd->rsrc_len = res->end - res->start + 1; + if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, + driver->description)) { + dev_dbg(&pdev->dev, "controller already in use\n"); + retval = -EBUSY; + goto err2; + } + hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); + + if (hcd->regs == NULL) { + dev_dbg(&pdev->dev, "error mapping memory\n"); + retval = -EFAULT; + goto err3; + } + + msm7201->clk = clk_get(&pdev->dev, "usb_hs_clk"); + if (IS_ERR(msm7201->clk)) { + dev_dbg(&pdev->dev, "error getting usb_hs_clk\n"); + retval = -EFAULT; + goto err4; + } + + msm7201->pclk = clk_get(&pdev->dev, "usb_hs_pclk"); + if (IS_ERR(msm7201->pclk)) { + dev_dbg(&pdev->dev, "error getting usb_hs_pclk\n"); + retval = -EFAULT; + goto err5; + } + + clk_enable(msm7201->clk); + clk_enable(msm7201->pclk); + + /* wait for a while after enable usb clk*/ + msleep(5); + + /* clear interrupts before requesting irq */ + writel(0, USB_USBINTR); + writel(0, USB_OTGSC); + disable_irq(irq); + retval = usb_add_hcd(hcd, irq, IRQF_SHARED); + enable_irq(irq); // Unbalanced (?) + /* enable interrupts */ + writel(STS_URI | STS_SLI | STS_UI | STS_PCI, USB_USBINTR); + + if (retval != 0) + goto err6; + return retval; + + err6: + clk_put(msm7201->pclk); + err5: + clk_put(msm7201->clk); + err4: + iounmap(hcd->regs); + err3: + release_mem_region(hcd->rsrc_start, hcd->rsrc_len); + err2: + usb_put_hcd(hcd); + err1: + dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval); + return retval; +} + +MODULE_ALIAS("platform:msm_hsusb"); + +static struct platform_driver ehci_msm7201_driver = { + .probe = usb_hcd_msm7201_probe, + .remove = usb_hcd_msm7201_remove, + .shutdown = usb_hcd_platform_shutdown, + .driver = { + .name = "msm_hsusb", + }, +}; diff --git a/drivers/usb/host/ehci-msm7201.h b/drivers/usb/host/ehci-msm7201.h new file mode 100644 index 0000000..a54d689 --- /dev/null +++ b/drivers/usb/host/ehci-msm7201.h @@ -0,0 +1,53 @@ +/* + * Nexus One support added by Sven Killig + * + * Copyright (c) 2010 Andrew de Quincey + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#ifndef _EHCI_MSM7201_H +#define _EHCI_MSM7201_H + +struct msm7201_usb_priv +{ + struct clk *clk; + struct clk *pclk; + + int *phy_init_seq; + void (*phy_reset)(void); + void (*phy_shutdown)(void); +}; + +static inline struct msm7201_usb_priv *hcd_to_msm7201(struct usb_hcd *hcd) +{ + return (struct msm7201_usb_priv *) (((unsigned char*) (hcd->hcd_priv)) + sizeof(struct ehci_hcd)); +} + +#define MSM_USB_BASE (hcd->regs) + + +#include + + +#define USBMODE_VBUS (1 << 5) /* vbus power select */ + +/* Redefining SDIS bit as it defined incorrectly in ehci.h. */ +#ifdef USBMODE_SDIS +#undef USBMODE_SDIS +#endif +#define USBMODE_SDIS (1 << 4) /* stream disable */ + + +#endif /* _EHCI_MSM7201_H */ diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c old mode 100644 new mode 100755 diff --git a/drivers/video/msm/msm_fb.c b/drivers/video/msm/msm_fb.c old mode 100644 new mode 100755 index a21a44a..90c122b --- a/drivers/video/msm/msm_fb.c +++ b/drivers/video/msm/msm_fb.c @@ -249,18 +249,18 @@ restart: /* if we are sleeping, on a pan_display wait 10ms (to throttle back * drawing otherwise return */ - if (msmfb->sleeping == SLEEPING) { +/* if (msmfb->sleeping == SLEEPING) { DLOG(SUSPEND_RESUME, "drawing while asleep\n"); spin_unlock_irqrestore(&msmfb->update_lock, irq_flags); if (pan_display) wait_event_interruptible_timeout(msmfb->frame_wq, msmfb->sleeping != SLEEPING, HZ/10); return; - } + }*/ sleeping = msmfb->sleeping; /* on a full update, if the last frame has not completed, wait for it */ - if ((pan_display && msmfb->frame_requested != msmfb->frame_done) || +/* if ((pan_display && msmfb->frame_requested != msmfb->frame_done) || sleeping == UPDATING) { int ret; spin_unlock_irqrestore(&msmfb->update_lock, irq_flags); @@ -286,7 +286,7 @@ restart: } } goto restart; - } + }*/ #if PRINT_FPS t2 = ktime_get(); @@ -336,7 +336,7 @@ restart: /* if the panel is all the way on wait for vsync, otherwise sleep * for 16 ms (long enough for the dma to panel) and then begin dma */ - msmfb->vsync_request_time = ktime_get(); +/* msmfb->vsync_request_time = ktime_get(); if (panel->request_vsync && (sleeping == AWAKE)) { wake_lock_timeout(&msmfb->idle_lock, HZ/4); panel->request_vsync(panel, &msmfb->vsync_callback); @@ -346,7 +346,7 @@ restart: ktime_set(0, NSEC_PER_SEC/60), HRTIMER_MODE_REL); } - } + }*/ } static void msmfb_update(struct fb_info *info, uint32_t left, uint32_t top, diff --git a/kernel/sched.c b/kernel/sched.c old mode 100644 new mode 100755 index 6d225f6..1835251 --- a/kernel/sched.c +++ b/kernel/sched.c @@ -3519,8 +3519,9 @@ static inline void schedule_debug(struct task_struct *prev) * schedule() atomically, we ignore that path for now. * Otherwise, whine if we are scheduling when we should not be. */ - if (unlikely(in_atomic_preempt_off() && !prev->exit_state)) - __schedule_bug(prev); +/// http://sven.killig.de/android/Galaxy/scheduling%20while%20atomic.txt +/* if (unlikely(in_atomic_preempt_off() && !prev->exit_state)) + __schedule_bug(prev);*/ profile_hit(SCHED_PROFILING, __builtin_return_address(0));