tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f9cc65cfda
M7350/kernel/drivers/usb/gadget/msm72k_udc.c

2980 lines
72 KiB
C
Raw Normal View History

M7350v1_en_gpl
2024-09-09 08:52:07 +00:00
/*
* Driver for HighSpeed USB Client Controller in MSM7K
*
* Copyright (C) 2008 Google, Inc.
* Copyright (c) 2009-2013, The Linux Foundation. All rights reserved.
* Author: Mike Lockwood <lockwood@android.com>
* Brian Swetland <swetland@google.com>
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* 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.
*
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/dmapool.h>
#include <linux/platform_device.h>
#include <linux/debugfs.h>
#include <linux/workqueue.h>
#include <linux/switch.h>
#include <linux/pm_runtime.h>
#include <mach/msm72k_otg.h>
#include <linux/io.h>
#include <asm/mach-types.h>
#include <mach/board.h>
#include <mach/msm_hsusb.h>
#include <linux/device.h>
#include <mach/msm_hsusb_hw.h>
#include <mach/clk.h>
#include <linux/uaccess.h>
#include <linux/wakelock.h>
static const char driver_name[] = "msm72k_udc";
/* #define DEBUG */
/* #define VERBOSE */
#define MSM_USB_BASE ((unsigned) ui->addr)
#define DRIVER_DESC "MSM 72K USB Peripheral Controller"
#define DRIVER_NAME "MSM72K_UDC"
#define EPT_FLAG_IN 0x0001
#define SETUP_BUF_SIZE 8
static const char *const ep_name[] = {
"ep0out", "ep1out", "ep2out", "ep3out",
"ep4out", "ep5out", "ep6out", "ep7out",
"ep8out", "ep9out", "ep10out", "ep11out",
"ep12out", "ep13out", "ep14out", "ep15out",
"ep0in", "ep1in", "ep2in", "ep3in",
"ep4in", "ep5in", "ep6in", "ep7in",
"ep8in", "ep9in", "ep10in", "ep11in",
"ep12in", "ep13in", "ep14in", "ep15in"
};
/*To release the wakelock from debugfs*/
static int release_wlocks;
struct msm_request {
struct usb_request req;
/* saved copy of req.complete */
void (*gadget_complete)(struct usb_ep *ep,
struct usb_request *req);
struct usb_info *ui;
struct msm_request *next;
struct msm_request *prev;
unsigned busy:1;
unsigned live:1;
unsigned alloced:1;
dma_addr_t dma;
dma_addr_t item_dma;
struct ept_queue_item *item;
};
#define to_msm_request(r) container_of(r, struct msm_request, req)
#define to_msm_endpoint(r) container_of(r, struct msm_endpoint, ep)
#define to_msm_otg(xceiv) container_of(xceiv, struct msm_otg, phy)
#define is_b_sess_vld() ((OTGSC_BSV & readl(USB_OTGSC)) ? 1 : 0)
#define is_usb_online(ui) (ui->usb_state != USB_STATE_NOTATTACHED)
struct msm_endpoint {
struct usb_ep ep;
struct usb_info *ui;
struct msm_request *req; /* head of pending requests */
struct msm_request *last;
unsigned flags;
/* bit number (0-31) in various status registers
** as well as the index into the usb_info's array
** of all endpoints
*/
unsigned char bit;
unsigned char num;
unsigned long dTD_update_fail_count;
unsigned long false_prime_fail_count;
unsigned actual_prime_fail_count;
unsigned long dTD_workaround_fail_count;
unsigned wedged:1;
/* pointers to DMA transfer list area */
/* these are allocated from the usb_info dma space */
struct ept_queue_head *head;
struct timer_list prime_timer;
};
/* PHY status check timer to monitor phy stuck up on reset */
static struct timer_list phy_status_timer;
static void ept_prime_timer_func(unsigned long data);
static void usb_do_work(struct work_struct *w);
static void usb_do_remote_wakeup(struct work_struct *w);
#define USB_STATE_IDLE 0
#define USB_STATE_ONLINE 1
#define USB_STATE_OFFLINE 2
#define USB_FLAG_START 0x0001
#define USB_FLAG_VBUS_ONLINE 0x0002
#define USB_FLAG_VBUS_OFFLINE 0x0004
#define USB_FLAG_RESET 0x0008
#define USB_FLAG_SUSPEND 0x0010
#define USB_FLAG_CONFIGURED 0x0020
#define USB_CHG_DET_DELAY msecs_to_jiffies(1000)
#define REMOTE_WAKEUP_DELAY msecs_to_jiffies(1000)
#define PHY_STATUS_CHECK_DELAY (jiffies + msecs_to_jiffies(1000))
#define EPT_PRIME_CHECK_DELAY (jiffies + msecs_to_jiffies(1000))
struct usb_info {
/* lock for register/queue/device state changes */
spinlock_t lock;
/* single request used for handling setup transactions */
struct usb_request *setup_req;
struct platform_device *pdev;
int irq;
void *addr;
unsigned state;
unsigned flags;
atomic_t configured;
atomic_t running;
struct dma_pool *pool;
/* dma page to back the queue heads and items */
unsigned char *buf;
dma_addr_t dma;
struct ept_queue_head *head;
/* used for allocation */
unsigned next_item;
unsigned next_ifc_num;
/* endpoints are ordered based on their status bits,
** so they are OUT0, OUT1, ... OUT15, IN0, IN1, ... IN15
*/
struct msm_endpoint ept[32];
/* max power requested by selected configuration */
unsigned b_max_pow;
unsigned chg_current;
unsigned chg_type_retry_cnt;
bool proprietary_chg;
struct delayed_work chg_det;
struct delayed_work chg_stop;
struct msm_hsusb_gadget_platform_data *pdata;
struct work_struct phy_status_check;
struct work_struct work;
unsigned phy_status;
unsigned phy_fail_count;
unsigned prime_fail_count;
unsigned long dTD_update_fail_count;
unsigned long dTD_workaround_fail_count;
struct usb_gadget gadget;
struct usb_gadget_driver *driver;
struct switch_dev sdev;
#define ep0out ept[0]
#define ep0in ept[16]
atomic_t ep0_dir;
atomic_t test_mode;
atomic_t offline_pending;
atomic_t softconnect;
#ifdef CONFIG_USB_OTG
u8 hnp_avail;
#endif
atomic_t remote_wakeup;
atomic_t self_powered;
struct delayed_work rw_work;
struct usb_phy *xceiv;
enum usb_device_state usb_state;
struct wake_lock wlock;
};
static const struct usb_ep_ops msm72k_ep_ops;
static struct usb_info *the_usb_info;
static int msm72k_wakeup(struct usb_gadget *_gadget);
static int msm72k_pullup_internal(struct usb_gadget *_gadget, int is_active);
static int msm72k_set_halt(struct usb_ep *_ep, int value);
static void flush_endpoint(struct msm_endpoint *ept);
static void usb_reset(struct usb_info *ui);
static int usb_ept_set_halt(struct usb_ep *_ep, int value);
static void msm_hsusb_set_speed(struct usb_info *ui)
{
unsigned long flags;
spin_lock_irqsave(&ui->lock, flags);
switch (readl(USB_PORTSC) & PORTSC_PSPD_MASK) {
case PORTSC_PSPD_FS:
dev_dbg(&ui->pdev->dev, "portchange USB_SPEED_FULL\n");
ui->gadget.speed = USB_SPEED_FULL;
break;
case PORTSC_PSPD_LS:
dev_dbg(&ui->pdev->dev, "portchange USB_SPEED_LOW\n");
ui->gadget.speed = USB_SPEED_LOW;
break;
case PORTSC_PSPD_HS:
dev_dbg(&ui->pdev->dev, "portchange USB_SPEED_HIGH\n");
ui->gadget.speed = USB_SPEED_HIGH;
break;
}
spin_unlock_irqrestore(&ui->lock, flags);
}
static void msm_hsusb_set_state(enum usb_device_state state)
{
unsigned long flags;
spin_lock_irqsave(&the_usb_info->lock, flags);
the_usb_info->usb_state = state;
spin_unlock_irqrestore(&the_usb_info->lock, flags);
}
static enum usb_device_state msm_hsusb_get_state(void)
{
unsigned long flags;
enum usb_device_state state;
spin_lock_irqsave(&the_usb_info->lock, flags);
state = the_usb_info->usb_state;
spin_unlock_irqrestore(&the_usb_info->lock, flags);
return state;
}
static ssize_t print_switch_name(struct switch_dev *sdev, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", DRIVER_NAME);
}
static ssize_t print_switch_state(struct switch_dev *sdev, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n",
sdev->state ? "online" : "offline");
}
static inline enum chg_type usb_get_chg_type(struct usb_info *ui)
{
if ((readl_relaxed(USB_PORTSC) & PORTSC_LS) == PORTSC_LS) {
return USB_CHG_TYPE__WALLCHARGER;
} else if (ui->pdata->prop_chg) {
if (ui->gadget.speed == USB_SPEED_LOW ||
ui->gadget.speed == USB_SPEED_FULL ||
ui->gadget.speed == USB_SPEED_HIGH)
return USB_CHG_TYPE__SDP;
else
return USB_CHG_TYPE__INVALID;
} else {
return USB_CHG_TYPE__SDP;
}
}
#define USB_WALLCHARGER_CHG_CURRENT 1800
#define USB_PROPRIETARY_CHG_CURRENT 500
static int usb_get_max_power(struct usb_info *ui)
{
struct msm_otg *otg = to_msm_otg(ui->xceiv);
unsigned long flags;
enum chg_type temp;
int suspended;
int configured;
unsigned bmaxpow;
if (ui->gadget.is_a_peripheral)
return -EINVAL;
temp = atomic_read(&otg->chg_type);
spin_lock_irqsave(&ui->lock, flags);
suspended = ui->usb_state == USB_STATE_SUSPENDED ? 1 : 0;
configured = atomic_read(&ui->configured);
bmaxpow = ui->b_max_pow;
spin_unlock_irqrestore(&ui->lock, flags);
if (temp == USB_CHG_TYPE__INVALID)
return -ENODEV;
if (temp == USB_CHG_TYPE__WALLCHARGER && !ui->proprietary_chg)
return USB_WALLCHARGER_CHG_CURRENT;
else if (ui->pdata->prop_chg)
return USB_PROPRIETARY_CHG_CURRENT;
if (suspended || !configured)
return 0;
return bmaxpow;
}
static int usb_phy_stuck_check(struct usb_info *ui)
{
/*
* write some value (0xAA) into scratch reg (0x16) and read it back,
* If the read value is same as written value, means PHY is normal
* otherwise, PHY seems to have stuck.
*/
if (usb_phy_io_write(ui->xceiv, 0xAA, 0x16) == -1) {
dev_dbg(&ui->pdev->dev,
"%s(): ulpi write timeout\n", __func__);
return -EIO;
}
if (usb_phy_io_read(ui->xceiv, 0x16) != 0xAA) {
dev_dbg(&ui->pdev->dev,
"%s(): read value is incorrect\n", __func__);
return -EIO;
}
return 0;
}
/*
* This function checks the phy status by reading/writing to the
* phy scratch register. If the phy is stuck resets the HW
* */
static void usb_phy_stuck_recover(struct work_struct *w)
{
struct usb_info *ui = the_usb_info;
struct msm_otg *otg = to_msm_otg(ui->xceiv);
unsigned long flags;
spin_lock_irqsave(&ui->lock, flags);
if (ui->gadget.speed != USB_SPEED_UNKNOWN ||
ui->usb_state == USB_STATE_NOTATTACHED ||
ui->driver == NULL) {
spin_unlock_irqrestore(&ui->lock, flags);
return;
}
spin_unlock_irqrestore(&ui->lock, flags);
disable_irq(otg->irq);
if (usb_phy_stuck_check(ui)) {
#ifdef CONFIG_USB_MSM_ACA
del_timer_sync(&otg->id_timer);
#endif
ui->phy_fail_count++;
dev_err(&ui->pdev->dev,
"%s():PHY stuck, resetting HW\n", __func__);
/*
* PHY seems to have stuck,
* reset the PHY and HW link to recover the PHY
*/
usb_reset(ui);
#ifdef CONFIG_USB_MSM_ACA
mod_timer(&otg->id_timer, jiffies +
msecs_to_jiffies(OTG_ID_POLL_MS));
#endif
msm72k_pullup_internal(&ui->gadget, 1);
}
enable_irq(otg->irq);
}
static void usb_phy_status_check_timer(unsigned long data)
{
struct usb_info *ui = the_usb_info;
schedule_work(&ui->phy_status_check);
}
static void usb_chg_stop(struct work_struct *w)
{
struct usb_info *ui = container_of(w, struct usb_info, chg_stop.work);
struct msm_otg *otg = to_msm_otg(ui->xceiv);
enum chg_type temp;
temp = atomic_read(&otg->chg_type);
if (temp == USB_CHG_TYPE__SDP)
usb_phy_set_power(ui->xceiv, 0);
}
static void usb_chg_detect(struct work_struct *w)
{
struct usb_info *ui = container_of(w, struct usb_info, chg_det.work);
struct msm_otg *otg = to_msm_otg(ui->xceiv);
enum chg_type temp = USB_CHG_TYPE__INVALID;
unsigned long flags;
int maxpower;
spin_lock_irqsave(&ui->lock, flags);
if (ui->usb_state == USB_STATE_NOTATTACHED) {
spin_unlock_irqrestore(&ui->lock, flags);
return;
}
temp = usb_get_chg_type(ui);
if (temp != USB_CHG_TYPE__WALLCHARGER && temp != USB_CHG_TYPE__SDP
&& !ui->chg_type_retry_cnt) {
schedule_delayed_work(&ui->chg_det, USB_CHG_DET_DELAY);
ui->chg_type_retry_cnt++;
spin_unlock_irqrestore(&ui->lock, flags);
return;
}
if (temp == USB_CHG_TYPE__INVALID) {
temp = USB_CHG_TYPE__WALLCHARGER;
ui->proprietary_chg = true;
}
spin_unlock_irqrestore(&ui->lock, flags);
atomic_set(&otg->chg_type, temp);
maxpower = usb_get_max_power(ui);
if (maxpower > 0)
usb_phy_set_power(ui->xceiv, maxpower);
/* USB driver prevents idle and suspend power collapse(pc)
* while USB cable is connected. But when dedicated charger is
* connected, driver can vote for idle and suspend pc.
* OTG driver handles idle pc as part of above usb_phy_set_power call
* when wallcharger is attached. To allow suspend pc, release the
* wakelock which will be re-acquired for any sub-sequent usb interrupts
* */
if (temp == USB_CHG_TYPE__WALLCHARGER) {
pm_runtime_put_sync(&ui->pdev->dev);
wake_unlock(&ui->wlock);
}
}
static int usb_ep_get_stall(struct msm_endpoint *ept)
{
unsigned int n;
struct usb_info *ui = ept->ui;
n = readl(USB_ENDPTCTRL(ept->num));
if (ept->flags & EPT_FLAG_IN)
return (CTRL_TXS & n) ? 1 : 0;
else
return (CTRL_RXS & n) ? 1 : 0;
}
static void init_endpoints(struct usb_info *ui)
{
unsigned n;
for (n = 0; n < 32; n++) {
struct msm_endpoint *ept = ui->ept + n;
ept->ui = ui;
ept->bit = n;
ept->num = n & 15;
ept->ep.name = ep_name[n];
ept->ep.ops = &msm72k_ep_ops;
if (ept->bit > 15) {
/* IN endpoint */
ept->head = ui->head + (ept->num << 1) + 1;
ept->flags = EPT_FLAG_IN;
} else {
/* OUT endpoint */
ept->head = ui->head + (ept->num << 1);
ept->flags = 0;
}
setup_timer(&ept->prime_timer, ept_prime_timer_func,
(unsigned long) ept);
}
}
static void config_ept(struct msm_endpoint *ept)
{
struct usb_info *ui = ept->ui;
unsigned cfg = CONFIG_MAX_PKT(ept->ep.maxpacket) | CONFIG_ZLT;
const struct usb_endpoint_descriptor *desc = ept->ep.desc;
unsigned mult = 0;
if (desc && ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
== USB_ENDPOINT_XFER_ISOC)) {
cfg &= ~(CONFIG_MULT);
mult = ((ept->ep.maxpacket >> CONFIG_MULT_SHIFT) + 1) & 0x03;
cfg |= (mult << (ffs(CONFIG_MULT) - 1));
}
/* ep0 out needs interrupt-on-setup */
if (ept->bit == 0)
cfg |= CONFIG_IOS;
ept->head->config = cfg;
ept->head->next = TERMINATE;
if (ept->ep.maxpacket)
dev_dbg(&ui->pdev->dev,
"ept #%d %s max:%d head:%p bit:%d\n",
ept->num,
(ept->flags & EPT_FLAG_IN) ? "in" : "out",
ept->ep.maxpacket, ept->head, ept->bit);
}
static void configure_endpoints(struct usb_info *ui)
{
unsigned n;
for (n = 0; n < 32; n++)
config_ept(ui->ept + n);
}
struct usb_request *usb_ept_alloc_req(struct msm_endpoint *ept,
unsigned bufsize, gfp_t gfp_flags)
{
struct usb_info *ui = ept->ui;
struct msm_request *req;
req = kzalloc(sizeof(*req), gfp_flags);
if (!req)
goto fail1;
req->item = dma_pool_alloc(ui->pool, gfp_flags, &req->item_dma);
if (!req->item)
goto fail2;
if (bufsize) {
req->req.buf = kmalloc(bufsize, gfp_flags);
if (!req->req.buf)
goto fail3;
req->alloced = 1;
}
return &req->req;
fail3:
dma_pool_free(ui->pool, req->item, req->item_dma);
fail2:
kfree(req);
fail1:
return 0;
}
static void usb_ept_enable(struct msm_endpoint *ept, int yes,
unsigned char ep_type)
{
struct usb_info *ui = ept->ui;
int in = ept->flags & EPT_FLAG_IN;
unsigned n;
n = readl(USB_ENDPTCTRL(ept->num));
if (in) {
if (yes) {
n = (n & (~CTRL_TXT_MASK)) |
(ep_type << CTRL_TXT_EP_TYPE_SHIFT);
n |= CTRL_TXE | CTRL_TXR;
} else
n &= (~CTRL_TXE);
} else {
if (yes) {
n = (n & (~CTRL_RXT_MASK)) |
(ep_type << CTRL_RXT_EP_TYPE_SHIFT);
n |= CTRL_RXE | CTRL_RXR;
} else
n &= ~(CTRL_RXE);
}
/* complete all the updates to ept->head before enabling endpoint*/
mb();
writel(n, USB_ENDPTCTRL(ept->num));
/* Ensure endpoint is enabled before returning */
mb();
dev_dbg(&ui->pdev->dev, "ept %d %s %s\n",
ept->num, in ? "in" : "out", yes ? "enabled" : "disabled");
}
static void ept_prime_timer_func(unsigned long data)
{
struct msm_endpoint *ept = (struct msm_endpoint *)data;
struct usb_info *ui = ept->ui;
unsigned n = 1 << ept->bit;
unsigned long flags;
spin_lock_irqsave(&ui->lock, flags);
ept->false_prime_fail_count++;
if ((readl_relaxed(USB_ENDPTPRIME) & n)) {
/*
* ---- UNLIKELY ---
* May be hardware is taking long time to process the
* prime request. Or could be intermittent priming and
* previous dTD is not fired yet.
*/
mod_timer(&ept->prime_timer, EPT_PRIME_CHECK_DELAY);
goto out;
}
if (readl_relaxed(USB_ENDPTSTAT) & n)
goto out;
/* clear speculative loads on item->info */
rmb();
if (ept->req && (ept->req->item->info & INFO_ACTIVE)) {
ui->prime_fail_count++;
ept->actual_prime_fail_count++;
pr_err("%s(): ept%d%s prime failed. ept: config: %x"
"active: %x next: %x info: %x\n",
__func__, ept->num,
ept->flags & EPT_FLAG_IN ? "in" : "out",
ept->head->config, ept->head->active,
ept->head->next, ept->head->info);
writel_relaxed(n, USB_ENDPTPRIME);
mod_timer(&ept->prime_timer, EPT_PRIME_CHECK_DELAY);
}
out:
spin_unlock_irqrestore(&ui->lock, flags);
}
static void usb_ept_start(struct msm_endpoint *ept)
{
struct usb_info *ui = ept->ui;
struct msm_request *req = ept->req;
unsigned n = 1 << ept->bit;
BUG_ON(req->live);
while (req) {
req->live = 1;
/* prepare the transaction descriptor item for the hardware */
req->item->info =
INFO_BYTES(req->req.length) | INFO_IOC | INFO_ACTIVE;
req->item->page0 = req->dma;
req->item->page1 = (req->dma + 0x1000) & 0xfffff000;
req->item->page2 = (req->dma + 0x2000) & 0xfffff000;
req->item->page3 = (req->dma + 0x3000) & 0xfffff000;
if (req->next == NULL) {
req->item->next = TERMINATE;
break;
}
req->item->next = req->next->item_dma;
req = req->next;
}
rmb();
/* link the hw queue head to the request's transaction item */
ept->head->next = ept->req->item_dma;
ept->head->info = 0;
/* flush buffers before priming ept */
mb();
/* during high throughput testing it is observed that
* ept stat bit is not set even though all the data
* structures are updated properly and ept prime bit
* is set. To workaround the issue, kick a timer and
* make decision on re-prime. We can do a busy loop here
* but it leads to high cpu usage.
*/
writel_relaxed(n, USB_ENDPTPRIME);
mod_timer(&ept->prime_timer, EPT_PRIME_CHECK_DELAY);
}
int usb_ept_queue_xfer(struct msm_endpoint *ept, struct usb_request *_req)
{
unsigned long flags;
struct msm_request *req = to_msm_request(_req);
struct msm_request *last;
struct usb_info *ui = ept->ui;
unsigned length = req->req.length;
if (length > 0x4000)
return -EMSGSIZE;
spin_lock_irqsave(&ui->lock, flags);
if (ept->num != 0 && ept->ep.desc == NULL) {
req->req.status = -EINVAL;
spin_unlock_irqrestore(&ui->lock, flags);
dev_err(&ui->pdev->dev,
"%s: called for disabled endpoint\n", __func__);
return -EINVAL;
}
if (req->busy) {
req->req.status = -EBUSY;
spin_unlock_irqrestore(&ui->lock, flags);
dev_err(&ui->pdev->dev,
"usb_ept_queue_xfer() tried to queue busy request\n");
return -EBUSY;
}
if (!atomic_read(&ui->configured) && (ept->num != 0)) {
req->req.status = -ESHUTDOWN;
spin_unlock_irqrestore(&ui->lock, flags);
if (printk_ratelimit())
dev_err(&ui->pdev->dev,
"%s: called while offline\n", __func__);
return -ESHUTDOWN;
}
if (ui->usb_state == USB_STATE_SUSPENDED) {
if (!atomic_read(&ui->remote_wakeup)) {
req->req.status = -EAGAIN;
spin_unlock_irqrestore(&ui->lock, flags);
if (printk_ratelimit())
dev_err(&ui->pdev->dev,
"%s: cannot queue as bus is suspended "
"ept #%d %s max:%d head:%p bit:%d\n",
__func__, ept->num,
(ept->flags & EPT_FLAG_IN) ? "in" : "out",
ept->ep.maxpacket, ept->head, ept->bit);
return -EAGAIN;
}
wake_lock(&ui->wlock);
usb_phy_set_suspend(ui->xceiv, 0);
schedule_delayed_work(&ui->rw_work, REMOTE_WAKEUP_DELAY);
}
req->busy = 1;
req->live = 0;
req->next = 0;
req->req.status = -EBUSY;
req->dma = dma_map_single(NULL, req->req.buf, length,
(ept->flags & EPT_FLAG_IN) ?
DMA_TO_DEVICE : DMA_FROM_DEVICE);
/* Add the new request to the end of the queue */
last = ept->last;
if (last) {
/* Already requests in the queue. add us to the
* end, but let the completion interrupt actually
* start things going, to avoid hw issues
*/
last->next = req;
req->prev = last;
} else {
/* queue was empty -- kick the hardware */
ept->req = req;
req->prev = NULL;
usb_ept_start(ept);
}
ept->last = req;
spin_unlock_irqrestore(&ui->lock, flags);
return 0;
}
/* --- endpoint 0 handling --- */
static void ep0_complete(struct usb_ep *ep, struct usb_request *req)
{
struct msm_request *r = to_msm_request(req);
struct msm_endpoint *ept = to_msm_endpoint(ep);
struct usb_info *ui = ept->ui;
req->complete = r->gadget_complete;
r->gadget_complete = 0;
if (req->complete)
req->complete(&ui->ep0in.ep, req);
}
static void ep0_status_complete(struct usb_ep *ep, struct usb_request *_req)
{
struct usb_request *req = _req->context;
struct msm_request *r;
struct msm_endpoint *ept;
struct usb_info *ui;
pr_debug("%s:\n", __func__);
if (!req)
return;
r = to_msm_request(req);
ept = to_msm_endpoint(ep);
ui = ept->ui;
_req->context = 0;
req->complete = r->gadget_complete;
req->zero = 0;
r->gadget_complete = 0;
if (req->complete)
req->complete(&ui->ep0in.ep, req);
}
static void ep0_status_phase(struct usb_ep *ep, struct usb_request *req)
{
struct msm_endpoint *ept = to_msm_endpoint(ep);
struct usb_info *ui = ept->ui;
pr_debug("%s:\n", __func__);
req->length = 0;
req->complete = ep0_status_complete;
/* status phase */
if (atomic_read(&ui->ep0_dir) == USB_DIR_IN)
usb_ept_queue_xfer(&ui->ep0out, req);
else
usb_ept_queue_xfer(&ui->ep0in, req);
}
static void ep0in_send_zero_leng_pkt(struct msm_endpoint *ept)
{
struct usb_info *ui = ept->ui;
struct usb_request *req = ui->setup_req;
pr_debug("%s:\n", __func__);
req->length = 0;
req->complete = ep0_status_phase;
usb_ept_queue_xfer(&ui->ep0in, req);
}
static void ep0_queue_ack_complete(struct usb_ep *ep,
struct usb_request *_req)
{
struct msm_endpoint *ept = to_msm_endpoint(ep);
struct usb_info *ui = ept->ui;
struct usb_request *req = ui->setup_req;
pr_debug("%s: _req:%p actual:%d length:%d zero:%d\n",
__func__, _req, _req->actual,
_req->length, _req->zero);
/* queue up the receive of the ACK response from the host */
if (_req->status == 0 && _req->actual == _req->length) {
req->context = _req;
if (atomic_read(&ui->ep0_dir) == USB_DIR_IN) {
if (_req->zero && _req->length &&
!(_req->length % ep->maxpacket)) {
ep0in_send_zero_leng_pkt(&ui->ep0in);
return;
}
}
ep0_status_phase(ep, req);
} else
ep0_complete(ep, _req);
}
static void ep0_setup_ack_complete(struct usb_ep *ep, struct usb_request *req)
{
struct msm_endpoint *ept = to_msm_endpoint(ep);
struct usb_info *ui = ept->ui;
unsigned int temp;
int test_mode = atomic_read(&ui->test_mode);
if (!test_mode)
return;
switch (test_mode) {
case J_TEST:
dev_info(&ui->pdev->dev, "usb electrical test mode: (J)\n");
temp = readl(USB_PORTSC) & (~PORTSC_PTC);
writel(temp | PORTSC_PTC_J_STATE, USB_PORTSC);
break;
case K_TEST:
dev_info(&ui->pdev->dev, "usb electrical test mode: (K)\n");
temp = readl(USB_PORTSC) & (~PORTSC_PTC);
writel(temp | PORTSC_PTC_K_STATE, USB_PORTSC);
break;
case SE0_NAK_TEST:
dev_info(&ui->pdev->dev,
"usb electrical test mode: (SE0-NAK)\n");
temp = readl(USB_PORTSC) & (~PORTSC_PTC);
writel(temp | PORTSC_PTC_SE0_NAK, USB_PORTSC);
break;
case TST_PKT_TEST:
dev_info(&ui->pdev->dev,
"usb electrical test mode: (TEST_PKT)\n");
temp = readl(USB_PORTSC) & (~PORTSC_PTC);
writel(temp | PORTSC_PTC_TST_PKT, USB_PORTSC);
break;
}
}
static void ep0_setup_ack(struct usb_info *ui)
{
struct usb_request *req = ui->setup_req;
req->length = 0;
req->complete = ep0_setup_ack_complete;
usb_ept_queue_xfer(&ui->ep0in, req);
}
static void ep0_setup_stall(struct usb_info *ui)
{
writel((1<<16) | (1<<0), USB_ENDPTCTRL(0));
}
static void ep0_setup_send(struct usb_info *ui, unsigned length)
{
struct usb_request *req = ui->setup_req;
struct msm_request *r = to_msm_request(req);
struct msm_endpoint *ept = &ui->ep0in;
req->length = length;
req->complete = ep0_queue_ack_complete;
r->gadget_complete = 0;
usb_ept_queue_xfer(ept, req);
}
static void handle_setup(struct usb_info *ui)
{
struct usb_ctrlrequest ctl;
struct usb_request *req = ui->setup_req;
int ret;
#ifdef CONFIG_USB_OTG
u8 hnp;
unsigned long flags;
#endif
/* USB hardware sometimes generate interrupt before
* 8 bytes of SETUP packet are written to system memory.
* This results in fetching wrong setup_data sometimes.
* TODO: Remove below workaround of adding 1us delay once
* it gets fixed in hardware.
*/
udelay(10);
memcpy(&ctl, ui->ep0out.head->setup_data, sizeof(ctl));
/* Ensure buffer is read before acknowledging to h/w */
mb();
writel(EPT_RX(0), USB_ENDPTSETUPSTAT);
if (ctl.bRequestType & USB_DIR_IN)
atomic_set(&ui->ep0_dir, USB_DIR_IN);
else
atomic_set(&ui->ep0_dir, USB_DIR_OUT);
/* any pending ep0 transactions must be canceled */
flush_endpoint(&ui->ep0out);
flush_endpoint(&ui->ep0in);
dev_dbg(&ui->pdev->dev,
"setup: type=%02x req=%02x val=%04x idx=%04x len=%04x\n",
ctl.bRequestType, ctl.bRequest, ctl.wValue,
ctl.wIndex, ctl.wLength);
if ((ctl.bRequestType & (USB_DIR_IN | USB_TYPE_MASK)) ==
(USB_DIR_IN | USB_TYPE_STANDARD)) {
if (ctl.bRequest == USB_REQ_GET_STATUS) {
/* OTG supplement Rev 2.0 introduces another device
* GET_STATUS request for HNP polling with length = 1.
*/
u8 len = 2;
switch (ctl.bRequestType & USB_RECIP_MASK) {
case USB_RECIP_ENDPOINT:
{
struct msm_endpoint *ept;
unsigned num =
ctl.wIndex & USB_ENDPOINT_NUMBER_MASK;
u16 temp = 0;
if (num == 0) {
memset(req->buf, 0, 2);
break;
}
if (ctl.wIndex & USB_ENDPOINT_DIR_MASK)
num += 16;
ept = &ui->ep0out + num;
temp = usb_ep_get_stall(ept);
temp = temp << USB_ENDPOINT_HALT;
memcpy(req->buf, &temp, 2);
break;
}
case USB_RECIP_DEVICE:
{
u16 temp = 0;
if (ctl.wIndex == OTG_STATUS_SELECTOR) {
#ifdef CONFIG_USB_OTG
spin_lock_irqsave(&ui->lock, flags);
hnp = (ui->gadget.host_request <<
HOST_REQUEST_FLAG);
ui->hnp_avail = 1;
spin_unlock_irqrestore(&ui->lock,
flags);
memcpy(req->buf, &hnp, 1);
len = 1;
#else
goto stall;
#endif
} else {
temp = (atomic_read(&ui->self_powered)
<< USB_DEVICE_SELF_POWERED);
temp |= (atomic_read(&ui->remote_wakeup)
<< USB_DEVICE_REMOTE_WAKEUP);
memcpy(req->buf, &temp, 2);
}
break;
}
case USB_RECIP_INTERFACE:
memset(req->buf, 0, 2);
break;
default:
goto stall;
}
ep0_setup_send(ui, len);
return;
}
}
if (ctl.bRequestType ==
(USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)) {
if ((ctl.bRequest == USB_REQ_CLEAR_FEATURE) ||
(ctl.bRequest == USB_REQ_SET_FEATURE)) {
if ((ctl.wValue == 0) && (ctl.wLength == 0)) {
unsigned num = ctl.wIndex & 0x0f;
if (num != 0) {
struct msm_endpoint *ept;
if (ctl.wIndex & 0x80)
num += 16;
ept = &ui->ep0out + num;
if (ept->wedged)
goto ack;
if (ctl.bRequest == USB_REQ_SET_FEATURE)
usb_ept_set_halt(&ept->ep, 1);
else
usb_ept_set_halt(&ept->ep, 0);
}
goto ack;
}
}
}
if (ctl.bRequestType == (USB_DIR_OUT | USB_TYPE_STANDARD)) {
if (ctl.bRequest == USB_REQ_SET_CONFIGURATION) {
atomic_set(&ui->configured, !!ctl.wValue);
msm_hsusb_set_state(USB_STATE_CONFIGURED);
} else if (ctl.bRequest == USB_REQ_SET_ADDRESS) {
/*
* Gadget speed should be set when PCI interrupt
* occurs. But sometimes, PCI interrupt is not
* occuring after reset. Hence update the gadget
* speed here.
*/
if (ui->gadget.speed == USB_SPEED_UNKNOWN) {
dev_info(&ui->pdev->dev,
"PCI intr missed"
"set speed explictly\n");
msm_hsusb_set_speed(ui);
}
msm_hsusb_set_state(USB_STATE_ADDRESS);
/* write address delayed (will take effect
** after the next IN txn)
*/
writel((ctl.wValue << 25) | (1 << 24), USB_DEVICEADDR);
goto ack;
} else if (ctl.bRequest == USB_REQ_SET_FEATURE) {
switch (ctl.wValue) {
case USB_DEVICE_TEST_MODE:
switch (ctl.wIndex) {
case J_TEST:
case K_TEST:
case SE0_NAK_TEST:
case TST_PKT_TEST:
atomic_set(&ui->test_mode, ctl.wIndex);
goto ack;
}
goto stall;
case USB_DEVICE_REMOTE_WAKEUP:
atomic_set(&ui->remote_wakeup, 1);
goto ack;
#ifdef CONFIG_USB_OTG
case USB_DEVICE_B_HNP_ENABLE:
ui->gadget.b_hnp_enable = 1;
goto ack;
case USB_DEVICE_A_HNP_SUPPORT:
case USB_DEVICE_A_ALT_HNP_SUPPORT:
/* B-devices compliant to OTG spec
* Rev 2.0 are not required to
* suppport these features.
*/
goto stall;
#endif
}
} else if ((ctl.bRequest == USB_REQ_CLEAR_FEATURE) &&
(ctl.wValue == USB_DEVICE_REMOTE_WAKEUP)) {
atomic_set(&ui->remote_wakeup, 0);
goto ack;
}
}
/* delegate if we get here */
if (ui->driver) {
ret = ui->driver->setup(&ui->gadget, &ctl);
if (ret >= 0)
return;
}
stall:
/* stall ep0 on error */
ep0_setup_stall(ui);
return;
ack:
ep0_setup_ack(ui);
}
static void handle_endpoint(struct usb_info *ui, unsigned bit)
{
struct msm_endpoint *ept = ui->ept + bit;
struct msm_request *req;
unsigned long flags;
int req_dequeue = 1;
int dtd_update_fail_count_chk = 10;
int check_bit = 0;
unsigned info;
/*
INFO("handle_endpoint() %d %s req=%p(%08x)\n",
ept->num, (ept->flags & EPT_FLAG_IN) ? "in" : "out",
ept->req, ept->req ? ept->req->item_dma : 0);
*/
/* expire all requests that are no longer active */
spin_lock_irqsave(&ui->lock, flags);
while ((req = ept->req)) {
/* if we've processed all live requests, time to
* restart the hardware on the next non-live request
*/
if (!req->live) {
usb_ept_start(ept);
break;
}
dequeue:
/* clean speculative fetches on req->item->info */
dma_coherent_post_ops();
info = req->item->info;
/* if the transaction is still in-flight, stop here */
if (info & INFO_ACTIVE) {
if (req_dequeue) {
ui->dTD_update_fail_count++;
ept->dTD_update_fail_count++;
udelay(1);
if (!dtd_update_fail_count_chk--) {
req_dequeue = 0;
check_bit = 1;
}
goto dequeue;
} else {
if (check_bit) {
pr_debug("%s: Delay Workaround Failed\n",
__func__);
check_bit = 0;
ui->dTD_workaround_fail_count++;
ept->dTD_workaround_fail_count++;
}
break;
}
}
req_dequeue = 0;
del_timer(&ept->prime_timer);
/* advance ept queue to the next request */
ept->req = req->next;
if (ept->req == 0)
ept->last = 0;
dma_unmap_single(NULL, req->dma, req->req.length,
(ept->flags & EPT_FLAG_IN) ?
DMA_TO_DEVICE : DMA_FROM_DEVICE);
if (info & (INFO_HALTED | INFO_BUFFER_ERROR | INFO_TXN_ERROR)) {
/* XXX pass on more specific error code */
req->req.status = -EIO;
req->req.actual = 0;
dev_err(&ui->pdev->dev,
"ept %d %s error. info=%08x\n",
ept->num,
(ept->flags & EPT_FLAG_IN) ? "in" : "out",
info);
} else {
req->req.status = 0;
req->req.actual =
req->req.length - ((info >> 16) & 0x7FFF);
}
req->busy = 0;
req->live = 0;
if (req->req.complete) {
spin_unlock_irqrestore(&ui->lock, flags);
req->req.complete(&ept->ep, &req->req);
spin_lock_irqsave(&ui->lock, flags);
}
}
spin_unlock_irqrestore(&ui->lock, flags);
}
static void flush_endpoint_hw(struct usb_info *ui, unsigned bits)
{
/* flush endpoint, canceling transactions
** - this can take a "large amount of time" (per databook)
** - the flush can fail in some cases, thus we check STAT
** and repeat if we're still operating
** (does the fact that this doesn't use the tripwire matter?!)
*/
do {
writel(bits, USB_ENDPTFLUSH);
while (readl(USB_ENDPTFLUSH) & bits)
udelay(100);
} while (readl(USB_ENDPTSTAT) & bits);
}
static void flush_endpoint_sw(struct msm_endpoint *ept)
{
struct usb_info *ui = ept->ui;
struct msm_request *req, *next_req = NULL;
unsigned long flags;
if (!ept->req)
return;
/* inactive endpoints have nothing to do here */
if (ept->ep.maxpacket == 0)
return;
/* put the queue head in a sane state */
ept->head->info = 0;
ept->head->next = TERMINATE;
/* cancel any pending requests */
spin_lock_irqsave(&ui->lock, flags);
req = ept->req;
ept->req = 0;
ept->last = 0;
while (req != 0) {
req->busy = 0;
req->live = 0;
req->req.status = -ESHUTDOWN;
req->req.actual = 0;
/* Gadget driver may free the request in completion
* handler. So keep a copy of next req pointer
* before calling completion handler.
*/
next_req = req->next;
if (req->req.complete) {
spin_unlock_irqrestore(&ui->lock, flags);
req->req.complete(&ept->ep, &req->req);
spin_lock_irqsave(&ui->lock, flags);
}
req = next_req;
}
spin_unlock_irqrestore(&ui->lock, flags);
}
static void flush_endpoint(struct msm_endpoint *ept)
{
del_timer(&ept->prime_timer);
flush_endpoint_hw(ept->ui, (1 << ept->bit));
flush_endpoint_sw(ept);
}
static irqreturn_t usb_interrupt(int irq, void *data)
{
struct usb_info *ui = data;
struct msm_otg *dev = to_msm_otg(ui->xceiv);
unsigned n;
unsigned long flags;
if (atomic_read(&dev->in_lpm))
return IRQ_NONE;
n = readl(USB_USBSTS);
writel(n, USB_USBSTS);
/* somehow we got an IRQ while in the reset sequence: ignore it */
if (!atomic_read(&ui->running))
return IRQ_HANDLED;
if (n & STS_PCI) {
msm_hsusb_set_speed(ui);
if (atomic_read(&ui->configured)) {
wake_lock(&ui->wlock);
spin_lock_irqsave(&ui->lock, flags);
ui->usb_state = USB_STATE_CONFIGURED;
ui->flags = USB_FLAG_CONFIGURED;
spin_unlock_irqrestore(&ui->lock, flags);
ui->driver->resume(&ui->gadget);
schedule_work(&ui->work);
} else {
msm_hsusb_set_state(USB_STATE_DEFAULT);
}
#ifdef CONFIG_USB_OTG
/* notify otg to clear A_BIDL_ADIS timer */
if (ui->gadget.is_a_peripheral)
usb_phy_set_suspend(ui->xceiv, 0);
#endif
}
if (n & STS_URI) {
dev_dbg(&ui->pdev->dev, "reset\n");
spin_lock_irqsave(&ui->lock, flags);
ui->gadget.speed = USB_SPEED_UNKNOWN;
spin_unlock_irqrestore(&ui->lock, flags);
#ifdef CONFIG_USB_OTG
/* notify otg to clear A_BIDL_ADIS timer */
if (ui->gadget.is_a_peripheral)
usb_phy_set_suspend(ui->xceiv, 0);
spin_lock_irqsave(&ui->lock, flags);
/* Host request is persistent across reset */
ui->gadget.b_hnp_enable = 0;
ui->hnp_avail = 0;
spin_unlock_irqrestore(&ui->lock, flags);
#endif
msm_hsusb_set_state(USB_STATE_DEFAULT);
atomic_set(&ui->remote_wakeup, 0);
if (!ui->gadget.is_a_peripheral)
schedule_delayed_work(&ui->chg_stop, 0);
writel(readl(USB_ENDPTSETUPSTAT), USB_ENDPTSETUPSTAT);
writel(readl(USB_ENDPTCOMPLETE), USB_ENDPTCOMPLETE);
writel(0xffffffff, USB_ENDPTFLUSH);
writel(0, USB_ENDPTCTRL(1));
wake_lock(&ui->wlock);
if (atomic_read(&ui->configured)) {
/* marking us offline will cause ept queue attempts
** to fail
*/
atomic_set(&ui->configured, 0);
/* Defer sending offline uevent to userspace */
atomic_set(&ui->offline_pending, 1);
/* XXX: we can't seem to detect going offline,
* XXX: so deconfigure on reset for the time being
*/
dev_dbg(&ui->pdev->dev,
"usb: notify offline\n");
ui->driver->disconnect(&ui->gadget);
/* cancel pending ep0 transactions */
flush_endpoint(&ui->ep0out);
flush_endpoint(&ui->ep0in);
}
/* Start phy stuck timer */
if (ui->pdata && ui->pdata->is_phy_status_timer_on)
mod_timer(&phy_status_timer, PHY_STATUS_CHECK_DELAY);
}
if (n & STS_SLI) {
dev_dbg(&ui->pdev->dev, "suspend\n");
spin_lock_irqsave(&ui->lock, flags);
ui->usb_state = USB_STATE_SUSPENDED;
ui->flags = USB_FLAG_SUSPEND;
spin_unlock_irqrestore(&ui->lock, flags);
ui->driver->suspend(&ui->gadget);
schedule_work(&ui->work);
#ifdef CONFIG_USB_OTG
/* notify otg for
* 1. kicking A_BIDL_ADIS timer in case of A-peripheral
* 2. disabling pull-up and kicking B_ASE0_RST timer
*/
if (ui->gadget.b_hnp_enable || ui->gadget.is_a_peripheral)
usb_phy_set_suspend(ui->xceiv, 1);
#endif
}
if (n & STS_UI) {
n = readl(USB_ENDPTSETUPSTAT);
if (n & EPT_RX(0))
handle_setup(ui);
n = readl(USB_ENDPTCOMPLETE);
writel(n, USB_ENDPTCOMPLETE);
while (n) {
unsigned bit = __ffs(n);
handle_endpoint(ui, bit);
n = n & (~(1 << bit));
}
}
return IRQ_HANDLED;
}
static void usb_prepare(struct usb_info *ui)
{
spin_lock_init(&ui->lock);
memset(ui->buf, 0, 4096);
ui->head = (void *) (ui->buf + 0);
/* only important for reset/reinit */
memset(ui->ept, 0, sizeof(ui->ept));
ui->next_item = 0;
ui->next_ifc_num = 0;
init_endpoints(ui);
ui->ep0in.ep.maxpacket = 64;
ui->ep0out.ep.maxpacket = 64;
ui->setup_req =
usb_ept_alloc_req(&ui->ep0in, SETUP_BUF_SIZE, GFP_KERNEL);
INIT_WORK(&ui->work, usb_do_work);
INIT_DELAYED_WORK(&ui->chg_det, usb_chg_detect);
INIT_DELAYED_WORK(&ui->chg_stop, usb_chg_stop);
INIT_DELAYED_WORK(&ui->rw_work, usb_do_remote_wakeup);
if (ui->pdata && ui->pdata->is_phy_status_timer_on)
INIT_WORK(&ui->phy_status_check, usb_phy_stuck_recover);
}
static void usb_reset(struct usb_info *ui)
{
struct msm_otg *otg = to_msm_otg(ui->xceiv);
dev_dbg(&ui->pdev->dev, "reset controller\n");
atomic_set(&ui->running, 0);
/*
* PHY reset takes minimum 100 msec. Hence reset only link
* during HNP. Reset PHY and link in B-peripheral mode.
*/
if (ui->gadget.is_a_peripheral)
otg->reset(ui->xceiv, 0);
else
otg->reset(ui->xceiv, 1);
/* set usb controller interrupt threshold to zero*/
writel((readl(USB_USBCMD) & ~USBCMD_ITC_MASK) | USBCMD_ITC(0),
USB_USBCMD);
writel(ui->dma, USB_ENDPOINTLISTADDR);
configure_endpoints(ui);
/* marking us offline will cause ept queue attempts to fail */
atomic_set(&ui->configured, 0);
if (ui->driver) {
dev_dbg(&ui->pdev->dev, "usb: notify offline\n");
ui->driver->disconnect(&ui->gadget);
}
/* cancel pending ep0 transactions */
flush_endpoint(&ui->ep0out);
flush_endpoint(&ui->ep0in);
/* enable interrupts */
writel(STS_URI | STS_SLI | STS_UI | STS_PCI, USB_USBINTR);
/* Ensure that h/w RESET is completed before returning */
mb();
atomic_set(&ui->running, 1);
}
static void usb_start(struct usb_info *ui)
{
unsigned long flags;
spin_lock_irqsave(&ui->lock, flags);
ui->flags |= USB_FLAG_START;
schedule_work(&ui->work);
spin_unlock_irqrestore(&ui->lock, flags);
}
static int usb_free(struct usb_info *ui, int ret)
{
if (ret)
dev_dbg(&ui->pdev->dev, "usb_free(%d)\n", ret);
usb_del_gadget_udc(&ui->gadget);
if (ui->xceiv)
usb_put_transceiver(ui->xceiv);
if (ui->irq)
free_irq(ui->irq, 0);
if (ui->pool)
dma_pool_destroy(ui->pool);
if (ui->dma)
dma_free_coherent(&ui->pdev->dev, 4096, ui->buf, ui->dma);
kfree(ui);
return ret;
}
static void usb_do_work_check_vbus(struct usb_info *ui)
{
unsigned long iflags;
spin_lock_irqsave(&ui->lock, iflags);
if (is_usb_online(ui))
ui->flags |= USB_FLAG_VBUS_ONLINE;
else
ui->flags |= USB_FLAG_VBUS_OFFLINE;
spin_unlock_irqrestore(&ui->lock, iflags);
}
static void usb_do_work(struct work_struct *w)
{
struct usb_info *ui = container_of(w, struct usb_info, work);
struct msm_otg *otg = to_msm_otg(ui->xceiv);
unsigned long iflags;
unsigned flags, _vbus;
for (;;) {
spin_lock_irqsave(&ui->lock, iflags);
flags = ui->flags;
ui->flags = 0;
_vbus = is_usb_online(ui);
spin_unlock_irqrestore(&ui->lock, iflags);
/* give up if we have nothing to do */
if (flags == 0)
break;
switch (ui->state) {
case USB_STATE_IDLE:
if (flags & USB_FLAG_START) {
int ret;
if (!_vbus) {
ui->state = USB_STATE_OFFLINE;
break;
}
pm_runtime_get_noresume(&ui->pdev->dev);
pm_runtime_resume(&ui->pdev->dev);
dev_dbg(&ui->pdev->dev,
"msm72k_udc: IDLE -> ONLINE\n");
usb_reset(ui);
ret = request_irq(otg->irq, usb_interrupt,
IRQF_SHARED,
ui->pdev->name, ui);
/* FIXME: should we call BUG_ON when
* requst irq fails
*/
if (ret) {
dev_err(&ui->pdev->dev,
"hsusb: peripheral: request irq"
" failed:(%d)", ret);
break;
}
ui->irq = otg->irq;
ui->state = USB_STATE_ONLINE;
usb_do_work_check_vbus(ui);
if (!atomic_read(&ui->softconnect))
break;
msm72k_pullup_internal(&ui->gadget, 1);
if (!ui->gadget.is_a_peripheral)
schedule_delayed_work(
&ui->chg_det,
USB_CHG_DET_DELAY);
}
break;
case USB_STATE_ONLINE:
if (atomic_read(&ui->offline_pending)) {
switch_set_state(&ui->sdev, 0);
atomic_set(&ui->offline_pending, 0);
}
/* If at any point when we were online, we received
* the signal to go offline, we must honor it
*/
if (flags & USB_FLAG_VBUS_OFFLINE) {
ui->chg_current = 0;
/* wait incase chg_detect is running */
if (!ui->gadget.is_a_peripheral)
cancel_delayed_work_sync(&ui->chg_det);
dev_dbg(&ui->pdev->dev,
"msm72k_udc: ONLINE -> OFFLINE\n");
atomic_set(&ui->running, 0);
atomic_set(&ui->remote_wakeup, 0);
atomic_set(&ui->configured, 0);
if (ui->driver) {
dev_dbg(&ui->pdev->dev,
"usb: notify offline\n");
ui->driver->disconnect(&ui->gadget);
}
/* cancel pending ep0 transactions */
flush_endpoint(&ui->ep0out);
flush_endpoint(&ui->ep0in);
/* synchronize with irq context */
spin_lock_irqsave(&ui->lock, iflags);
#ifdef CONFIG_USB_OTG
ui->gadget.host_request = 0;
ui->gadget.b_hnp_enable = 0;
ui->hnp_avail = 0;
#endif
msm72k_pullup_internal(&ui->gadget, 0);
spin_unlock_irqrestore(&ui->lock, iflags);
/* if charger is initialized to known type
* we must let modem know about charger
* disconnection
*/
usb_phy_set_power(ui->xceiv, 0);
if (ui->irq) {
/* Disable and acknowledge all
* USB interrupts before freeing
* irq, so that no USB spurious
* interrupt occurs during USB cable
* disconnect which may lead to
* IRQ nobody cared error.
*/
writel_relaxed(0, USB_USBINTR);
writel_relaxed(readl_relaxed(USB_USBSTS)
, USB_USBSTS);
/* Ensure that above STOREs are
* completed before enabling
* interrupts */
wmb();
free_irq(ui->irq, ui);
ui->irq = 0;
}
switch_set_state(&ui->sdev, 0);
ui->state = USB_STATE_OFFLINE;
usb_do_work_check_vbus(ui);
pm_runtime_put_noidle(&ui->pdev->dev);
pm_runtime_suspend(&ui->pdev->dev);
wake_unlock(&ui->wlock);
break;
}
if (flags & USB_FLAG_SUSPEND) {
int maxpower = usb_get_max_power(ui);
if (maxpower < 0)
break;
usb_phy_set_power(ui->xceiv, 0);
/* To support TCXO during bus suspend
* This might be dummy check since bus suspend
* is not implemented as of now
* */
if (release_wlocks)
wake_unlock(&ui->wlock);
/* TBD: Initiate LPM at usb bus suspend */
break;
}
if (flags & USB_FLAG_CONFIGURED) {
int maxpower = usb_get_max_power(ui);
/* We may come here even when no configuration
* is selected. Send online/offline event
* accordingly.
*/
switch_set_state(&ui->sdev,
atomic_read(&ui->configured));
if (maxpower < 0)
break;
ui->chg_current = maxpower;
usb_phy_set_power(ui->xceiv, maxpower);
break;
}
if (flags & USB_FLAG_RESET) {
dev_dbg(&ui->pdev->dev,
"msm72k_udc: ONLINE -> RESET\n");
msm72k_pullup_internal(&ui->gadget, 0);
usb_reset(ui);
msm72k_pullup_internal(&ui->gadget, 1);
dev_dbg(&ui->pdev->dev,
"msm72k_udc: RESET -> ONLINE\n");
break;
}
break;
case USB_STATE_OFFLINE:
/* If we were signaled to go online and vbus is still
* present when we received the signal, go online.
*/
if ((flags & USB_FLAG_VBUS_ONLINE) && _vbus) {
int ret;
pm_runtime_get_noresume(&ui->pdev->dev);
pm_runtime_resume(&ui->pdev->dev);
dev_dbg(&ui->pdev->dev,
"msm72k_udc: OFFLINE -> ONLINE\n");
usb_reset(ui);
ui->state = USB_STATE_ONLINE;
usb_do_work_check_vbus(ui);
ret = request_irq(otg->irq, usb_interrupt,
IRQF_SHARED,
ui->pdev->name, ui);
/* FIXME: should we call BUG_ON when
* requst irq fails
*/
if (ret) {
dev_err(&ui->pdev->dev,
"hsusb: peripheral: request irq"
" failed:(%d)", ret);
break;
}
ui->irq = otg->irq;
enable_irq_wake(otg->irq);
if (!atomic_read(&ui->softconnect))
break;
msm72k_pullup_internal(&ui->gadget, 1);
if (!ui->gadget.is_a_peripheral)
schedule_delayed_work(
&ui->chg_det,
USB_CHG_DET_DELAY);
}
break;
}
}
}
/* FIXME - the callers of this function should use a gadget API instead.
* This is called from htc_battery.c and board-halibut.c
* WARNING - this can get called before this driver is initialized.
*/
void msm_hsusb_set_vbus_state(int online)
{
unsigned long flags;
struct usb_info *ui = the_usb_info;
if (!ui) {
pr_err("%s called before driver initialized\n", __func__);
return;
}
spin_lock_irqsave(&ui->lock, flags);
if (is_usb_online(ui) == online)
goto out;
if (online) {
ui->usb_state = USB_STATE_POWERED;
ui->flags |= USB_FLAG_VBUS_ONLINE;
} else {
ui->gadget.speed = USB_SPEED_UNKNOWN;
ui->usb_state = USB_STATE_NOTATTACHED;
ui->flags |= USB_FLAG_VBUS_OFFLINE;
ui->chg_type_retry_cnt = 0;
ui->proprietary_chg = false;
}
if (in_interrupt()) {
schedule_work(&ui->work);
} else {
spin_unlock_irqrestore(&ui->lock, flags);
usb_do_work(&ui->work);
return;
}
out:
spin_unlock_irqrestore(&ui->lock, flags);
}
#if defined(CONFIG_DEBUG_FS)
void usb_function_reenumerate(void)
{
struct usb_info *ui = the_usb_info;
/* disable and re-enable the D+ pullup */
dev_dbg(&ui->pdev->dev, "disable pullup\n");
writel(readl(USB_USBCMD) & ~USBCMD_RS, USB_USBCMD);
msleep(10);
dev_dbg(&ui->pdev->dev, "enable pullup\n");
writel(readl(USB_USBCMD) | USBCMD_RS, USB_USBCMD);
}
static char debug_buffer[PAGE_SIZE];
static ssize_t debug_read_status(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
struct usb_info *ui = file->private_data;
char *buf = debug_buffer;
unsigned long flags;
struct msm_endpoint *ept;
struct msm_request *req;
int n;
int i = 0;
spin_lock_irqsave(&ui->lock, flags);
i += scnprintf(buf + i, PAGE_SIZE - i,
"regs: setup=%08x prime=%08x stat=%08x done=%08x\n",
readl(USB_ENDPTSETUPSTAT),
readl(USB_ENDPTPRIME),
readl(USB_ENDPTSTAT),
readl(USB_ENDPTCOMPLETE));
i += scnprintf(buf + i, PAGE_SIZE - i,
"regs: cmd=%08x sts=%08x intr=%08x port=%08x\n\n",
readl(USB_USBCMD),
readl(USB_USBSTS),
readl(USB_USBINTR),
readl(USB_PORTSC));
for (n = 0; n < 32; n++) {
ept = ui->ept + n;
if (ept->ep.maxpacket == 0)
continue;
i += scnprintf(buf + i, PAGE_SIZE - i,
"ept%d %s cfg=%08x active=%08x next=%08x info=%08x\n",
ept->num, (ept->flags & EPT_FLAG_IN) ? "in " : "out",
ept->head->config, ept->head->active,
ept->head->next, ept->head->info);
for (req = ept->req; req; req = req->next)
i += scnprintf(buf + i, PAGE_SIZE - i,
" req @%08x next=%08x info=%08x page0=%08x %c %c\n",
req->item_dma, req->item->next,
req->item->info, req->item->page0,
req->busy ? 'B' : ' ',
req->live ? 'L' : ' ');
}
i += scnprintf(buf + i, PAGE_SIZE - i,
"phy failure count: %d\n", ui->phy_fail_count);
spin_unlock_irqrestore(&ui->lock, flags);
return simple_read_from_buffer(ubuf, count, ppos, buf, i);
}
static ssize_t debug_write_reset(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
struct usb_info *ui = file->private_data;
unsigned long flags;
spin_lock_irqsave(&ui->lock, flags);
ui->flags |= USB_FLAG_RESET;
schedule_work(&ui->work);
spin_unlock_irqrestore(&ui->lock, flags);
return count;
}
static ssize_t debug_write_cycle(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
usb_function_reenumerate();
return count;
}
static int debug_open(struct inode *inode, struct file *file)
{
file->private_data = inode->i_private;
return 0;
}
const struct file_operations debug_stat_ops = {
.open = debug_open,
.read = debug_read_status,
};
const struct file_operations debug_reset_ops = {
.open = debug_open,
.write = debug_write_reset,
};
const struct file_operations debug_cycle_ops = {
.open = debug_open,
.write = debug_write_cycle,
};
static ssize_t debug_read_release_wlocks(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
char kbuf[10];
size_t c = 0;
memset(kbuf, 0, 10);
c = scnprintf(kbuf, 10, "%d", release_wlocks);
if (copy_to_user(ubuf, kbuf, c))
return -EFAULT;
return c;
}
static ssize_t debug_write_release_wlocks(struct file *file,
const char __user *buf, size_t count, loff_t *ppos)
{
char kbuf[10];
long temp;
memset(kbuf, 0, 10);
if (copy_from_user(kbuf, buf, count > 10 ? 10 : count))
return -EFAULT;
if (strict_strtol(kbuf, 10, &temp))
return -EINVAL;
if (temp)
release_wlocks = 1;
else
release_wlocks = 0;
return count;
}
static int debug_wake_lock_open(struct inode *inode, struct file *file)
{
file->private_data = inode->i_private;
return 0;
}
const struct file_operations debug_wlocks_ops = {
.open = debug_wake_lock_open,
.read = debug_read_release_wlocks,
.write = debug_write_release_wlocks,
};
static ssize_t debug_reprime_ep(struct file *file, const char __user *ubuf,
size_t count, loff_t *ppos)
{
struct usb_info *ui = file->private_data;
struct msm_endpoint *ept;
char kbuf[10];
unsigned int ep_num, dir;
unsigned long flags;
unsigned n, i;
memset(kbuf, 0, 10);
if (copy_from_user(kbuf, ubuf, count > 10 ? 10 : count))
return -EFAULT;
if (sscanf(kbuf, "%u %u", &ep_num, &dir) != 2)
return -EINVAL;
if (dir)
i = ep_num + 16;
else
i = ep_num;
spin_lock_irqsave(&ui->lock, flags);
ept = ui->ept + i;
n = 1 << ept->bit;
if ((readl_relaxed(USB_ENDPTPRIME) & n))
goto out;
if (readl_relaxed(USB_ENDPTSTAT) & n)
goto out;
/* clear speculative loads on item->info */
rmb();
if (ept->req && (ept->req->item->info & INFO_ACTIVE)) {
pr_err("%s(): ept%d%s prime failed. ept: config: %x"
"active: %x next: %x info: %x\n",
__func__, ept->num,
ept->flags & EPT_FLAG_IN ? "in" : "out",
ept->head->config, ept->head->active,
ept->head->next, ept->head->info);
writel_relaxed(n, USB_ENDPTPRIME);
}
out:
spin_unlock_irqrestore(&ui->lock, flags);
return count;
}
static char buffer[512];
static ssize_t debug_prime_fail_read(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
struct usb_info *ui = file->private_data;
char *buf = buffer;
unsigned long flags;
struct msm_endpoint *ept;
int n;
int i = 0;
spin_lock_irqsave(&ui->lock, flags);
for (n = 0; n < 32; n++) {
ept = ui->ept + n;
if (ept->ep.maxpacket == 0)
continue;
i += scnprintf(buf + i, PAGE_SIZE - i,
"ept%d %s false_prime_count=%lu prime_fail_count=%d "
"dtd_fail_count=%lu "
"dTD_workaround_fail_count=%lu\n",
ept->num, (ept->flags & EPT_FLAG_IN) ? "in " : "out",
ept->false_prime_fail_count,
ept->actual_prime_fail_count,
ept->dTD_update_fail_count,
ept->dTD_workaround_fail_count);
}
i += scnprintf(buf + i, PAGE_SIZE - i,
"dTD_update_fail count: %lu\n",
ui->dTD_update_fail_count);
i += scnprintf(buf + i, PAGE_SIZE - i,
"prime_fail count: %d\n", ui->prime_fail_count);
i += scnprintf(buf + i, PAGE_SIZE - i,
"dtd_workaround_fail count: %lu\n",
ui->dTD_workaround_fail_count);
spin_unlock_irqrestore(&ui->lock, flags);
return simple_read_from_buffer(ubuf, count, ppos, buf, i);
}
static int debug_prime_fail_open(struct inode *inode, struct file *file)
{
file->private_data = inode->i_private;
return 0;
}
const struct file_operations prime_fail_ops = {
.open = debug_prime_fail_open,
.read = debug_prime_fail_read,
.write = debug_reprime_ep,
};
static ssize_t debug_prop_chg_write(struct file *file,
const char __user *buf, size_t count, loff_t *ppos)
{
struct usb_info *ui = file->private_data;
char kbuf[2];
memset(kbuf, 0, sizeof(kbuf));
if (copy_from_user(kbuf, buf, sizeof(kbuf)))
return -EFAULT;
if (!strncmp(kbuf, "1", 1))
ui->pdata->prop_chg = 1;
else
ui->pdata->prop_chg = 0;
return count;
}
static ssize_t debug_prop_chg_read(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
struct usb_info *ui = file->private_data;
char kbuf[2];
size_t c = 0;
memset(kbuf, 0, sizeof(kbuf));
c = scnprintf(kbuf, sizeof(kbuf), "%d\n", ui->pdata->prop_chg);
if (copy_to_user(ubuf, kbuf, c))
return -EFAULT;
return simple_read_from_buffer(ubuf, count, ppos, kbuf, c);
}
static int debug_prop_chg_open(struct inode *inode, struct file *file)
{
file->private_data = inode->i_private;
return 0;
}
const struct file_operations debug_prop_chg_ops = {
.open = debug_prop_chg_open,
.read = debug_prop_chg_read,
.write = debug_prop_chg_write,
};
static void usb_debugfs_init(struct usb_info *ui)
{
struct dentry *dent;
dent = debugfs_create_dir(dev_name(&ui->pdev->dev), 0);
if (IS_ERR(dent))
return;
debugfs_create_file("status", 0444, dent, ui, &debug_stat_ops);
debugfs_create_file("reset", 0222, dent, ui, &debug_reset_ops);
debugfs_create_file("cycle", 0222, dent, ui, &debug_cycle_ops);
debugfs_create_file("release_wlocks", 0666, dent, ui,
&debug_wlocks_ops);
debugfs_create_file("prime_fail_countt", 0666, dent, ui,
&prime_fail_ops);
debugfs_create_file("proprietary_chg", 0666, dent, ui,
&debug_prop_chg_ops);
}
#else
static void usb_debugfs_init(struct usb_info *ui) {}
#endif
static int
msm72k_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
{
struct msm_endpoint *ept;
unsigned char ep_type;
if (_ep == NULL || desc == NULL)
return -EINVAL;
ept = to_msm_endpoint(_ep);
ep_type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
_ep->maxpacket = le16_to_cpu(desc->wMaxPacketSize);
config_ept(ept);
ept->wedged = 0;
usb_ept_enable(ept, 1, ep_type);
return 0;
}
static int msm72k_disable(struct usb_ep *_ep)
{
struct msm_endpoint *ept = to_msm_endpoint(_ep);
usb_ept_enable(ept, 0, 0);
flush_endpoint(ept);
/*
* Clear descriptors here. Otherwise previous descriptors
* will be used by function drivers upon next enumeration.
*/
_ep->desc = NULL;
return 0;
}
static struct usb_request *
msm72k_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
{
return usb_ept_alloc_req(to_msm_endpoint(_ep), 0, gfp_flags);
}
static void
msm72k_free_request(struct usb_ep *_ep, struct usb_request *_req)
{
struct msm_request *req = to_msm_request(_req);
struct msm_endpoint *ept = to_msm_endpoint(_ep);
struct usb_info *ui = ept->ui;
/* request should not be busy */
BUG_ON(req->busy);
if (req->alloced)
kfree(req->req.buf);
dma_pool_free(ui->pool, req->item, req->item_dma);
kfree(req);
}
static int
msm72k_queue(struct usb_ep *_ep, struct usb_request *req, gfp_t gfp_flags)
{
struct msm_endpoint *ep = to_msm_endpoint(_ep);
struct usb_info *ui = ep->ui;
if (!atomic_read(&ui->softconnect))
return -ENODEV;
if (ep == &ui->ep0in) {
struct msm_request *r = to_msm_request(req);
if (!req->length)
goto ep_queue_done;
r->gadget_complete = req->complete;
/* ep0_queue_ack_complete queue a receive for ACK before
** calling req->complete
*/
req->complete = ep0_queue_ack_complete;
if (atomic_read(&ui->ep0_dir) == USB_DIR_OUT)
ep = &ui->ep0out;
goto ep_queue_done;
}
ep_queue_done:
return usb_ept_queue_xfer(ep, req);
}
static int msm72k_dequeue(struct usb_ep *_ep, struct usb_request *_req)
{
struct msm_endpoint *ep = to_msm_endpoint(_ep);
struct msm_request *req = to_msm_request(_req);
struct usb_info *ui = ep->ui;
struct msm_request *temp_req;
unsigned long flags;
if (ep->num == 0) {
/* Flush both out and in control endpoints */
flush_endpoint(&ui->ep0out);
flush_endpoint(&ui->ep0in);
return 0;
}
if (!(ui && req && ep->req))
return -EINVAL;
spin_lock_irqsave(&ui->lock, flags);
if (!req->busy) {
dev_dbg(&ui->pdev->dev, "%s: !req->busy\n", __func__);
spin_unlock_irqrestore(&ui->lock, flags);
return -EINVAL;
}
del_timer(&ep->prime_timer);
/* Stop the transfer */
do {
writel((1 << ep->bit), USB_ENDPTFLUSH);
while (readl(USB_ENDPTFLUSH) & (1 << ep->bit))
udelay(100);
} while (readl(USB_ENDPTSTAT) & (1 << ep->bit));
req->req.status = 0;
req->busy = 0;
if (ep->req == req) {
ep->req = req->next;
ep->head->next = req->item->next;
} else {
req->prev->next = req->next;
if (req->next)
req->next->prev = req->prev;
req->prev->item->next = req->item->next;
}
if (!req->next)
ep->last = req->prev;
/* initialize request to default */
req->item->next = TERMINATE;
req->item->info = 0;
req->live = 0;
dma_unmap_single(NULL, req->dma, req->req.length,
(ep->flags & EPT_FLAG_IN) ?
DMA_TO_DEVICE : DMA_FROM_DEVICE);
if (req->req.complete) {
req->req.status = -ECONNRESET;
spin_unlock_irqrestore(&ui->lock, flags);
req->req.complete(&ep->ep, &req->req);
spin_lock_irqsave(&ui->lock, flags);
}
if (!req->live) {
/* Reprime the endpoint for the remaining transfers */
for (temp_req = ep->req ; temp_req ; temp_req = temp_req->next)
temp_req->live = 0;
if (ep->req)
usb_ept_start(ep);
spin_unlock_irqrestore(&ui->lock, flags);
return 0;
}
spin_unlock_irqrestore(&ui->lock, flags);
return 0;
}
static int
usb_ept_set_halt(struct usb_ep *_ep, int value)
{
struct msm_endpoint *ept = to_msm_endpoint(_ep);
struct usb_info *ui = ept->ui;
unsigned int in = ept->flags & EPT_FLAG_IN;
unsigned int n;
unsigned long flags;
spin_lock_irqsave(&ui->lock, flags);
n = readl(USB_ENDPTCTRL(ept->num));
if (in) {
if (value)
n |= CTRL_TXS;
else {
n &= ~CTRL_TXS;
n |= CTRL_TXR;
}
} else {
if (value)
n |= CTRL_RXS;
else {
n &= ~CTRL_RXS;
n |= CTRL_RXR;
}
}
writel(n, USB_ENDPTCTRL(ept->num));
if (!value)
ept->wedged = 0;
spin_unlock_irqrestore(&ui->lock, flags);
return 0;
}
static int
msm72k_set_halt(struct usb_ep *_ep, int value)
{
struct msm_endpoint *ept = to_msm_endpoint(_ep);
unsigned int in = ept->flags & EPT_FLAG_IN;
if (value && in && ept->req)
return -EAGAIN;
usb_ept_set_halt(_ep, value);
return 0;
}
static int
msm72k_fifo_status(struct usb_ep *_ep)
{
return -EOPNOTSUPP;
}
static void
msm72k_fifo_flush(struct usb_ep *_ep)
{
flush_endpoint(to_msm_endpoint(_ep));
}
static int msm72k_set_wedge(struct usb_ep *_ep)
{
struct msm_endpoint *ept = to_msm_endpoint(_ep);
if (ept->num == 0)
return -EINVAL;
ept->wedged = 1;
return msm72k_set_halt(_ep, 1);
}
static const struct usb_ep_ops msm72k_ep_ops = {
.enable = msm72k_enable,
.disable = msm72k_disable,
.alloc_request = msm72k_alloc_request,
.free_request = msm72k_free_request,
.queue = msm72k_queue,
.dequeue = msm72k_dequeue,
.set_halt = msm72k_set_halt,
.set_wedge = msm72k_set_wedge,
.fifo_status = msm72k_fifo_status,
.fifo_flush = msm72k_fifo_flush,
};
static int msm72k_get_frame(struct usb_gadget *_gadget)
{
struct usb_info *ui = container_of(_gadget, struct usb_info, gadget);
/* frame number is in bits 13:3 */
return (readl(USB_FRINDEX) >> 3) & 0x000007FF;
}
/* VBUS reporting logically comes from a transceiver */
static int msm72k_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
{
struct usb_info *ui = container_of(_gadget, struct usb_info, gadget);
struct msm_otg *otg = to_msm_otg(ui->xceiv);
if (is_active || atomic_read(&otg->chg_type)
== USB_CHG_TYPE__WALLCHARGER)
wake_lock(&ui->wlock);
msm_hsusb_set_vbus_state(is_active);
return 0;
}
/* SW workarounds
Issue #1 - USB Spoof Disconnect Failure
Symptom - Writing 0 to run/stop bit of USBCMD doesn't cause disconnect
SW workaround - Making opmode non-driving and SuspendM set in function
register of SMSC phy
*/
/* drivers may have software control over D+ pullup */
static int msm72k_pullup_internal(struct usb_gadget *_gadget, int is_active)
{
struct usb_info *ui = container_of(_gadget, struct usb_info, gadget);
unsigned long flags;
if (is_active) {
spin_lock_irqsave(&ui->lock, flags);
if (is_usb_online(ui) && ui->driver)
writel(readl(USB_USBCMD) | USBCMD_RS, USB_USBCMD);
spin_unlock_irqrestore(&ui->lock, flags);
} else {
writel(readl(USB_USBCMD) & ~USBCMD_RS, USB_USBCMD);
/* S/W workaround, Issue#1 */
usb_phy_io_write(ui->xceiv, 0x48, 0x04);
}
/* Ensure pull-up operation is completed before returning */
mb();
return 0;
}
static int msm72k_pullup(struct usb_gadget *_gadget, int is_active)
{
struct usb_info *ui = container_of(_gadget, struct usb_info, gadget);
struct msm_otg *otg = to_msm_otg(ui->xceiv);
unsigned long flags;
atomic_set(&ui->softconnect, is_active);
spin_lock_irqsave(&ui->lock, flags);
if (ui->usb_state == USB_STATE_NOTATTACHED || ui->driver == NULL ||
atomic_read(&otg->chg_type) == USB_CHG_TYPE__WALLCHARGER) {
spin_unlock_irqrestore(&ui->lock, flags);
return 0;
}
spin_unlock_irqrestore(&ui->lock, flags);
msm72k_pullup_internal(_gadget, is_active);
if (is_active && !ui->gadget.is_a_peripheral)
schedule_delayed_work(&ui->chg_det, USB_CHG_DET_DELAY);
return 0;
}
static int msm72k_wakeup(struct usb_gadget *_gadget)
{
struct usb_info *ui = container_of(_gadget, struct usb_info, gadget);
struct msm_otg *otg = to_msm_otg(ui->xceiv);
if (!atomic_read(&ui->remote_wakeup)) {
dev_err(&ui->pdev->dev,
"%s: remote wakeup not supported\n", __func__);
return -ENOTSUPP;
}
if (!atomic_read(&ui->configured)) {
dev_err(&ui->pdev->dev,
"%s: device is not configured\n", __func__);
return -ENODEV;
}
usb_phy_set_suspend(ui->xceiv, 0);
disable_irq(otg->irq);
if (!is_usb_active())
writel(readl(USB_PORTSC) | PORTSC_FPR, USB_PORTSC);
/* Ensure that USB port is resumed before enabling the IRQ */
mb();
enable_irq(otg->irq);
return 0;
}
/* when Gadget is configured, it will indicate how much power
* can be pulled from vbus, as specified in configuiration descriptor
*/
static int msm72k_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
{
struct usb_info *ui = container_of(_gadget, struct usb_info, gadget);
unsigned long flags;
spin_lock_irqsave(&ui->lock, flags);
ui->b_max_pow = mA;
ui->flags = USB_FLAG_CONFIGURED;
spin_unlock_irqrestore(&ui->lock, flags);
schedule_work(&ui->work);
return 0;
}
static int msm72k_set_selfpowered(struct usb_gadget *_gadget, int set)
{
struct usb_info *ui = container_of(_gadget, struct usb_info, gadget);
unsigned long flags;
int ret = 0;
spin_lock_irqsave(&ui->lock, flags);
if (set) {
if (ui->pdata && ui->pdata->self_powered)
atomic_set(&ui->self_powered, 1);
else
ret = -EOPNOTSUPP;
} else {
/* We can always work as a bus powered device */
atomic_set(&ui->self_powered, 0);
}
spin_unlock_irqrestore(&ui->lock, flags);
return ret;
}
static int msm72k_gadget_start(struct usb_gadget_driver *driver,
int (*bind)(struct usb_gadget *));
static int msm72k_gadget_stop(struct usb_gadget_driver *driver);
static const struct usb_gadget_ops msm72k_ops = {
.get_frame = msm72k_get_frame,
.vbus_session = msm72k_udc_vbus_session,
.vbus_draw = msm72k_udc_vbus_draw,
.pullup = msm72k_pullup,
.wakeup = msm72k_wakeup,
.set_selfpowered = msm72k_set_selfpowered,
.start = msm72k_gadget_start,
.stop = msm72k_gadget_stop
};
static void usb_do_remote_wakeup(struct work_struct *w)
{
struct usb_info *ui = the_usb_info;
msm72k_wakeup(&ui->gadget);
}
static ssize_t usb_remote_wakeup(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct usb_info *ui = the_usb_info;
msm72k_wakeup(&ui->gadget);
return count;
}
static ssize_t show_usb_state(struct device *dev, struct device_attribute *attr,
char *buf)
{
size_t i;
char *state[] = {"USB_STATE_NOTATTACHED", "USB_STATE_ATTACHED",
"USB_STATE_POWERED", "USB_STATE_UNAUTHENTICATED",
"USB_STATE_RECONNECTING", "USB_STATE_DEFAULT",
"USB_STATE_ADDRESS", "USB_STATE_CONFIGURED",
"USB_STATE_SUSPENDED"
};
i = scnprintf(buf, PAGE_SIZE, "%s\n", state[msm_hsusb_get_state()]);
return i;
}
static ssize_t show_usb_speed(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct usb_info *ui = the_usb_info;
size_t i;
char *speed[] = {"USB_SPEED_UNKNOWN", "USB_SPEED_LOW",
"USB_SPEED_FULL", "USB_SPEED_HIGH"};
i = scnprintf(buf, PAGE_SIZE, "%s\n", speed[ui->gadget.speed]);
return i;
}
static ssize_t store_usb_chg_current(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct usb_info *ui = the_usb_info;
unsigned long mA;
if (ui->gadget.is_a_peripheral)
return -EINVAL;
if (strict_strtoul(buf, 10, &mA))
return -EINVAL;
ui->chg_current = mA;
usb_phy_set_power(ui->xceiv, mA);
return count;
}
static ssize_t show_usb_chg_current(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct usb_info *ui = the_usb_info;
size_t count;
count = snprintf(buf, PAGE_SIZE, "%d", ui->chg_current);
return count;
}
static ssize_t show_usb_chg_type(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct usb_info *ui = the_usb_info;
struct msm_otg *otg = to_msm_otg(ui->xceiv);
size_t count;
char *chg_type[] = {"STD DOWNSTREAM PORT",
"CARKIT",
"DEDICATED CHARGER",
"INVALID"};
count = snprintf(buf, PAGE_SIZE, "%s",
chg_type[atomic_read(&otg->chg_type)]);
return count;
}
static DEVICE_ATTR(wakeup, S_IWUSR, 0, usb_remote_wakeup);
static DEVICE_ATTR(usb_state, S_IRUSR, show_usb_state, 0);
static DEVICE_ATTR(usb_speed, S_IRUSR, show_usb_speed, 0);
static DEVICE_ATTR(chg_type, S_IRUSR, show_usb_chg_type, 0);
static DEVICE_ATTR(chg_current, S_IWUSR | S_IRUSR,
show_usb_chg_current, store_usb_chg_current);
#ifdef CONFIG_USB_OTG
static ssize_t store_host_req(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct usb_info *ui = the_usb_info;
unsigned long val, flags;
if (strict_strtoul(buf, 10, &val))
return -EINVAL;
dev_dbg(&ui->pdev->dev, "%s host request\n",
val ? "set" : "clear");
spin_lock_irqsave(&ui->lock, flags);
if (ui->hnp_avail)
ui->gadget.host_request = !!val;
spin_unlock_irqrestore(&ui->lock, flags);
return count;
}
static DEVICE_ATTR(host_request, S_IWUSR, NULL, store_host_req);
/* How do we notify user space about HNP availability?
* As we are compliant to Rev 2.0, Host will not set a_hnp_support.
* Introduce hnp_avail flag and set when HNP polling request arrives.
* The expectation is that user space checks hnp availability before
* requesting host role via above sysfs node.
*/
static ssize_t show_host_avail(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct usb_info *ui = the_usb_info;
size_t count;
unsigned long flags;
spin_lock_irqsave(&ui->lock, flags);
count = snprintf(buf, PAGE_SIZE, "%d\n", ui->hnp_avail);
spin_unlock_irqrestore(&ui->lock, flags);
return count;
}
static DEVICE_ATTR(host_avail, S_IRUSR, show_host_avail, NULL);
static struct attribute *otg_attrs[] = {
&dev_attr_host_request.attr,
&dev_attr_host_avail.attr,
NULL,
};
static struct attribute_group otg_attr_grp = {
.name = "otg",
.attrs = otg_attrs,
};
#endif
static int msm72k_probe(struct platform_device *pdev)
{
struct usb_info *ui;
struct msm_otg *otg;
int retval;
dev_dbg(&pdev->dev, "msm72k_probe\n");
ui = kzalloc(sizeof(struct usb_info), GFP_KERNEL);
if (!ui)
return -ENOMEM;
ui->pdev = pdev;
ui->pdata = pdev->dev.platform_data;
ui->buf = dma_alloc_coherent(&pdev->dev, 4096, &ui->dma, GFP_KERNEL);
if (!ui->buf)
return usb_free(ui, -ENOMEM);
ui->pool = dma_pool_create("msm72k_udc", NULL, 32, 32, 0);
if (!ui->pool)
return usb_free(ui, -ENOMEM);
ui->xceiv = usb_get_transceiver();
if (!ui->xceiv)
return usb_free(ui, -ENODEV);
otg = to_msm_otg(ui->xceiv);
ui->addr = otg->regs;
ui->gadget.ops = &msm72k_ops;
ui->gadget.max_speed = USB_SPEED_HIGH;
device_initialize(&ui->gadget.dev);
dev_set_name(&ui->gadget.dev, "gadget");
ui->gadget.dev.parent = &pdev->dev;
ui->gadget.dev.dma_mask = pdev->dev.dma_mask;
#ifdef CONFIG_USB_OTG
ui->gadget.is_otg = 1;
#endif
retval = usb_add_gadget_udc(&pdev->dev, &ui->gadget);
if (retval)
return usb_free(ui, retval);
ui->sdev.name = DRIVER_NAME;
ui->sdev.print_name = print_switch_name;
ui->sdev.print_state = print_switch_state;
retval = switch_dev_register(&ui->sdev);
if (retval)
return usb_free(ui, retval);
the_usb_info = ui;
wake_lock_init(&ui->wlock,
WAKE_LOCK_SUSPEND, "usb_bus_active");
usb_debugfs_init(ui);
usb_prepare(ui);
#ifdef CONFIG_USB_OTG
retval = sysfs_create_group(&pdev->dev.kobj, &otg_attr_grp);
if (retval) {
dev_err(&ui->pdev->dev,
"failed to create otg sysfs directory:"
"err:(%d)\n", retval);
}
#endif
retval = otg_set_peripheral(ui->xceiv->otg, &ui->gadget);
if (retval) {
dev_err(&ui->pdev->dev,
"%s: Cannot bind the transceiver, retval:(%d)\n",
__func__, retval);
switch_dev_unregister(&ui->sdev);
wake_lock_destroy(&ui->wlock);
return usb_free(ui, retval);
}
pm_runtime_enable(&pdev->dev);
/* Setup phy stuck timer */
if (ui->pdata && ui->pdata->is_phy_status_timer_on)
setup_timer(&phy_status_timer, usb_phy_status_check_timer, 0);
return 0;
}
static int msm72k_gadget_start(struct usb_gadget_driver *driver,
int (*bind)(struct usb_gadget *))
{
struct usb_info *ui = the_usb_info;
int retval, n;
if (!driver
|| driver->max_speed < USB_SPEED_FULL
|| !bind
|| !driver->disconnect
|| !driver->setup)
return -EINVAL;
if (!ui)
return -ENODEV;
if (ui->driver)
return -EBUSY;
/* first hook up the driver ... */
ui->driver = driver;
ui->gadget.dev.driver = &driver->driver;
ui->gadget.name = driver_name;
INIT_LIST_HEAD(&ui->gadget.ep_list);
ui->gadget.ep0 = &ui->ep0in.ep;
INIT_LIST_HEAD(&ui->gadget.ep0->ep_list);
ui->gadget.speed = USB_SPEED_UNKNOWN;
atomic_set(&ui->softconnect, 1);
for (n = 1; n < 16; n++) {
struct msm_endpoint *ept = ui->ept + n;
list_add_tail(&ept->ep.ep_list, &ui->gadget.ep_list);
ept->ep.maxpacket = 512;
}
for (n = 17; n < 32; n++) {
struct msm_endpoint *ept = ui->ept + n;
list_add_tail(&ept->ep.ep_list, &ui->gadget.ep_list);
ept->ep.maxpacket = 512;
}
retval = device_add(&ui->gadget.dev);
if (retval)
goto fail;
retval = bind(&ui->gadget);
if (retval) {
dev_err(&ui->pdev->dev, "bind to driver %s --> error %d\n",
driver->driver.name, retval);
device_del(&ui->gadget.dev);
goto fail;
}
retval = device_create_file(&ui->gadget.dev, &dev_attr_wakeup);
if (retval != 0)
dev_err(&ui->pdev->dev, "failed to create sysfs entry:"
"(wakeup) error: (%d)\n", retval);
retval = device_create_file(&ui->gadget.dev, &dev_attr_usb_state);
if (retval != 0)
dev_err(&ui->pdev->dev, "failed to create sysfs entry:"
" (usb_state) error: (%d)\n", retval);
retval = device_create_file(&ui->gadget.dev, &dev_attr_usb_speed);
if (retval != 0)
dev_err(&ui->pdev->dev, "failed to create sysfs entry:"
" (usb_speed) error: (%d)\n", retval);
retval = device_create_file(&ui->gadget.dev, &dev_attr_chg_type);
if (retval != 0)
dev_err(&ui->pdev->dev,
"failed to create sysfs entry(chg_type): err:(%d)\n",
retval);
retval = device_create_file(&ui->gadget.dev, &dev_attr_chg_current);
if (retval != 0)
dev_err(&ui->pdev->dev,
"failed to create sysfs entry(chg_current):"
"err:(%d)\n", retval);
dev_dbg(&ui->pdev->dev, "registered gadget driver '%s'\n",
driver->driver.name);
usb_start(ui);
return 0;
fail:
ui->driver = NULL;
ui->gadget.dev.driver = NULL;
return retval;
}
static int msm72k_gadget_stop(struct usb_gadget_driver *driver)
{
struct usb_info *dev = the_usb_info;
if (!dev)
return -ENODEV;
if (!driver || driver != dev->driver || !driver->unbind)
return -EINVAL;
msm72k_pullup_internal(&dev->gadget, 0);
if (dev->irq) {
free_irq(dev->irq, dev);
dev->irq = 0;
}
dev->state = USB_STATE_IDLE;
atomic_set(&dev->configured, 0);
switch_set_state(&dev->sdev, 0);
/* cancel pending ep0 transactions */
flush_endpoint(&dev->ep0out);
flush_endpoint(&dev->ep0in);
device_remove_file(&dev->gadget.dev, &dev_attr_wakeup);
device_remove_file(&dev->gadget.dev, &dev_attr_usb_state);
device_remove_file(&dev->gadget.dev, &dev_attr_usb_speed);
device_remove_file(&dev->gadget.dev, &dev_attr_chg_type);
device_remove_file(&dev->gadget.dev, &dev_attr_chg_current);
driver->disconnect(&dev->gadget);
driver->unbind(&dev->gadget);
dev->gadget.dev.driver = NULL;
dev->driver = NULL;
device_del(&dev->gadget.dev);
dev_dbg(&dev->pdev->dev,
"unregistered gadget driver '%s'\n", driver->driver.name);
return 0;
}
static int msm72k_udc_runtime_suspend(struct device *dev)
{
dev_dbg(dev, "pm_runtime: suspending...\n");
return 0;
}
static int msm72k_udc_runtime_resume(struct device *dev)
{
dev_dbg(dev, "pm_runtime: resuming...\n");
return 0;
}
static int msm72k_udc_runtime_idle(struct device *dev)
{
dev_dbg(dev, "pm_runtime: idling...\n");
return 0;
}
static struct dev_pm_ops msm72k_udc_dev_pm_ops = {
.runtime_suspend = msm72k_udc_runtime_suspend,
.runtime_resume = msm72k_udc_runtime_resume,
.runtime_idle = msm72k_udc_runtime_idle
};
static int __exit msm72k_remove(struct platform_device *pdev)
{
struct usb_info *ui = container_of(&pdev, struct usb_info, pdev);
return usb_free(ui, 0);
}
static struct platform_driver usb_driver = {
.probe = msm72k_probe,
.remove = msm72k_remove,
.driver = { .name = "msm_hsusb",
.pm = &msm72k_udc_dev_pm_ops, },
};
static int __init init(void)
{
return platform_driver_register(&usb_driver);
}
module_init(init);
static void __exit cleanup(void)
{
platform_driver_unregister(&usb_driver);
}
module_exit(cleanup);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Mike Lockwood, Brian Swetland");
MODULE_LICENSE("GPL");
Reference in New Issue Copy Permalink