1 /* Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 #include <linux/module.h>
20 #include <linux/device.h>
21 #include <linux/platform_device.h>
22 #include <linux/clk.h>
23 #include <linux/slab.h>
24 #include <linux/interrupt.h>
25 #include <linux/err.h>
26 #include <linux/delay.h>
28 #include <linux/ioport.h>
29 #include <linux/uaccess.h>
30 #include <linux/debugfs.h>
31 #include <linux/seq_file.h>
32 #include <linux/pm_runtime.h>
34 #include <linux/usb.h>
35 #include <linux/usb/otg.h>
36 #include <linux/usb/ulpi.h>
37 #include <linux/usb/gadget.h>
38 #include <linux/usb/hcd.h>
39 #include <linux/usb/msm_hsusb.h>
40 #include <linux/usb/msm_hsusb_hw.h>
41 #include <linux/regulator/consumer.h>
43 #define MSM_USB_BASE (motg->regs)
44 #define DRIVER_NAME "msm_otg"
46 #define ULPI_IO_TIMEOUT_USEC (10 * 1000)
48 #define USB_PHY_3P3_VOL_MIN 3050000 /* uV */
49 #define USB_PHY_3P3_VOL_MAX 3300000 /* uV */
50 #define USB_PHY_3P3_HPM_LOAD 50000 /* uA */
51 #define USB_PHY_3P3_LPM_LOAD 4000 /* uA */
53 #define USB_PHY_1P8_VOL_MIN 1800000 /* uV */
54 #define USB_PHY_1P8_VOL_MAX 1800000 /* uV */
55 #define USB_PHY_1P8_HPM_LOAD 50000 /* uA */
56 #define USB_PHY_1P8_LPM_LOAD 4000 /* uA */
58 #define USB_PHY_VDD_DIG_VOL_MIN 1000000 /* uV */
59 #define USB_PHY_VDD_DIG_VOL_MAX 1320000 /* uV */
61 static struct regulator
*hsusb_3p3
;
62 static struct regulator
*hsusb_1p8
;
63 static struct regulator
*hsusb_vddcx
;
65 static int msm_hsusb_init_vddcx(struct msm_otg
*motg
, int init
)
70 hsusb_vddcx
= regulator_get(motg
->phy
.dev
, "HSUSB_VDDCX");
71 if (IS_ERR(hsusb_vddcx
)) {
72 dev_err(motg
->phy
.dev
, "unable to get hsusb vddcx\n");
73 return PTR_ERR(hsusb_vddcx
);
76 ret
= regulator_set_voltage(hsusb_vddcx
,
77 USB_PHY_VDD_DIG_VOL_MIN
,
78 USB_PHY_VDD_DIG_VOL_MAX
);
80 dev_err(motg
->phy
.dev
, "unable to set the voltage "
82 regulator_put(hsusb_vddcx
);
86 ret
= regulator_enable(hsusb_vddcx
);
88 dev_err(motg
->phy
.dev
, "unable to enable hsusb vddcx\n");
89 regulator_put(hsusb_vddcx
);
92 ret
= regulator_set_voltage(hsusb_vddcx
, 0,
93 USB_PHY_VDD_DIG_VOL_MAX
);
95 dev_err(motg
->phy
.dev
, "unable to set the voltage "
97 ret
= regulator_disable(hsusb_vddcx
);
99 dev_err(motg
->phy
.dev
, "unable to disable hsusb vddcx\n");
101 regulator_put(hsusb_vddcx
);
107 static int msm_hsusb_ldo_init(struct msm_otg
*motg
, int init
)
112 hsusb_3p3
= regulator_get(motg
->phy
.dev
, "HSUSB_3p3");
113 if (IS_ERR(hsusb_3p3
)) {
114 dev_err(motg
->phy
.dev
, "unable to get hsusb 3p3\n");
115 return PTR_ERR(hsusb_3p3
);
118 rc
= regulator_set_voltage(hsusb_3p3
, USB_PHY_3P3_VOL_MIN
,
119 USB_PHY_3P3_VOL_MAX
);
121 dev_err(motg
->phy
.dev
, "unable to set voltage level "
125 rc
= regulator_enable(hsusb_3p3
);
127 dev_err(motg
->phy
.dev
, "unable to enable the hsusb 3p3\n");
130 hsusb_1p8
= regulator_get(motg
->phy
.dev
, "HSUSB_1p8");
131 if (IS_ERR(hsusb_1p8
)) {
132 dev_err(motg
->phy
.dev
, "unable to get hsusb 1p8\n");
133 rc
= PTR_ERR(hsusb_1p8
);
136 rc
= regulator_set_voltage(hsusb_1p8
, USB_PHY_1P8_VOL_MIN
,
137 USB_PHY_1P8_VOL_MAX
);
139 dev_err(motg
->phy
.dev
, "unable to set voltage level "
143 rc
= regulator_enable(hsusb_1p8
);
145 dev_err(motg
->phy
.dev
, "unable to enable the hsusb 1p8\n");
152 regulator_disable(hsusb_1p8
);
154 regulator_put(hsusb_1p8
);
156 regulator_disable(hsusb_3p3
);
158 regulator_put(hsusb_3p3
);
162 static int msm_hsusb_ldo_set_mode(int on
)
166 if (!hsusb_1p8
|| IS_ERR(hsusb_1p8
)) {
167 pr_err("%s: HSUSB_1p8 is not initialized\n", __func__
);
171 if (!hsusb_3p3
|| IS_ERR(hsusb_3p3
)) {
172 pr_err("%s: HSUSB_3p3 is not initialized\n", __func__
);
177 ret
= regulator_set_optimum_mode(hsusb_1p8
,
178 USB_PHY_1P8_HPM_LOAD
);
180 pr_err("%s: Unable to set HPM of the regulator "
181 "HSUSB_1p8\n", __func__
);
184 ret
= regulator_set_optimum_mode(hsusb_3p3
,
185 USB_PHY_3P3_HPM_LOAD
);
187 pr_err("%s: Unable to set HPM of the regulator "
188 "HSUSB_3p3\n", __func__
);
189 regulator_set_optimum_mode(hsusb_1p8
,
190 USB_PHY_1P8_LPM_LOAD
);
194 ret
= regulator_set_optimum_mode(hsusb_1p8
,
195 USB_PHY_1P8_LPM_LOAD
);
197 pr_err("%s: Unable to set LPM of the regulator "
198 "HSUSB_1p8\n", __func__
);
199 ret
= regulator_set_optimum_mode(hsusb_3p3
,
200 USB_PHY_3P3_LPM_LOAD
);
202 pr_err("%s: Unable to set LPM of the regulator "
203 "HSUSB_3p3\n", __func__
);
206 pr_debug("reg (%s)\n", on
? "HPM" : "LPM");
207 return ret
< 0 ? ret
: 0;
210 static int ulpi_read(struct usb_phy
*phy
, u32 reg
)
212 struct msm_otg
*motg
= container_of(phy
, struct msm_otg
, phy
);
215 /* initiate read operation */
216 writel(ULPI_RUN
| ULPI_READ
| ULPI_ADDR(reg
),
219 /* wait for completion */
220 while (cnt
< ULPI_IO_TIMEOUT_USEC
) {
221 if (!(readl(USB_ULPI_VIEWPORT
) & ULPI_RUN
))
227 if (cnt
>= ULPI_IO_TIMEOUT_USEC
) {
228 dev_err(phy
->dev
, "ulpi_read: timeout %08x\n",
229 readl(USB_ULPI_VIEWPORT
));
232 return ULPI_DATA_READ(readl(USB_ULPI_VIEWPORT
));
235 static int ulpi_write(struct usb_phy
*phy
, u32 val
, u32 reg
)
237 struct msm_otg
*motg
= container_of(phy
, struct msm_otg
, phy
);
240 /* initiate write operation */
241 writel(ULPI_RUN
| ULPI_WRITE
|
242 ULPI_ADDR(reg
) | ULPI_DATA(val
),
245 /* wait for completion */
246 while (cnt
< ULPI_IO_TIMEOUT_USEC
) {
247 if (!(readl(USB_ULPI_VIEWPORT
) & ULPI_RUN
))
253 if (cnt
>= ULPI_IO_TIMEOUT_USEC
) {
254 dev_err(phy
->dev
, "ulpi_write: timeout\n");
260 static struct usb_phy_io_ops msm_otg_io_ops
= {
265 static void ulpi_init(struct msm_otg
*motg
)
267 struct msm_otg_platform_data
*pdata
= motg
->pdata
;
268 int *seq
= pdata
->phy_init_seq
;
273 while (seq
[0] >= 0) {
274 dev_vdbg(motg
->phy
.dev
, "ulpi: write 0x%02x to 0x%02x\n",
276 ulpi_write(&motg
->phy
, seq
[0], seq
[1]);
281 static int msm_otg_link_clk_reset(struct msm_otg
*motg
, bool assert)
285 if (!motg
->pdata
->link_clk_reset
)
288 ret
= motg
->pdata
->link_clk_reset(motg
->clk
, assert);
290 dev_err(motg
->phy
.dev
, "usb link clk reset %s failed\n",
291 assert ? "assert" : "deassert");
296 static int msm_otg_phy_clk_reset(struct msm_otg
*motg
)
300 if (!motg
->pdata
->phy_clk_reset
)
303 ret
= motg
->pdata
->phy_clk_reset(motg
->phy_reset_clk
);
305 dev_err(motg
->phy
.dev
, "usb phy clk reset failed\n");
310 static int msm_otg_phy_reset(struct msm_otg
*motg
)
316 ret
= msm_otg_link_clk_reset(motg
, 1);
319 ret
= msm_otg_phy_clk_reset(motg
);
322 ret
= msm_otg_link_clk_reset(motg
, 0);
326 val
= readl(USB_PORTSC
) & ~PORTSC_PTS_MASK
;
327 writel(val
| PORTSC_PTS_ULPI
, USB_PORTSC
);
329 for (retries
= 3; retries
> 0; retries
--) {
330 ret
= ulpi_write(&motg
->phy
, ULPI_FUNC_CTRL_SUSPENDM
,
331 ULPI_CLR(ULPI_FUNC_CTRL
));
334 ret
= msm_otg_phy_clk_reset(motg
);
341 /* This reset calibrates the phy, if the above write succeeded */
342 ret
= msm_otg_phy_clk_reset(motg
);
346 for (retries
= 3; retries
> 0; retries
--) {
347 ret
= ulpi_read(&motg
->phy
, ULPI_DEBUG
);
348 if (ret
!= -ETIMEDOUT
)
350 ret
= msm_otg_phy_clk_reset(motg
);
357 dev_info(motg
->phy
.dev
, "phy_reset: success\n");
361 #define LINK_RESET_TIMEOUT_USEC (250 * 1000)
362 static int msm_otg_reset(struct usb_phy
*phy
)
364 struct msm_otg
*motg
= container_of(phy
, struct msm_otg
, phy
);
365 struct msm_otg_platform_data
*pdata
= motg
->pdata
;
371 ret
= msm_otg_phy_reset(motg
);
373 dev_err(phy
->dev
, "phy_reset failed\n");
379 writel(USBCMD_RESET
, USB_USBCMD
);
380 while (cnt
< LINK_RESET_TIMEOUT_USEC
) {
381 if (!(readl(USB_USBCMD
) & USBCMD_RESET
))
386 if (cnt
>= LINK_RESET_TIMEOUT_USEC
)
389 /* select ULPI phy */
390 writel(0x80000000, USB_PORTSC
);
394 writel(0x0, USB_AHBBURST
);
395 writel(0x00, USB_AHBMODE
);
397 if (pdata
->otg_control
== OTG_PHY_CONTROL
) {
398 val
= readl(USB_OTGSC
);
399 if (pdata
->mode
== USB_OTG
) {
400 ulpi_val
= ULPI_INT_IDGRD
| ULPI_INT_SESS_VALID
;
401 val
|= OTGSC_IDIE
| OTGSC_BSVIE
;
402 } else if (pdata
->mode
== USB_PERIPHERAL
) {
403 ulpi_val
= ULPI_INT_SESS_VALID
;
406 writel(val
, USB_OTGSC
);
407 ulpi_write(phy
, ulpi_val
, ULPI_USB_INT_EN_RISE
);
408 ulpi_write(phy
, ulpi_val
, ULPI_USB_INT_EN_FALL
);
414 #define PHY_SUSPEND_TIMEOUT_USEC (500 * 1000)
415 #define PHY_RESUME_TIMEOUT_USEC (100 * 1000)
419 #define USB_PHY_SUSP_DIG_VOL 500000
420 static int msm_hsusb_config_vddcx(int high
)
422 int max_vol
= USB_PHY_VDD_DIG_VOL_MAX
;
427 min_vol
= USB_PHY_VDD_DIG_VOL_MIN
;
429 min_vol
= USB_PHY_SUSP_DIG_VOL
;
431 ret
= regulator_set_voltage(hsusb_vddcx
, min_vol
, max_vol
);
433 pr_err("%s: unable to set the voltage for regulator "
434 "HSUSB_VDDCX\n", __func__
);
438 pr_debug("%s: min_vol:%d max_vol:%d\n", __func__
, min_vol
, max_vol
);
443 static int msm_otg_suspend(struct msm_otg
*motg
)
445 struct usb_phy
*phy
= &motg
->phy
;
446 struct usb_bus
*bus
= phy
->otg
->host
;
447 struct msm_otg_platform_data
*pdata
= motg
->pdata
;
450 if (atomic_read(&motg
->in_lpm
))
453 disable_irq(motg
->irq
);
455 * Chipidea 45-nm PHY suspend sequence:
457 * Interrupt Latch Register auto-clear feature is not present
458 * in all PHY versions. Latch register is clear on read type.
459 * Clear latch register to avoid spurious wakeup from
460 * low power mode (LPM).
462 * PHY comparators are disabled when PHY enters into low power
463 * mode (LPM). Keep PHY comparators ON in LPM only when we expect
464 * VBUS/Id notifications from USB PHY. Otherwise turn off USB
465 * PHY comparators. This save significant amount of power.
467 * PLL is not turned off when PHY enters into low power mode (LPM).
468 * Disable PLL for maximum power savings.
471 if (motg
->pdata
->phy_type
== CI_45NM_INTEGRATED_PHY
) {
472 ulpi_read(phy
, 0x14);
473 if (pdata
->otg_control
== OTG_PHY_CONTROL
)
474 ulpi_write(phy
, 0x01, 0x30);
475 ulpi_write(phy
, 0x08, 0x09);
479 * PHY may take some time or even fail to enter into low power
480 * mode (LPM). Hence poll for 500 msec and reset the PHY and link
483 writel(readl(USB_PORTSC
) | PORTSC_PHCD
, USB_PORTSC
);
484 while (cnt
< PHY_SUSPEND_TIMEOUT_USEC
) {
485 if (readl(USB_PORTSC
) & PORTSC_PHCD
)
491 if (cnt
>= PHY_SUSPEND_TIMEOUT_USEC
) {
492 dev_err(phy
->dev
, "Unable to suspend PHY\n");
494 enable_irq(motg
->irq
);
499 * PHY has capability to generate interrupt asynchronously in low
500 * power mode (LPM). This interrupt is level triggered. So USB IRQ
501 * line must be disabled till async interrupt enable bit is cleared
502 * in USBCMD register. Assert STP (ULPI interface STOP signal) to
503 * block data communication from PHY.
505 writel(readl(USB_USBCMD
) | ASYNC_INTR_CTRL
| ULPI_STP_CTRL
, USB_USBCMD
);
507 if (motg
->pdata
->phy_type
== SNPS_28NM_INTEGRATED_PHY
&&
508 motg
->pdata
->otg_control
== OTG_PMIC_CONTROL
)
509 writel(readl(USB_PHY_CTRL
) | PHY_RETEN
, USB_PHY_CTRL
);
511 clk_disable_unprepare(motg
->pclk
);
512 clk_disable_unprepare(motg
->clk
);
514 clk_disable_unprepare(motg
->core_clk
);
516 if (!IS_ERR(motg
->pclk_src
))
517 clk_disable_unprepare(motg
->pclk_src
);
519 if (motg
->pdata
->phy_type
== SNPS_28NM_INTEGRATED_PHY
&&
520 motg
->pdata
->otg_control
== OTG_PMIC_CONTROL
) {
521 msm_hsusb_ldo_set_mode(0);
522 msm_hsusb_config_vddcx(0);
525 if (device_may_wakeup(phy
->dev
))
526 enable_irq_wake(motg
->irq
);
528 clear_bit(HCD_FLAG_HW_ACCESSIBLE
, &(bus_to_hcd(bus
))->flags
);
530 atomic_set(&motg
->in_lpm
, 1);
531 enable_irq(motg
->irq
);
533 dev_info(phy
->dev
, "USB in low power mode\n");
538 static int msm_otg_resume(struct msm_otg
*motg
)
540 struct usb_phy
*phy
= &motg
->phy
;
541 struct usb_bus
*bus
= phy
->otg
->host
;
545 if (!atomic_read(&motg
->in_lpm
))
548 if (!IS_ERR(motg
->pclk_src
))
549 clk_prepare_enable(motg
->pclk_src
);
551 clk_prepare_enable(motg
->pclk
);
552 clk_prepare_enable(motg
->clk
);
554 clk_prepare_enable(motg
->core_clk
);
556 if (motg
->pdata
->phy_type
== SNPS_28NM_INTEGRATED_PHY
&&
557 motg
->pdata
->otg_control
== OTG_PMIC_CONTROL
) {
558 msm_hsusb_ldo_set_mode(1);
559 msm_hsusb_config_vddcx(1);
560 writel(readl(USB_PHY_CTRL
) & ~PHY_RETEN
, USB_PHY_CTRL
);
563 temp
= readl(USB_USBCMD
);
564 temp
&= ~ASYNC_INTR_CTRL
;
565 temp
&= ~ULPI_STP_CTRL
;
566 writel(temp
, USB_USBCMD
);
569 * PHY comes out of low power mode (LPM) in case of wakeup
570 * from asynchronous interrupt.
572 if (!(readl(USB_PORTSC
) & PORTSC_PHCD
))
573 goto skip_phy_resume
;
575 writel(readl(USB_PORTSC
) & ~PORTSC_PHCD
, USB_PORTSC
);
576 while (cnt
< PHY_RESUME_TIMEOUT_USEC
) {
577 if (!(readl(USB_PORTSC
) & PORTSC_PHCD
))
583 if (cnt
>= PHY_RESUME_TIMEOUT_USEC
) {
585 * This is a fatal error. Reset the link and
586 * PHY. USB state can not be restored. Re-insertion
587 * of USB cable is the only way to get USB working.
589 dev_err(phy
->dev
, "Unable to resume USB."
590 "Re-plugin the cable\n");
595 if (device_may_wakeup(phy
->dev
))
596 disable_irq_wake(motg
->irq
);
598 set_bit(HCD_FLAG_HW_ACCESSIBLE
, &(bus_to_hcd(bus
))->flags
);
600 atomic_set(&motg
->in_lpm
, 0);
602 if (motg
->async_int
) {
604 pm_runtime_put(phy
->dev
);
605 enable_irq(motg
->irq
);
608 dev_info(phy
->dev
, "USB exited from low power mode\n");
614 static void msm_otg_notify_charger(struct msm_otg
*motg
, unsigned mA
)
616 if (motg
->cur_power
== mA
)
619 /* TODO: Notify PMIC about available current */
620 dev_info(motg
->phy
.dev
, "Avail curr from USB = %u\n", mA
);
621 motg
->cur_power
= mA
;
624 static int msm_otg_set_power(struct usb_phy
*phy
, unsigned mA
)
626 struct msm_otg
*motg
= container_of(phy
, struct msm_otg
, phy
);
629 * Gadget driver uses set_power method to notify about the
630 * available current based on suspend/configured states.
632 * IDEV_CHG can be drawn irrespective of suspend/un-configured
633 * states when CDP/ACA is connected.
635 if (motg
->chg_type
== USB_SDP_CHARGER
)
636 msm_otg_notify_charger(motg
, mA
);
641 static void msm_otg_start_host(struct usb_phy
*phy
, int on
)
643 struct msm_otg
*motg
= container_of(phy
, struct msm_otg
, phy
);
644 struct msm_otg_platform_data
*pdata
= motg
->pdata
;
650 hcd
= bus_to_hcd(phy
->otg
->host
);
653 dev_dbg(phy
->dev
, "host on\n");
655 if (pdata
->vbus_power
)
656 pdata
->vbus_power(1);
658 * Some boards have a switch cotrolled by gpio
659 * to enable/disable internal HUB. Enable internal
660 * HUB before kicking the host.
662 if (pdata
->setup_gpio
)
663 pdata
->setup_gpio(OTG_STATE_A_HOST
);
665 usb_add_hcd(hcd
, hcd
->irq
, IRQF_SHARED
);
666 device_wakeup_enable(hcd
->self
.controller
);
669 dev_dbg(phy
->dev
, "host off\n");
674 if (pdata
->setup_gpio
)
675 pdata
->setup_gpio(OTG_STATE_UNDEFINED
);
676 if (pdata
->vbus_power
)
677 pdata
->vbus_power(0);
681 static int msm_otg_set_host(struct usb_otg
*otg
, struct usb_bus
*host
)
683 struct msm_otg
*motg
= container_of(otg
->phy
, struct msm_otg
, phy
);
687 * Fail host registration if this board can support
688 * only peripheral configuration.
690 if (motg
->pdata
->mode
== USB_PERIPHERAL
) {
691 dev_info(otg
->phy
->dev
, "Host mode is not supported\n");
696 if (otg
->phy
->state
== OTG_STATE_A_HOST
) {
697 pm_runtime_get_sync(otg
->phy
->dev
);
698 msm_otg_start_host(otg
->phy
, 0);
700 otg
->phy
->state
= OTG_STATE_UNDEFINED
;
701 schedule_work(&motg
->sm_work
);
709 hcd
= bus_to_hcd(host
);
710 hcd
->power_budget
= motg
->pdata
->power_budget
;
713 dev_dbg(otg
->phy
->dev
, "host driver registered w/ tranceiver\n");
716 * Kick the state machine work, if peripheral is not supported
717 * or peripheral is already registered with us.
719 if (motg
->pdata
->mode
== USB_HOST
|| otg
->gadget
) {
720 pm_runtime_get_sync(otg
->phy
->dev
);
721 schedule_work(&motg
->sm_work
);
727 static void msm_otg_start_peripheral(struct usb_phy
*phy
, int on
)
729 struct msm_otg
*motg
= container_of(phy
, struct msm_otg
, phy
);
730 struct msm_otg_platform_data
*pdata
= motg
->pdata
;
732 if (!phy
->otg
->gadget
)
736 dev_dbg(phy
->dev
, "gadget on\n");
738 * Some boards have a switch cotrolled by gpio
739 * to enable/disable internal HUB. Disable internal
740 * HUB before kicking the gadget.
742 if (pdata
->setup_gpio
)
743 pdata
->setup_gpio(OTG_STATE_B_PERIPHERAL
);
744 usb_gadget_vbus_connect(phy
->otg
->gadget
);
746 dev_dbg(phy
->dev
, "gadget off\n");
747 usb_gadget_vbus_disconnect(phy
->otg
->gadget
);
748 if (pdata
->setup_gpio
)
749 pdata
->setup_gpio(OTG_STATE_UNDEFINED
);
754 static int msm_otg_set_peripheral(struct usb_otg
*otg
,
755 struct usb_gadget
*gadget
)
757 struct msm_otg
*motg
= container_of(otg
->phy
, struct msm_otg
, phy
);
760 * Fail peripheral registration if this board can support
761 * only host configuration.
763 if (motg
->pdata
->mode
== USB_HOST
) {
764 dev_info(otg
->phy
->dev
, "Peripheral mode is not supported\n");
769 if (otg
->phy
->state
== OTG_STATE_B_PERIPHERAL
) {
770 pm_runtime_get_sync(otg
->phy
->dev
);
771 msm_otg_start_peripheral(otg
->phy
, 0);
773 otg
->phy
->state
= OTG_STATE_UNDEFINED
;
774 schedule_work(&motg
->sm_work
);
781 otg
->gadget
= gadget
;
782 dev_dbg(otg
->phy
->dev
, "peripheral driver registered w/ tranceiver\n");
785 * Kick the state machine work, if host is not supported
786 * or host is already registered with us.
788 if (motg
->pdata
->mode
== USB_PERIPHERAL
|| otg
->host
) {
789 pm_runtime_get_sync(otg
->phy
->dev
);
790 schedule_work(&motg
->sm_work
);
796 static bool msm_chg_check_secondary_det(struct msm_otg
*motg
)
798 struct usb_phy
*phy
= &motg
->phy
;
802 switch (motg
->pdata
->phy_type
) {
803 case CI_45NM_INTEGRATED_PHY
:
804 chg_det
= ulpi_read(phy
, 0x34);
805 ret
= chg_det
& (1 << 4);
807 case SNPS_28NM_INTEGRATED_PHY
:
808 chg_det
= ulpi_read(phy
, 0x87);
817 static void msm_chg_enable_secondary_det(struct msm_otg
*motg
)
819 struct usb_phy
*phy
= &motg
->phy
;
822 switch (motg
->pdata
->phy_type
) {
823 case CI_45NM_INTEGRATED_PHY
:
824 chg_det
= ulpi_read(phy
, 0x34);
825 /* Turn off charger block */
826 chg_det
|= ~(1 << 1);
827 ulpi_write(phy
, chg_det
, 0x34);
829 /* control chg block via ULPI */
830 chg_det
&= ~(1 << 3);
831 ulpi_write(phy
, chg_det
, 0x34);
832 /* put it in host mode for enabling D- source */
833 chg_det
&= ~(1 << 2);
834 ulpi_write(phy
, chg_det
, 0x34);
835 /* Turn on chg detect block */
836 chg_det
&= ~(1 << 1);
837 ulpi_write(phy
, chg_det
, 0x34);
839 /* enable chg detection */
840 chg_det
&= ~(1 << 0);
841 ulpi_write(phy
, chg_det
, 0x34);
843 case SNPS_28NM_INTEGRATED_PHY
:
845 * Configure DM as current source, DP as current sink
846 * and enable battery charging comparators.
848 ulpi_write(phy
, 0x8, 0x85);
849 ulpi_write(phy
, 0x2, 0x85);
850 ulpi_write(phy
, 0x1, 0x85);
857 static bool msm_chg_check_primary_det(struct msm_otg
*motg
)
859 struct usb_phy
*phy
= &motg
->phy
;
863 switch (motg
->pdata
->phy_type
) {
864 case CI_45NM_INTEGRATED_PHY
:
865 chg_det
= ulpi_read(phy
, 0x34);
866 ret
= chg_det
& (1 << 4);
868 case SNPS_28NM_INTEGRATED_PHY
:
869 chg_det
= ulpi_read(phy
, 0x87);
878 static void msm_chg_enable_primary_det(struct msm_otg
*motg
)
880 struct usb_phy
*phy
= &motg
->phy
;
883 switch (motg
->pdata
->phy_type
) {
884 case CI_45NM_INTEGRATED_PHY
:
885 chg_det
= ulpi_read(phy
, 0x34);
886 /* enable chg detection */
887 chg_det
&= ~(1 << 0);
888 ulpi_write(phy
, chg_det
, 0x34);
890 case SNPS_28NM_INTEGRATED_PHY
:
892 * Configure DP as current source, DM as current sink
893 * and enable battery charging comparators.
895 ulpi_write(phy
, 0x2, 0x85);
896 ulpi_write(phy
, 0x1, 0x85);
903 static bool msm_chg_check_dcd(struct msm_otg
*motg
)
905 struct usb_phy
*phy
= &motg
->phy
;
909 switch (motg
->pdata
->phy_type
) {
910 case CI_45NM_INTEGRATED_PHY
:
911 line_state
= ulpi_read(phy
, 0x15);
912 ret
= !(line_state
& 1);
914 case SNPS_28NM_INTEGRATED_PHY
:
915 line_state
= ulpi_read(phy
, 0x87);
916 ret
= line_state
& 2;
924 static void msm_chg_disable_dcd(struct msm_otg
*motg
)
926 struct usb_phy
*phy
= &motg
->phy
;
929 switch (motg
->pdata
->phy_type
) {
930 case CI_45NM_INTEGRATED_PHY
:
931 chg_det
= ulpi_read(phy
, 0x34);
932 chg_det
&= ~(1 << 5);
933 ulpi_write(phy
, chg_det
, 0x34);
935 case SNPS_28NM_INTEGRATED_PHY
:
936 ulpi_write(phy
, 0x10, 0x86);
943 static void msm_chg_enable_dcd(struct msm_otg
*motg
)
945 struct usb_phy
*phy
= &motg
->phy
;
948 switch (motg
->pdata
->phy_type
) {
949 case CI_45NM_INTEGRATED_PHY
:
950 chg_det
= ulpi_read(phy
, 0x34);
951 /* Turn on D+ current source */
953 ulpi_write(phy
, chg_det
, 0x34);
955 case SNPS_28NM_INTEGRATED_PHY
:
956 /* Data contact detection enable */
957 ulpi_write(phy
, 0x10, 0x85);
964 static void msm_chg_block_on(struct msm_otg
*motg
)
966 struct usb_phy
*phy
= &motg
->phy
;
967 u32 func_ctrl
, chg_det
;
969 /* put the controller in non-driving mode */
970 func_ctrl
= ulpi_read(phy
, ULPI_FUNC_CTRL
);
971 func_ctrl
&= ~ULPI_FUNC_CTRL_OPMODE_MASK
;
972 func_ctrl
|= ULPI_FUNC_CTRL_OPMODE_NONDRIVING
;
973 ulpi_write(phy
, func_ctrl
, ULPI_FUNC_CTRL
);
975 switch (motg
->pdata
->phy_type
) {
976 case CI_45NM_INTEGRATED_PHY
:
977 chg_det
= ulpi_read(phy
, 0x34);
978 /* control chg block via ULPI */
979 chg_det
&= ~(1 << 3);
980 ulpi_write(phy
, chg_det
, 0x34);
981 /* Turn on chg detect block */
982 chg_det
&= ~(1 << 1);
983 ulpi_write(phy
, chg_det
, 0x34);
986 case SNPS_28NM_INTEGRATED_PHY
:
987 /* Clear charger detecting control bits */
988 ulpi_write(phy
, 0x3F, 0x86);
989 /* Clear alt interrupt latch and enable bits */
990 ulpi_write(phy
, 0x1F, 0x92);
991 ulpi_write(phy
, 0x1F, 0x95);
999 static void msm_chg_block_off(struct msm_otg
*motg
)
1001 struct usb_phy
*phy
= &motg
->phy
;
1002 u32 func_ctrl
, chg_det
;
1004 switch (motg
->pdata
->phy_type
) {
1005 case CI_45NM_INTEGRATED_PHY
:
1006 chg_det
= ulpi_read(phy
, 0x34);
1007 /* Turn off charger block */
1008 chg_det
|= ~(1 << 1);
1009 ulpi_write(phy
, chg_det
, 0x34);
1011 case SNPS_28NM_INTEGRATED_PHY
:
1012 /* Clear charger detecting control bits */
1013 ulpi_write(phy
, 0x3F, 0x86);
1014 /* Clear alt interrupt latch and enable bits */
1015 ulpi_write(phy
, 0x1F, 0x92);
1016 ulpi_write(phy
, 0x1F, 0x95);
1022 /* put the controller in normal mode */
1023 func_ctrl
= ulpi_read(phy
, ULPI_FUNC_CTRL
);
1024 func_ctrl
&= ~ULPI_FUNC_CTRL_OPMODE_MASK
;
1025 func_ctrl
|= ULPI_FUNC_CTRL_OPMODE_NORMAL
;
1026 ulpi_write(phy
, func_ctrl
, ULPI_FUNC_CTRL
);
1029 #define MSM_CHG_DCD_POLL_TIME (100 * HZ/1000) /* 100 msec */
1030 #define MSM_CHG_DCD_MAX_RETRIES 6 /* Tdcd_tmout = 6 * 100 msec */
1031 #define MSM_CHG_PRIMARY_DET_TIME (40 * HZ/1000) /* TVDPSRC_ON */
1032 #define MSM_CHG_SECONDARY_DET_TIME (40 * HZ/1000) /* TVDMSRC_ON */
1033 static void msm_chg_detect_work(struct work_struct
*w
)
1035 struct msm_otg
*motg
= container_of(w
, struct msm_otg
, chg_work
.work
);
1036 struct usb_phy
*phy
= &motg
->phy
;
1037 bool is_dcd
, tmout
, vout
;
1038 unsigned long delay
;
1040 dev_dbg(phy
->dev
, "chg detection work\n");
1041 switch (motg
->chg_state
) {
1042 case USB_CHG_STATE_UNDEFINED
:
1043 pm_runtime_get_sync(phy
->dev
);
1044 msm_chg_block_on(motg
);
1045 msm_chg_enable_dcd(motg
);
1046 motg
->chg_state
= USB_CHG_STATE_WAIT_FOR_DCD
;
1047 motg
->dcd_retries
= 0;
1048 delay
= MSM_CHG_DCD_POLL_TIME
;
1050 case USB_CHG_STATE_WAIT_FOR_DCD
:
1051 is_dcd
= msm_chg_check_dcd(motg
);
1052 tmout
= ++motg
->dcd_retries
== MSM_CHG_DCD_MAX_RETRIES
;
1053 if (is_dcd
|| tmout
) {
1054 msm_chg_disable_dcd(motg
);
1055 msm_chg_enable_primary_det(motg
);
1056 delay
= MSM_CHG_PRIMARY_DET_TIME
;
1057 motg
->chg_state
= USB_CHG_STATE_DCD_DONE
;
1059 delay
= MSM_CHG_DCD_POLL_TIME
;
1062 case USB_CHG_STATE_DCD_DONE
:
1063 vout
= msm_chg_check_primary_det(motg
);
1065 msm_chg_enable_secondary_det(motg
);
1066 delay
= MSM_CHG_SECONDARY_DET_TIME
;
1067 motg
->chg_state
= USB_CHG_STATE_PRIMARY_DONE
;
1069 motg
->chg_type
= USB_SDP_CHARGER
;
1070 motg
->chg_state
= USB_CHG_STATE_DETECTED
;
1074 case USB_CHG_STATE_PRIMARY_DONE
:
1075 vout
= msm_chg_check_secondary_det(motg
);
1077 motg
->chg_type
= USB_DCP_CHARGER
;
1079 motg
->chg_type
= USB_CDP_CHARGER
;
1080 motg
->chg_state
= USB_CHG_STATE_SECONDARY_DONE
;
1082 case USB_CHG_STATE_SECONDARY_DONE
:
1083 motg
->chg_state
= USB_CHG_STATE_DETECTED
;
1084 case USB_CHG_STATE_DETECTED
:
1085 msm_chg_block_off(motg
);
1086 dev_dbg(phy
->dev
, "charger = %d\n", motg
->chg_type
);
1087 schedule_work(&motg
->sm_work
);
1093 schedule_delayed_work(&motg
->chg_work
, delay
);
1097 * We support OTG, Peripheral only and Host only configurations. In case
1098 * of OTG, mode switch (host-->peripheral/peripheral-->host) can happen
1099 * via Id pin status or user request (debugfs). Id/BSV interrupts are not
1100 * enabled when switch is controlled by user and default mode is supplied
1101 * by board file, which can be changed by userspace later.
1103 static void msm_otg_init_sm(struct msm_otg
*motg
)
1105 struct msm_otg_platform_data
*pdata
= motg
->pdata
;
1106 u32 otgsc
= readl(USB_OTGSC
);
1108 switch (pdata
->mode
) {
1110 if (pdata
->otg_control
== OTG_PHY_CONTROL
) {
1111 if (otgsc
& OTGSC_ID
)
1112 set_bit(ID
, &motg
->inputs
);
1114 clear_bit(ID
, &motg
->inputs
);
1116 if (otgsc
& OTGSC_BSV
)
1117 set_bit(B_SESS_VLD
, &motg
->inputs
);
1119 clear_bit(B_SESS_VLD
, &motg
->inputs
);
1120 } else if (pdata
->otg_control
== OTG_USER_CONTROL
) {
1121 if (pdata
->default_mode
== USB_HOST
) {
1122 clear_bit(ID
, &motg
->inputs
);
1123 } else if (pdata
->default_mode
== USB_PERIPHERAL
) {
1124 set_bit(ID
, &motg
->inputs
);
1125 set_bit(B_SESS_VLD
, &motg
->inputs
);
1127 set_bit(ID
, &motg
->inputs
);
1128 clear_bit(B_SESS_VLD
, &motg
->inputs
);
1133 clear_bit(ID
, &motg
->inputs
);
1135 case USB_PERIPHERAL
:
1136 set_bit(ID
, &motg
->inputs
);
1137 if (otgsc
& OTGSC_BSV
)
1138 set_bit(B_SESS_VLD
, &motg
->inputs
);
1140 clear_bit(B_SESS_VLD
, &motg
->inputs
);
1147 static void msm_otg_sm_work(struct work_struct
*w
)
1149 struct msm_otg
*motg
= container_of(w
, struct msm_otg
, sm_work
);
1150 struct usb_otg
*otg
= motg
->phy
.otg
;
1152 switch (otg
->phy
->state
) {
1153 case OTG_STATE_UNDEFINED
:
1154 dev_dbg(otg
->phy
->dev
, "OTG_STATE_UNDEFINED state\n");
1155 msm_otg_reset(otg
->phy
);
1156 msm_otg_init_sm(motg
);
1157 otg
->phy
->state
= OTG_STATE_B_IDLE
;
1159 case OTG_STATE_B_IDLE
:
1160 dev_dbg(otg
->phy
->dev
, "OTG_STATE_B_IDLE state\n");
1161 if (!test_bit(ID
, &motg
->inputs
) && otg
->host
) {
1162 /* disable BSV bit */
1163 writel(readl(USB_OTGSC
) & ~OTGSC_BSVIE
, USB_OTGSC
);
1164 msm_otg_start_host(otg
->phy
, 1);
1165 otg
->phy
->state
= OTG_STATE_A_HOST
;
1166 } else if (test_bit(B_SESS_VLD
, &motg
->inputs
)) {
1167 switch (motg
->chg_state
) {
1168 case USB_CHG_STATE_UNDEFINED
:
1169 msm_chg_detect_work(&motg
->chg_work
.work
);
1171 case USB_CHG_STATE_DETECTED
:
1172 switch (motg
->chg_type
) {
1173 case USB_DCP_CHARGER
:
1174 msm_otg_notify_charger(motg
,
1177 case USB_CDP_CHARGER
:
1178 msm_otg_notify_charger(motg
,
1180 msm_otg_start_peripheral(otg
->phy
, 1);
1182 = OTG_STATE_B_PERIPHERAL
;
1184 case USB_SDP_CHARGER
:
1185 msm_otg_notify_charger(motg
, IUNIT
);
1186 msm_otg_start_peripheral(otg
->phy
, 1);
1188 = OTG_STATE_B_PERIPHERAL
;
1199 * If charger detection work is pending, decrement
1200 * the pm usage counter to balance with the one that
1201 * is incremented in charger detection work.
1203 if (cancel_delayed_work_sync(&motg
->chg_work
)) {
1204 pm_runtime_put_sync(otg
->phy
->dev
);
1205 msm_otg_reset(otg
->phy
);
1207 msm_otg_notify_charger(motg
, 0);
1208 motg
->chg_state
= USB_CHG_STATE_UNDEFINED
;
1209 motg
->chg_type
= USB_INVALID_CHARGER
;
1211 pm_runtime_put_sync(otg
->phy
->dev
);
1213 case OTG_STATE_B_PERIPHERAL
:
1214 dev_dbg(otg
->phy
->dev
, "OTG_STATE_B_PERIPHERAL state\n");
1215 if (!test_bit(B_SESS_VLD
, &motg
->inputs
) ||
1216 !test_bit(ID
, &motg
->inputs
)) {
1217 msm_otg_notify_charger(motg
, 0);
1218 msm_otg_start_peripheral(otg
->phy
, 0);
1219 motg
->chg_state
= USB_CHG_STATE_UNDEFINED
;
1220 motg
->chg_type
= USB_INVALID_CHARGER
;
1221 otg
->phy
->state
= OTG_STATE_B_IDLE
;
1222 msm_otg_reset(otg
->phy
);
1226 case OTG_STATE_A_HOST
:
1227 dev_dbg(otg
->phy
->dev
, "OTG_STATE_A_HOST state\n");
1228 if (test_bit(ID
, &motg
->inputs
)) {
1229 msm_otg_start_host(otg
->phy
, 0);
1230 otg
->phy
->state
= OTG_STATE_B_IDLE
;
1231 msm_otg_reset(otg
->phy
);
1240 static irqreturn_t
msm_otg_irq(int irq
, void *data
)
1242 struct msm_otg
*motg
= data
;
1243 struct usb_phy
*phy
= &motg
->phy
;
1246 if (atomic_read(&motg
->in_lpm
)) {
1247 disable_irq_nosync(irq
);
1248 motg
->async_int
= 1;
1249 pm_runtime_get(phy
->dev
);
1253 otgsc
= readl(USB_OTGSC
);
1254 if (!(otgsc
& (OTGSC_IDIS
| OTGSC_BSVIS
)))
1257 if ((otgsc
& OTGSC_IDIS
) && (otgsc
& OTGSC_IDIE
)) {
1258 if (otgsc
& OTGSC_ID
)
1259 set_bit(ID
, &motg
->inputs
);
1261 clear_bit(ID
, &motg
->inputs
);
1262 dev_dbg(phy
->dev
, "ID set/clear\n");
1263 pm_runtime_get_noresume(phy
->dev
);
1264 } else if ((otgsc
& OTGSC_BSVIS
) && (otgsc
& OTGSC_BSVIE
)) {
1265 if (otgsc
& OTGSC_BSV
)
1266 set_bit(B_SESS_VLD
, &motg
->inputs
);
1268 clear_bit(B_SESS_VLD
, &motg
->inputs
);
1269 dev_dbg(phy
->dev
, "BSV set/clear\n");
1270 pm_runtime_get_noresume(phy
->dev
);
1273 writel(otgsc
, USB_OTGSC
);
1274 schedule_work(&motg
->sm_work
);
1278 static int msm_otg_mode_show(struct seq_file
*s
, void *unused
)
1280 struct msm_otg
*motg
= s
->private;
1281 struct usb_otg
*otg
= motg
->phy
.otg
;
1283 switch (otg
->phy
->state
) {
1284 case OTG_STATE_A_HOST
:
1285 seq_printf(s
, "host\n");
1287 case OTG_STATE_B_PERIPHERAL
:
1288 seq_printf(s
, "peripheral\n");
1291 seq_printf(s
, "none\n");
1298 static int msm_otg_mode_open(struct inode
*inode
, struct file
*file
)
1300 return single_open(file
, msm_otg_mode_show
, inode
->i_private
);
1303 static ssize_t
msm_otg_mode_write(struct file
*file
, const char __user
*ubuf
,
1304 size_t count
, loff_t
*ppos
)
1306 struct seq_file
*s
= file
->private_data
;
1307 struct msm_otg
*motg
= s
->private;
1309 struct usb_otg
*otg
= motg
->phy
.otg
;
1311 enum usb_mode_type req_mode
;
1313 memset(buf
, 0x00, sizeof(buf
));
1315 if (copy_from_user(&buf
, ubuf
, min_t(size_t, sizeof(buf
) - 1, count
))) {
1320 if (!strncmp(buf
, "host", 4)) {
1321 req_mode
= USB_HOST
;
1322 } else if (!strncmp(buf
, "peripheral", 10)) {
1323 req_mode
= USB_PERIPHERAL
;
1324 } else if (!strncmp(buf
, "none", 4)) {
1325 req_mode
= USB_NONE
;
1333 switch (otg
->phy
->state
) {
1334 case OTG_STATE_A_HOST
:
1335 case OTG_STATE_B_PERIPHERAL
:
1336 set_bit(ID
, &motg
->inputs
);
1337 clear_bit(B_SESS_VLD
, &motg
->inputs
);
1343 case USB_PERIPHERAL
:
1344 switch (otg
->phy
->state
) {
1345 case OTG_STATE_B_IDLE
:
1346 case OTG_STATE_A_HOST
:
1347 set_bit(ID
, &motg
->inputs
);
1348 set_bit(B_SESS_VLD
, &motg
->inputs
);
1355 switch (otg
->phy
->state
) {
1356 case OTG_STATE_B_IDLE
:
1357 case OTG_STATE_B_PERIPHERAL
:
1358 clear_bit(ID
, &motg
->inputs
);
1368 pm_runtime_get_sync(otg
->phy
->dev
);
1369 schedule_work(&motg
->sm_work
);
1374 const struct file_operations msm_otg_mode_fops
= {
1375 .open
= msm_otg_mode_open
,
1377 .write
= msm_otg_mode_write
,
1378 .llseek
= seq_lseek
,
1379 .release
= single_release
,
1382 static struct dentry
*msm_otg_dbg_root
;
1383 static struct dentry
*msm_otg_dbg_mode
;
1385 static int msm_otg_debugfs_init(struct msm_otg
*motg
)
1387 msm_otg_dbg_root
= debugfs_create_dir("msm_otg", NULL
);
1389 if (!msm_otg_dbg_root
|| IS_ERR(msm_otg_dbg_root
))
1392 msm_otg_dbg_mode
= debugfs_create_file("mode", S_IRUGO
| S_IWUSR
,
1393 msm_otg_dbg_root
, motg
, &msm_otg_mode_fops
);
1394 if (!msm_otg_dbg_mode
) {
1395 debugfs_remove(msm_otg_dbg_root
);
1396 msm_otg_dbg_root
= NULL
;
1403 static void msm_otg_debugfs_cleanup(void)
1405 debugfs_remove(msm_otg_dbg_mode
);
1406 debugfs_remove(msm_otg_dbg_root
);
1409 static int __init
msm_otg_probe(struct platform_device
*pdev
)
1412 struct resource
*res
;
1413 struct msm_otg
*motg
;
1414 struct usb_phy
*phy
;
1416 dev_info(&pdev
->dev
, "msm_otg probe\n");
1417 if (!dev_get_platdata(&pdev
->dev
)) {
1418 dev_err(&pdev
->dev
, "No platform data given. Bailing out\n");
1422 motg
= kzalloc(sizeof(struct msm_otg
), GFP_KERNEL
);
1424 dev_err(&pdev
->dev
, "unable to allocate msm_otg\n");
1428 motg
->phy
.otg
= kzalloc(sizeof(struct usb_otg
), GFP_KERNEL
);
1429 if (!motg
->phy
.otg
) {
1430 dev_err(&pdev
->dev
, "unable to allocate msm_otg\n");
1434 motg
->pdata
= dev_get_platdata(&pdev
->dev
);
1436 phy
->dev
= &pdev
->dev
;
1438 motg
->phy_reset_clk
= clk_get(&pdev
->dev
, "usb_phy_clk");
1439 if (IS_ERR(motg
->phy_reset_clk
)) {
1440 dev_err(&pdev
->dev
, "failed to get usb_phy_clk\n");
1441 ret
= PTR_ERR(motg
->phy_reset_clk
);
1445 motg
->clk
= clk_get(&pdev
->dev
, "usb_hs_clk");
1446 if (IS_ERR(motg
->clk
)) {
1447 dev_err(&pdev
->dev
, "failed to get usb_hs_clk\n");
1448 ret
= PTR_ERR(motg
->clk
);
1449 goto put_phy_reset_clk
;
1451 clk_set_rate(motg
->clk
, 60000000);
1454 * If USB Core is running its protocol engine based on CORE CLK,
1455 * CORE CLK must be running at >55Mhz for correct HSUSB
1456 * operation and USB core cannot tolerate frequency changes on
1457 * CORE CLK. For such USB cores, vote for maximum clk frequency
1460 if (motg
->pdata
->pclk_src_name
) {
1461 motg
->pclk_src
= clk_get(&pdev
->dev
,
1462 motg
->pdata
->pclk_src_name
);
1463 if (IS_ERR(motg
->pclk_src
))
1465 clk_set_rate(motg
->pclk_src
, INT_MAX
);
1466 clk_prepare_enable(motg
->pclk_src
);
1468 motg
->pclk_src
= ERR_PTR(-ENOENT
);
1471 motg
->pclk
= clk_get(&pdev
->dev
, "usb_hs_pclk");
1472 if (IS_ERR(motg
->pclk
)) {
1473 dev_err(&pdev
->dev
, "failed to get usb_hs_pclk\n");
1474 ret
= PTR_ERR(motg
->pclk
);
1479 * USB core clock is not present on all MSM chips. This
1480 * clock is introduced to remove the dependency on AXI
1483 motg
->core_clk
= clk_get(&pdev
->dev
, "usb_hs_core_clk");
1484 if (IS_ERR(motg
->core_clk
))
1485 motg
->core_clk
= NULL
;
1487 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1489 dev_err(&pdev
->dev
, "failed to get platform resource mem\n");
1494 motg
->regs
= ioremap(res
->start
, resource_size(res
));
1496 dev_err(&pdev
->dev
, "ioremap failed\n");
1500 dev_info(&pdev
->dev
, "OTG regs = %p\n", motg
->regs
);
1502 motg
->irq
= platform_get_irq(pdev
, 0);
1504 dev_err(&pdev
->dev
, "platform_get_irq failed\n");
1509 clk_prepare_enable(motg
->clk
);
1510 clk_prepare_enable(motg
->pclk
);
1512 ret
= msm_hsusb_init_vddcx(motg
, 1);
1514 dev_err(&pdev
->dev
, "hsusb vddcx configuration failed\n");
1518 ret
= msm_hsusb_ldo_init(motg
, 1);
1520 dev_err(&pdev
->dev
, "hsusb vreg configuration failed\n");
1523 ret
= msm_hsusb_ldo_set_mode(1);
1525 dev_err(&pdev
->dev
, "hsusb vreg enable failed\n");
1530 clk_prepare_enable(motg
->core_clk
);
1532 writel(0, USB_USBINTR
);
1533 writel(0, USB_OTGSC
);
1535 INIT_WORK(&motg
->sm_work
, msm_otg_sm_work
);
1536 INIT_DELAYED_WORK(&motg
->chg_work
, msm_chg_detect_work
);
1537 ret
= request_irq(motg
->irq
, msm_otg_irq
, IRQF_SHARED
,
1540 dev_err(&pdev
->dev
, "request irq failed\n");
1544 phy
->init
= msm_otg_reset
;
1545 phy
->set_power
= msm_otg_set_power
;
1547 phy
->io_ops
= &msm_otg_io_ops
;
1549 phy
->otg
->phy
= &motg
->phy
;
1550 phy
->otg
->set_host
= msm_otg_set_host
;
1551 phy
->otg
->set_peripheral
= msm_otg_set_peripheral
;
1553 ret
= usb_add_phy(&motg
->phy
, USB_PHY_TYPE_USB2
);
1555 dev_err(&pdev
->dev
, "usb_add_phy failed\n");
1559 platform_set_drvdata(pdev
, motg
);
1560 device_init_wakeup(&pdev
->dev
, 1);
1562 if (motg
->pdata
->mode
== USB_OTG
&&
1563 motg
->pdata
->otg_control
== OTG_USER_CONTROL
) {
1564 ret
= msm_otg_debugfs_init(motg
);
1566 dev_dbg(&pdev
->dev
, "mode debugfs file is"
1570 pm_runtime_set_active(&pdev
->dev
);
1571 pm_runtime_enable(&pdev
->dev
);
1575 free_irq(motg
->irq
, motg
);
1577 clk_disable_unprepare(motg
->pclk
);
1578 clk_disable_unprepare(motg
->clk
);
1580 msm_hsusb_ldo_init(motg
, 0);
1582 msm_hsusb_init_vddcx(motg
, 0);
1584 iounmap(motg
->regs
);
1587 clk_put(motg
->core_clk
);
1588 clk_put(motg
->pclk
);
1590 if (!IS_ERR(motg
->pclk_src
)) {
1591 clk_disable_unprepare(motg
->pclk_src
);
1592 clk_put(motg
->pclk_src
);
1597 clk_put(motg
->phy_reset_clk
);
1599 kfree(motg
->phy
.otg
);
1604 static int msm_otg_remove(struct platform_device
*pdev
)
1606 struct msm_otg
*motg
= platform_get_drvdata(pdev
);
1607 struct usb_phy
*phy
= &motg
->phy
;
1610 if (phy
->otg
->host
|| phy
->otg
->gadget
)
1613 msm_otg_debugfs_cleanup();
1614 cancel_delayed_work_sync(&motg
->chg_work
);
1615 cancel_work_sync(&motg
->sm_work
);
1617 pm_runtime_resume(&pdev
->dev
);
1619 device_init_wakeup(&pdev
->dev
, 0);
1620 pm_runtime_disable(&pdev
->dev
);
1622 usb_remove_phy(phy
);
1623 free_irq(motg
->irq
, motg
);
1626 * Put PHY in low power mode.
1628 ulpi_read(phy
, 0x14);
1629 ulpi_write(phy
, 0x08, 0x09);
1631 writel(readl(USB_PORTSC
) | PORTSC_PHCD
, USB_PORTSC
);
1632 while (cnt
< PHY_SUSPEND_TIMEOUT_USEC
) {
1633 if (readl(USB_PORTSC
) & PORTSC_PHCD
)
1638 if (cnt
>= PHY_SUSPEND_TIMEOUT_USEC
)
1639 dev_err(phy
->dev
, "Unable to suspend PHY\n");
1641 clk_disable_unprepare(motg
->pclk
);
1642 clk_disable_unprepare(motg
->clk
);
1644 clk_disable_unprepare(motg
->core_clk
);
1645 if (!IS_ERR(motg
->pclk_src
)) {
1646 clk_disable_unprepare(motg
->pclk_src
);
1647 clk_put(motg
->pclk_src
);
1649 msm_hsusb_ldo_init(motg
, 0);
1651 iounmap(motg
->regs
);
1652 pm_runtime_set_suspended(&pdev
->dev
);
1654 clk_put(motg
->phy_reset_clk
);
1655 clk_put(motg
->pclk
);
1658 clk_put(motg
->core_clk
);
1660 kfree(motg
->phy
.otg
);
1666 #ifdef CONFIG_PM_RUNTIME
1667 static int msm_otg_runtime_idle(struct device
*dev
)
1669 struct msm_otg
*motg
= dev_get_drvdata(dev
);
1670 struct usb_otg
*otg
= motg
->phy
.otg
;
1672 dev_dbg(dev
, "OTG runtime idle\n");
1675 * It is observed some times that a spurious interrupt
1676 * comes when PHY is put into LPM immediately after PHY reset.
1677 * This 1 sec delay also prevents entering into LPM immediately
1678 * after asynchronous interrupt.
1680 if (otg
->phy
->state
!= OTG_STATE_UNDEFINED
)
1681 pm_schedule_suspend(dev
, 1000);
1686 static int msm_otg_runtime_suspend(struct device
*dev
)
1688 struct msm_otg
*motg
= dev_get_drvdata(dev
);
1690 dev_dbg(dev
, "OTG runtime suspend\n");
1691 return msm_otg_suspend(motg
);
1694 static int msm_otg_runtime_resume(struct device
*dev
)
1696 struct msm_otg
*motg
= dev_get_drvdata(dev
);
1698 dev_dbg(dev
, "OTG runtime resume\n");
1699 return msm_otg_resume(motg
);
1703 #ifdef CONFIG_PM_SLEEP
1704 static int msm_otg_pm_suspend(struct device
*dev
)
1706 struct msm_otg
*motg
= dev_get_drvdata(dev
);
1708 dev_dbg(dev
, "OTG PM suspend\n");
1709 return msm_otg_suspend(motg
);
1712 static int msm_otg_pm_resume(struct device
*dev
)
1714 struct msm_otg
*motg
= dev_get_drvdata(dev
);
1717 dev_dbg(dev
, "OTG PM resume\n");
1719 ret
= msm_otg_resume(motg
);
1724 * Runtime PM Documentation recommends bringing the
1725 * device to full powered state upon resume.
1727 pm_runtime_disable(dev
);
1728 pm_runtime_set_active(dev
);
1729 pm_runtime_enable(dev
);
1735 static const struct dev_pm_ops msm_otg_dev_pm_ops
= {
1736 SET_SYSTEM_SLEEP_PM_OPS(msm_otg_pm_suspend
, msm_otg_pm_resume
)
1737 SET_RUNTIME_PM_OPS(msm_otg_runtime_suspend
, msm_otg_runtime_resume
,
1738 msm_otg_runtime_idle
)
1741 static struct platform_driver msm_otg_driver
= {
1742 .remove
= msm_otg_remove
,
1744 .name
= DRIVER_NAME
,
1745 .owner
= THIS_MODULE
,
1746 .pm
= &msm_otg_dev_pm_ops
,
1750 module_platform_driver_probe(msm_otg_driver
, msm_otg_probe
);
1752 MODULE_LICENSE("GPL v2");
1753 MODULE_DESCRIPTION("MSM USB transceiver driver");