blob: ced34f39bdd47f29ddf308ad7d89f59af3e5b3ce [file] [log] [blame]
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301/* Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05302 *
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.
6 *
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.
11 *
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
15 * 02110-1301, USA.
16 *
17 */
18
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>
27#include <linux/io.h>
28#include <linux/ioport.h>
29#include <linux/uaccess.h>
30#include <linux/debugfs.h>
31#include <linux/seq_file.h>
Pavankumar Kondeti87c01042010-12-07 17:53:58 +053032#include <linux/pm_runtime.h>
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +030033#include <linux/of.h>
34#include <linux/of_device.h>
Ivan T. Ivanova2734542014-04-28 16:34:16 +030035#include <linux/reset.h>
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +053036
37#include <linux/usb.h>
38#include <linux/usb/otg.h>
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +030039#include <linux/usb/of.h>
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +053040#include <linux/usb/ulpi.h>
41#include <linux/usb/gadget.h>
42#include <linux/usb/hcd.h>
43#include <linux/usb/msm_hsusb.h>
44#include <linux/usb/msm_hsusb_hw.h>
Anji jonnala11aa5c42011-05-04 10:19:48 +053045#include <linux/regulator/consumer.h>
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +053046
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +053047#define MSM_USB_BASE (motg->regs)
48#define DRIVER_NAME "msm_otg"
49
50#define ULPI_IO_TIMEOUT_USEC (10 * 1000)
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +030051#define LINK_RESET_TIMEOUT_USEC (250 * 1000)
Anji jonnala11aa5c42011-05-04 10:19:48 +053052
53#define USB_PHY_3P3_VOL_MIN 3050000 /* uV */
54#define USB_PHY_3P3_VOL_MAX 3300000 /* uV */
55#define USB_PHY_3P3_HPM_LOAD 50000 /* uA */
56#define USB_PHY_3P3_LPM_LOAD 4000 /* uA */
57
58#define USB_PHY_1P8_VOL_MIN 1800000 /* uV */
59#define USB_PHY_1P8_VOL_MAX 1800000 /* uV */
60#define USB_PHY_1P8_HPM_LOAD 50000 /* uA */
61#define USB_PHY_1P8_LPM_LOAD 4000 /* uA */
62
63#define USB_PHY_VDD_DIG_VOL_MIN 1000000 /* uV */
64#define USB_PHY_VDD_DIG_VOL_MAX 1320000 /* uV */
Ivan T. Ivanov01799b62014-04-28 16:34:22 +030065#define USB_PHY_SUSP_DIG_VOL 500000 /* uV */
66
67enum vdd_levels {
68 VDD_LEVEL_NONE = 0,
69 VDD_LEVEL_MIN,
70 VDD_LEVEL_MAX,
71};
Anji jonnala11aa5c42011-05-04 10:19:48 +053072
Anji jonnala11aa5c42011-05-04 10:19:48 +053073static int msm_hsusb_init_vddcx(struct msm_otg *motg, int init)
74{
75 int ret = 0;
76
77 if (init) {
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +030078 ret = regulator_set_voltage(motg->vddcx,
Ivan T. Ivanov01799b62014-04-28 16:34:22 +030079 motg->vdd_levels[VDD_LEVEL_MIN],
80 motg->vdd_levels[VDD_LEVEL_MAX]);
Anji jonnala11aa5c42011-05-04 10:19:48 +053081 if (ret) {
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +030082 dev_err(motg->phy.dev, "Cannot set vddcx voltage\n");
Anji jonnala11aa5c42011-05-04 10:19:48 +053083 return ret;
84 }
85
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +030086 ret = regulator_enable(motg->vddcx);
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +030087 if (ret)
Heikki Krogerus1d4c9292012-02-13 13:24:09 +020088 dev_err(motg->phy.dev, "unable to enable hsusb vddcx\n");
Anji jonnala11aa5c42011-05-04 10:19:48 +053089 } else {
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +030090 ret = regulator_set_voltage(motg->vddcx, 0,
Ivan T. Ivanov01799b62014-04-28 16:34:22 +030091 motg->vdd_levels[VDD_LEVEL_MAX]);
Mark Browne99c4302011-05-15 09:55:58 -070092 if (ret)
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +030093 dev_err(motg->phy.dev, "Cannot set vddcx voltage\n");
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +030094 ret = regulator_disable(motg->vddcx);
Anji jonnala11aa5c42011-05-04 10:19:48 +053095 if (ret)
Heikki Krogerus1d4c9292012-02-13 13:24:09 +020096 dev_err(motg->phy.dev, "unable to disable hsusb vddcx\n");
Anji jonnala11aa5c42011-05-04 10:19:48 +053097 }
98
99 return ret;
100}
101
102static int msm_hsusb_ldo_init(struct msm_otg *motg, int init)
103{
104 int rc = 0;
105
106 if (init) {
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300107 rc = regulator_set_voltage(motg->v3p3, USB_PHY_3P3_VOL_MIN,
Anji jonnala11aa5c42011-05-04 10:19:48 +0530108 USB_PHY_3P3_VOL_MAX);
109 if (rc) {
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +0300110 dev_err(motg->phy.dev, "Cannot set v3p3 voltage\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +0300111 goto exit;
Anji jonnala11aa5c42011-05-04 10:19:48 +0530112 }
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300113 rc = regulator_enable(motg->v3p3);
Anji jonnala11aa5c42011-05-04 10:19:48 +0530114 if (rc) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200115 dev_err(motg->phy.dev, "unable to enable the hsusb 3p3\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +0300116 goto exit;
Anji jonnala11aa5c42011-05-04 10:19:48 +0530117 }
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300118 rc = regulator_set_voltage(motg->v1p8, USB_PHY_1P8_VOL_MIN,
Anji jonnala11aa5c42011-05-04 10:19:48 +0530119 USB_PHY_1P8_VOL_MAX);
120 if (rc) {
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +0300121 dev_err(motg->phy.dev, "Cannot set v1p8 voltage\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +0300122 goto disable_3p3;
Anji jonnala11aa5c42011-05-04 10:19:48 +0530123 }
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300124 rc = regulator_enable(motg->v1p8);
Anji jonnala11aa5c42011-05-04 10:19:48 +0530125 if (rc) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200126 dev_err(motg->phy.dev, "unable to enable the hsusb 1p8\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +0300127 goto disable_3p3;
Anji jonnala11aa5c42011-05-04 10:19:48 +0530128 }
129
130 return 0;
131 }
132
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300133 regulator_disable(motg->v1p8);
Anji jonnala11aa5c42011-05-04 10:19:48 +0530134disable_3p3:
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300135 regulator_disable(motg->v3p3);
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +0300136exit:
Anji jonnala11aa5c42011-05-04 10:19:48 +0530137 return rc;
138}
139
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300140static int msm_hsusb_ldo_set_mode(struct msm_otg *motg, int on)
Anji jonnala11aa5c42011-05-04 10:19:48 +0530141{
142 int ret = 0;
143
Anji jonnala11aa5c42011-05-04 10:19:48 +0530144 if (on) {
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300145 ret = regulator_set_optimum_mode(motg->v1p8,
Anji jonnala11aa5c42011-05-04 10:19:48 +0530146 USB_PHY_1P8_HPM_LOAD);
147 if (ret < 0) {
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +0300148 pr_err("Could not set HPM for v1p8\n");
Anji jonnala11aa5c42011-05-04 10:19:48 +0530149 return ret;
150 }
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300151 ret = regulator_set_optimum_mode(motg->v3p3,
Anji jonnala11aa5c42011-05-04 10:19:48 +0530152 USB_PHY_3P3_HPM_LOAD);
153 if (ret < 0) {
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +0300154 pr_err("Could not set HPM for v3p3\n");
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300155 regulator_set_optimum_mode(motg->v1p8,
Anji jonnala11aa5c42011-05-04 10:19:48 +0530156 USB_PHY_1P8_LPM_LOAD);
157 return ret;
158 }
159 } else {
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300160 ret = regulator_set_optimum_mode(motg->v1p8,
Anji jonnala11aa5c42011-05-04 10:19:48 +0530161 USB_PHY_1P8_LPM_LOAD);
162 if (ret < 0)
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +0300163 pr_err("Could not set LPM for v1p8\n");
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300164 ret = regulator_set_optimum_mode(motg->v3p3,
Anji jonnala11aa5c42011-05-04 10:19:48 +0530165 USB_PHY_3P3_LPM_LOAD);
166 if (ret < 0)
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +0300167 pr_err("Could not set LPM for v3p3\n");
Anji jonnala11aa5c42011-05-04 10:19:48 +0530168 }
169
170 pr_debug("reg (%s)\n", on ? "HPM" : "LPM");
171 return ret < 0 ? ret : 0;
172}
173
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200174static int ulpi_read(struct usb_phy *phy, u32 reg)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530175{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200176 struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530177 int cnt = 0;
178
179 /* initiate read operation */
180 writel(ULPI_RUN | ULPI_READ | ULPI_ADDR(reg),
181 USB_ULPI_VIEWPORT);
182
183 /* wait for completion */
184 while (cnt < ULPI_IO_TIMEOUT_USEC) {
185 if (!(readl(USB_ULPI_VIEWPORT) & ULPI_RUN))
186 break;
187 udelay(1);
188 cnt++;
189 }
190
191 if (cnt >= ULPI_IO_TIMEOUT_USEC) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200192 dev_err(phy->dev, "ulpi_read: timeout %08x\n",
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530193 readl(USB_ULPI_VIEWPORT));
194 return -ETIMEDOUT;
195 }
196 return ULPI_DATA_READ(readl(USB_ULPI_VIEWPORT));
197}
198
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200199static int ulpi_write(struct usb_phy *phy, u32 val, u32 reg)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530200{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200201 struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530202 int cnt = 0;
203
204 /* initiate write operation */
205 writel(ULPI_RUN | ULPI_WRITE |
206 ULPI_ADDR(reg) | ULPI_DATA(val),
207 USB_ULPI_VIEWPORT);
208
209 /* wait for completion */
210 while (cnt < ULPI_IO_TIMEOUT_USEC) {
211 if (!(readl(USB_ULPI_VIEWPORT) & ULPI_RUN))
212 break;
213 udelay(1);
214 cnt++;
215 }
216
217 if (cnt >= ULPI_IO_TIMEOUT_USEC) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200218 dev_err(phy->dev, "ulpi_write: timeout\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530219 return -ETIMEDOUT;
220 }
221 return 0;
222}
223
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200224static struct usb_phy_io_ops msm_otg_io_ops = {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530225 .read = ulpi_read,
226 .write = ulpi_write,
227};
228
229static void ulpi_init(struct msm_otg *motg)
230{
231 struct msm_otg_platform_data *pdata = motg->pdata;
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +0300232 int *seq = pdata->phy_init_seq, idx;
233 u32 addr = ULPI_EXT_VENDOR_SPECIFIC;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530234
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +0300235 for (idx = 0; idx < pdata->phy_init_sz; idx++) {
236 if (seq[idx] == -1)
237 continue;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530238
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200239 dev_vdbg(motg->phy.dev, "ulpi: write 0x%02x to 0x%02x\n",
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +0300240 seq[idx], addr + idx);
241 ulpi_write(&motg->phy, seq[idx], addr + idx);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530242 }
243}
244
Ivan T. Ivanov349907c2014-04-28 16:34:21 +0300245static int msm_phy_notify_disconnect(struct usb_phy *phy,
246 enum usb_device_speed speed)
247{
248 int val;
249
250 /*
251 * Put the transceiver in non-driving mode. Otherwise host
252 * may not detect soft-disconnection.
253 */
254 val = ulpi_read(phy, ULPI_FUNC_CTRL);
255 val &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
256 val |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
257 ulpi_write(phy, val, ULPI_FUNC_CTRL);
258
259 return 0;
260}
261
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530262static int msm_otg_link_clk_reset(struct msm_otg *motg, bool assert)
263{
Ivan T. Ivanova2734542014-04-28 16:34:16 +0300264 int ret;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530265
Ivan T. Ivanova2734542014-04-28 16:34:16 +0300266 if (motg->pdata->link_clk_reset)
267 ret = motg->pdata->link_clk_reset(motg->clk, assert);
268 else if (assert)
269 ret = reset_control_assert(motg->link_rst);
270 else
271 ret = reset_control_deassert(motg->link_rst);
Ivan T. Ivanov5146d772013-12-30 13:15:27 -0800272
Ivan T. Ivanov5146d772013-12-30 13:15:27 -0800273 if (ret)
274 dev_err(motg->phy.dev, "usb link clk reset %s failed\n",
275 assert ? "assert" : "deassert");
276
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530277 return ret;
278}
279
280static int msm_otg_phy_clk_reset(struct msm_otg *motg)
281{
Ivan T. Ivanova2734542014-04-28 16:34:16 +0300282 int ret;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530283
Ivan T. Ivanova2734542014-04-28 16:34:16 +0300284 if (motg->pdata->phy_clk_reset)
285 ret = motg->pdata->phy_clk_reset(motg->phy_reset_clk);
286 else
287 ret = reset_control_reset(motg->phy_rst);
Ivan T. Ivanov5146d772013-12-30 13:15:27 -0800288
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530289 if (ret)
Ivan T. Ivanov5146d772013-12-30 13:15:27 -0800290 dev_err(motg->phy.dev, "usb phy clk reset failed\n");
291
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530292 return ret;
293}
294
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +0300295static int msm_link_reset(struct msm_otg *motg)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530296{
297 u32 val;
298 int ret;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530299
300 ret = msm_otg_link_clk_reset(motg, 1);
301 if (ret)
302 return ret;
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +0300303
304 /* wait for 1ms delay as suggested in HPG. */
305 usleep_range(1000, 1200);
306
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530307 ret = msm_otg_link_clk_reset(motg, 0);
308 if (ret)
309 return ret;
310
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +0300311 if (motg->phy_number)
312 writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
313
Tim Bird9f27984b2014-04-28 16:34:19 +0300314 /* put transceiver in serial mode as part of reset */
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +0300315 val = readl(USB_PORTSC) & ~PORTSC_PTS_MASK;
Tim Bird9f27984b2014-04-28 16:34:19 +0300316 writel(val | PORTSC_PTS_SERIAL, USB_PORTSC);
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +0300317
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530318 return 0;
319}
320
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200321static int msm_otg_reset(struct usb_phy *phy)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530322{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200323 struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530324 int cnt = 0;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530325
326 writel(USBCMD_RESET, USB_USBCMD);
327 while (cnt < LINK_RESET_TIMEOUT_USEC) {
328 if (!(readl(USB_USBCMD) & USBCMD_RESET))
329 break;
330 udelay(1);
331 cnt++;
332 }
333 if (cnt >= LINK_RESET_TIMEOUT_USEC)
334 return -ETIMEDOUT;
335
Tim Bird9f27984b2014-04-28 16:34:19 +0300336 /* select ULPI phy and clear other status/control bits in PORTSC */
337 writel(PORTSC_PTS_ULPI, USB_PORTSC);
338
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +0300339 writel(0x0, USB_AHBBURST);
340 writel(0x08, USB_AHBMODE);
341
342 if (motg->phy_number)
343 writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
344 return 0;
345}
346
347static void msm_phy_reset(struct msm_otg *motg)
348{
349 void __iomem *addr;
350
351 if (motg->pdata->phy_type != SNPS_28NM_INTEGRATED_PHY) {
352 msm_otg_phy_clk_reset(motg);
353 return;
354 }
355
356 addr = USB_PHY_CTRL;
357 if (motg->phy_number)
358 addr = USB_PHY_CTRL2;
359
360 /* Assert USB PHY_POR */
361 writel(readl(addr) | PHY_POR_ASSERT, addr);
362
363 /*
364 * wait for minimum 10 microseconds as suggested in HPG.
365 * Use a slightly larger value since the exact value didn't
366 * work 100% of the time.
367 */
368 udelay(12);
369
370 /* Deassert USB PHY_POR */
371 writel(readl(addr) & ~PHY_POR_ASSERT, addr);
372}
373
374static int msm_usb_reset(struct usb_phy *phy)
375{
376 struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
377 int ret;
378
379 if (!IS_ERR(motg->core_clk))
380 clk_prepare_enable(motg->core_clk);
381
382 ret = msm_link_reset(motg);
383 if (ret) {
384 dev_err(phy->dev, "phy_reset failed\n");
385 return ret;
386 }
387
388 ret = msm_otg_reset(&motg->phy);
389 if (ret) {
390 dev_err(phy->dev, "link reset failed\n");
391 return ret;
392 }
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530393
394 msleep(100);
395
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +0300396 /* Reset USB PHY after performing USB Link RESET */
397 msm_phy_reset(motg);
398
399 if (!IS_ERR(motg->core_clk))
400 clk_disable_unprepare(motg->core_clk);
401
402 return 0;
403}
404
405static int msm_phy_init(struct usb_phy *phy)
406{
407 struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
408 struct msm_otg_platform_data *pdata = motg->pdata;
409 u32 val, ulpi_val = 0;
410
411 /* Program USB PHY Override registers. */
412 ulpi_init(motg);
413
414 /*
415 * It is recommended in HPG to reset USB PHY after programming
416 * USB PHY Override registers.
417 */
418 msm_phy_reset(motg);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530419
420 if (pdata->otg_control == OTG_PHY_CONTROL) {
421 val = readl(USB_OTGSC);
Ivan T. Ivanov971232c2014-04-28 16:34:11 +0300422 if (pdata->mode == USB_DR_MODE_OTG) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530423 ulpi_val = ULPI_INT_IDGRD | ULPI_INT_SESS_VALID;
424 val |= OTGSC_IDIE | OTGSC_BSVIE;
Ivan T. Ivanov971232c2014-04-28 16:34:11 +0300425 } else if (pdata->mode == USB_DR_MODE_PERIPHERAL) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530426 ulpi_val = ULPI_INT_SESS_VALID;
427 val |= OTGSC_BSVIE;
428 }
429 writel(val, USB_OTGSC);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200430 ulpi_write(phy, ulpi_val, ULPI_USB_INT_EN_RISE);
431 ulpi_write(phy, ulpi_val, ULPI_USB_INT_EN_FALL);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530432 }
433
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +0300434 if (motg->phy_number)
435 writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
436
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530437 return 0;
438}
439
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530440#define PHY_SUSPEND_TIMEOUT_USEC (500 * 1000)
Pavankumar Kondeti70187732011-02-15 09:42:34 +0530441#define PHY_RESUME_TIMEOUT_USEC (100 * 1000)
442
Josh Cartwrighte7d613d2014-02-18 10:36:29 -0600443#ifdef CONFIG_PM
444
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300445static int msm_hsusb_config_vddcx(struct msm_otg *motg, int high)
Josh Cartwrighte7d613d2014-02-18 10:36:29 -0600446{
Ivan T. Ivanov01799b62014-04-28 16:34:22 +0300447 int max_vol = motg->vdd_levels[VDD_LEVEL_MAX];
Josh Cartwrighte7d613d2014-02-18 10:36:29 -0600448 int min_vol;
449 int ret;
450
451 if (high)
Ivan T. Ivanov01799b62014-04-28 16:34:22 +0300452 min_vol = motg->vdd_levels[VDD_LEVEL_MIN];
Josh Cartwrighte7d613d2014-02-18 10:36:29 -0600453 else
Ivan T. Ivanov01799b62014-04-28 16:34:22 +0300454 min_vol = motg->vdd_levels[VDD_LEVEL_NONE];
Josh Cartwrighte7d613d2014-02-18 10:36:29 -0600455
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300456 ret = regulator_set_voltage(motg->vddcx, min_vol, max_vol);
Josh Cartwrighte7d613d2014-02-18 10:36:29 -0600457 if (ret) {
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +0300458 pr_err("Cannot set vddcx voltage\n");
Josh Cartwrighte7d613d2014-02-18 10:36:29 -0600459 return ret;
460 }
461
462 pr_debug("%s: min_vol:%d max_vol:%d\n", __func__, min_vol, max_vol);
463
464 return ret;
465}
466
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530467static int msm_otg_suspend(struct msm_otg *motg)
468{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200469 struct usb_phy *phy = &motg->phy;
470 struct usb_bus *bus = phy->otg->host;
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530471 struct msm_otg_platform_data *pdata = motg->pdata;
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +0300472 void __iomem *addr;
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530473 int cnt = 0;
474
475 if (atomic_read(&motg->in_lpm))
476 return 0;
477
478 disable_irq(motg->irq);
479 /*
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530480 * Chipidea 45-nm PHY suspend sequence:
481 *
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530482 * Interrupt Latch Register auto-clear feature is not present
483 * in all PHY versions. Latch register is clear on read type.
484 * Clear latch register to avoid spurious wakeup from
485 * low power mode (LPM).
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530486 *
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530487 * PHY comparators are disabled when PHY enters into low power
488 * mode (LPM). Keep PHY comparators ON in LPM only when we expect
489 * VBUS/Id notifications from USB PHY. Otherwise turn off USB
490 * PHY comparators. This save significant amount of power.
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530491 *
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530492 * PLL is not turned off when PHY enters into low power mode (LPM).
493 * Disable PLL for maximum power savings.
494 */
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530495
496 if (motg->pdata->phy_type == CI_45NM_INTEGRATED_PHY) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200497 ulpi_read(phy, 0x14);
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530498 if (pdata->otg_control == OTG_PHY_CONTROL)
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200499 ulpi_write(phy, 0x01, 0x30);
500 ulpi_write(phy, 0x08, 0x09);
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530501 }
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530502
503 /*
504 * PHY may take some time or even fail to enter into low power
505 * mode (LPM). Hence poll for 500 msec and reset the PHY and link
506 * in failure case.
507 */
508 writel(readl(USB_PORTSC) | PORTSC_PHCD, USB_PORTSC);
509 while (cnt < PHY_SUSPEND_TIMEOUT_USEC) {
510 if (readl(USB_PORTSC) & PORTSC_PHCD)
511 break;
512 udelay(1);
513 cnt++;
514 }
515
516 if (cnt >= PHY_SUSPEND_TIMEOUT_USEC) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200517 dev_err(phy->dev, "Unable to suspend PHY\n");
518 msm_otg_reset(phy);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530519 enable_irq(motg->irq);
520 return -ETIMEDOUT;
521 }
522
523 /*
524 * PHY has capability to generate interrupt asynchronously in low
525 * power mode (LPM). This interrupt is level triggered. So USB IRQ
526 * line must be disabled till async interrupt enable bit is cleared
527 * in USBCMD register. Assert STP (ULPI interface STOP signal) to
528 * block data communication from PHY.
529 */
530 writel(readl(USB_USBCMD) | ASYNC_INTR_CTRL | ULPI_STP_CTRL, USB_USBCMD);
531
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +0300532 addr = USB_PHY_CTRL;
533 if (motg->phy_number)
534 addr = USB_PHY_CTRL2;
535
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530536 if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
537 motg->pdata->otg_control == OTG_PMIC_CONTROL)
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +0300538 writel(readl(addr) | PHY_RETEN, addr);
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530539
Stephen Boydb99a8f62013-06-17 10:43:10 -0700540 clk_disable_unprepare(motg->pclk);
541 clk_disable_unprepare(motg->clk);
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +0300542 if (!IS_ERR(motg->core_clk))
Stephen Boydb99a8f62013-06-17 10:43:10 -0700543 clk_disable_unprepare(motg->core_clk);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530544
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530545 if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
546 motg->pdata->otg_control == OTG_PMIC_CONTROL) {
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300547 msm_hsusb_ldo_set_mode(motg, 0);
548 msm_hsusb_config_vddcx(motg, 0);
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530549 }
550
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200551 if (device_may_wakeup(phy->dev))
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530552 enable_irq_wake(motg->irq);
553 if (bus)
554 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &(bus_to_hcd(bus))->flags);
555
556 atomic_set(&motg->in_lpm, 1);
557 enable_irq(motg->irq);
558
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200559 dev_info(phy->dev, "USB in low power mode\n");
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530560
561 return 0;
562}
563
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530564static int msm_otg_resume(struct msm_otg *motg)
565{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200566 struct usb_phy *phy = &motg->phy;
567 struct usb_bus *bus = phy->otg->host;
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +0300568 void __iomem *addr;
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530569 int cnt = 0;
570 unsigned temp;
571
572 if (!atomic_read(&motg->in_lpm))
573 return 0;
574
Stephen Boydb99a8f62013-06-17 10:43:10 -0700575 clk_prepare_enable(motg->pclk);
576 clk_prepare_enable(motg->clk);
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +0300577 if (!IS_ERR(motg->core_clk))
Stephen Boydb99a8f62013-06-17 10:43:10 -0700578 clk_prepare_enable(motg->core_clk);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530579
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530580 if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
581 motg->pdata->otg_control == OTG_PMIC_CONTROL) {
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +0300582
583 addr = USB_PHY_CTRL;
584 if (motg->phy_number)
585 addr = USB_PHY_CTRL2;
586
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +0300587 msm_hsusb_ldo_set_mode(motg, 1);
588 msm_hsusb_config_vddcx(motg, 1);
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +0300589 writel(readl(addr) & ~PHY_RETEN, addr);
Pavankumar Kondeti04aebcb2011-05-04 10:19:49 +0530590 }
591
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530592 temp = readl(USB_USBCMD);
593 temp &= ~ASYNC_INTR_CTRL;
594 temp &= ~ULPI_STP_CTRL;
595 writel(temp, USB_USBCMD);
596
597 /*
598 * PHY comes out of low power mode (LPM) in case of wakeup
599 * from asynchronous interrupt.
600 */
601 if (!(readl(USB_PORTSC) & PORTSC_PHCD))
602 goto skip_phy_resume;
603
604 writel(readl(USB_PORTSC) & ~PORTSC_PHCD, USB_PORTSC);
605 while (cnt < PHY_RESUME_TIMEOUT_USEC) {
606 if (!(readl(USB_PORTSC) & PORTSC_PHCD))
607 break;
608 udelay(1);
609 cnt++;
610 }
611
612 if (cnt >= PHY_RESUME_TIMEOUT_USEC) {
613 /*
614 * This is a fatal error. Reset the link and
615 * PHY. USB state can not be restored. Re-insertion
616 * of USB cable is the only way to get USB working.
617 */
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +0300618 dev_err(phy->dev, "Unable to resume USB. Re-plugin the cable\n");
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200619 msm_otg_reset(phy);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530620 }
621
622skip_phy_resume:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200623 if (device_may_wakeup(phy->dev))
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530624 disable_irq_wake(motg->irq);
625 if (bus)
626 set_bit(HCD_FLAG_HW_ACCESSIBLE, &(bus_to_hcd(bus))->flags);
627
Pavankumar Kondeti2ce2c3a2011-05-02 11:56:33 +0530628 atomic_set(&motg->in_lpm, 0);
629
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530630 if (motg->async_int) {
631 motg->async_int = 0;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200632 pm_runtime_put(phy->dev);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530633 enable_irq(motg->irq);
634 }
635
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200636 dev_info(phy->dev, "USB exited from low power mode\n");
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530637
638 return 0;
639}
Pavankumar Kondeti70187732011-02-15 09:42:34 +0530640#endif
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530641
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530642static void msm_otg_notify_charger(struct msm_otg *motg, unsigned mA)
643{
644 if (motg->cur_power == mA)
645 return;
646
647 /* TODO: Notify PMIC about available current */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200648 dev_info(motg->phy.dev, "Avail curr from USB = %u\n", mA);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530649 motg->cur_power = mA;
650}
651
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200652static int msm_otg_set_power(struct usb_phy *phy, unsigned mA)
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530653{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200654 struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530655
656 /*
657 * Gadget driver uses set_power method to notify about the
658 * available current based on suspend/configured states.
659 *
660 * IDEV_CHG can be drawn irrespective of suspend/un-configured
661 * states when CDP/ACA is connected.
662 */
663 if (motg->chg_type == USB_SDP_CHARGER)
664 msm_otg_notify_charger(motg, mA);
665
666 return 0;
667}
668
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200669static void msm_otg_start_host(struct usb_phy *phy, int on)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530670{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200671 struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530672 struct msm_otg_platform_data *pdata = motg->pdata;
673 struct usb_hcd *hcd;
674
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200675 if (!phy->otg->host)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530676 return;
677
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200678 hcd = bus_to_hcd(phy->otg->host);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530679
680 if (on) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200681 dev_dbg(phy->dev, "host on\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530682
683 if (pdata->vbus_power)
684 pdata->vbus_power(1);
685 /*
686 * Some boards have a switch cotrolled by gpio
687 * to enable/disable internal HUB. Enable internal
688 * HUB before kicking the host.
689 */
690 if (pdata->setup_gpio)
691 pdata->setup_gpio(OTG_STATE_A_HOST);
692#ifdef CONFIG_USB
693 usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
Peter Chen3c9740a2013-11-05 10:46:02 +0800694 device_wakeup_enable(hcd->self.controller);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530695#endif
696 } else {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200697 dev_dbg(phy->dev, "host off\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530698
699#ifdef CONFIG_USB
700 usb_remove_hcd(hcd);
701#endif
702 if (pdata->setup_gpio)
703 pdata->setup_gpio(OTG_STATE_UNDEFINED);
704 if (pdata->vbus_power)
705 pdata->vbus_power(0);
706 }
707}
708
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200709static int msm_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530710{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200711 struct msm_otg *motg = container_of(otg->phy, struct msm_otg, phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530712 struct usb_hcd *hcd;
713
714 /*
715 * Fail host registration if this board can support
716 * only peripheral configuration.
717 */
Ivan T. Ivanov971232c2014-04-28 16:34:11 +0300718 if (motg->pdata->mode == USB_DR_MODE_PERIPHERAL) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200719 dev_info(otg->phy->dev, "Host mode is not supported\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530720 return -ENODEV;
721 }
722
723 if (!host) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200724 if (otg->phy->state == OTG_STATE_A_HOST) {
725 pm_runtime_get_sync(otg->phy->dev);
726 msm_otg_start_host(otg->phy, 0);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530727 otg->host = NULL;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200728 otg->phy->state = OTG_STATE_UNDEFINED;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530729 schedule_work(&motg->sm_work);
730 } else {
731 otg->host = NULL;
732 }
733
734 return 0;
735 }
736
737 hcd = bus_to_hcd(host);
738 hcd->power_budget = motg->pdata->power_budget;
739
740 otg->host = host;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200741 dev_dbg(otg->phy->dev, "host driver registered w/ tranceiver\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530742
743 /*
744 * Kick the state machine work, if peripheral is not supported
745 * or peripheral is already registered with us.
746 */
Ivan T. Ivanov971232c2014-04-28 16:34:11 +0300747 if (motg->pdata->mode == USB_DR_MODE_HOST || otg->gadget) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200748 pm_runtime_get_sync(otg->phy->dev);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530749 schedule_work(&motg->sm_work);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530750 }
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530751
752 return 0;
753}
754
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200755static void msm_otg_start_peripheral(struct usb_phy *phy, int on)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530756{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200757 struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530758 struct msm_otg_platform_data *pdata = motg->pdata;
759
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200760 if (!phy->otg->gadget)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530761 return;
762
763 if (on) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200764 dev_dbg(phy->dev, "gadget on\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530765 /*
766 * Some boards have a switch cotrolled by gpio
767 * to enable/disable internal HUB. Disable internal
768 * HUB before kicking the gadget.
769 */
770 if (pdata->setup_gpio)
771 pdata->setup_gpio(OTG_STATE_B_PERIPHERAL);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200772 usb_gadget_vbus_connect(phy->otg->gadget);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530773 } else {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200774 dev_dbg(phy->dev, "gadget off\n");
775 usb_gadget_vbus_disconnect(phy->otg->gadget);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530776 if (pdata->setup_gpio)
777 pdata->setup_gpio(OTG_STATE_UNDEFINED);
778 }
779
780}
781
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200782static int msm_otg_set_peripheral(struct usb_otg *otg,
783 struct usb_gadget *gadget)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530784{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200785 struct msm_otg *motg = container_of(otg->phy, struct msm_otg, phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530786
787 /*
788 * Fail peripheral registration if this board can support
789 * only host configuration.
790 */
Ivan T. Ivanov971232c2014-04-28 16:34:11 +0300791 if (motg->pdata->mode == USB_DR_MODE_HOST) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200792 dev_info(otg->phy->dev, "Peripheral mode is not supported\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530793 return -ENODEV;
794 }
795
796 if (!gadget) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200797 if (otg->phy->state == OTG_STATE_B_PERIPHERAL) {
798 pm_runtime_get_sync(otg->phy->dev);
799 msm_otg_start_peripheral(otg->phy, 0);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530800 otg->gadget = NULL;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200801 otg->phy->state = OTG_STATE_UNDEFINED;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530802 schedule_work(&motg->sm_work);
803 } else {
804 otg->gadget = NULL;
805 }
806
807 return 0;
808 }
809 otg->gadget = gadget;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200810 dev_dbg(otg->phy->dev, "peripheral driver registered w/ tranceiver\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530811
812 /*
813 * Kick the state machine work, if host is not supported
814 * or host is already registered with us.
815 */
Ivan T. Ivanov971232c2014-04-28 16:34:11 +0300816 if (motg->pdata->mode == USB_DR_MODE_PERIPHERAL || otg->host) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200817 pm_runtime_get_sync(otg->phy->dev);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530818 schedule_work(&motg->sm_work);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +0530819 }
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +0530820
821 return 0;
822}
823
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530824static bool msm_chg_check_secondary_det(struct msm_otg *motg)
825{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200826 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530827 u32 chg_det;
828 bool ret = false;
829
830 switch (motg->pdata->phy_type) {
831 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200832 chg_det = ulpi_read(phy, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530833 ret = chg_det & (1 << 4);
834 break;
835 case SNPS_28NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200836 chg_det = ulpi_read(phy, 0x87);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530837 ret = chg_det & 1;
838 break;
839 default:
840 break;
841 }
842 return ret;
843}
844
845static void msm_chg_enable_secondary_det(struct msm_otg *motg)
846{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200847 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530848 u32 chg_det;
849
850 switch (motg->pdata->phy_type) {
851 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200852 chg_det = ulpi_read(phy, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530853 /* Turn off charger block */
854 chg_det |= ~(1 << 1);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200855 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530856 udelay(20);
857 /* control chg block via ULPI */
858 chg_det &= ~(1 << 3);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200859 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530860 /* put it in host mode for enabling D- source */
861 chg_det &= ~(1 << 2);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200862 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530863 /* Turn on chg detect block */
864 chg_det &= ~(1 << 1);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200865 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530866 udelay(20);
867 /* enable chg detection */
868 chg_det &= ~(1 << 0);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200869 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530870 break;
871 case SNPS_28NM_INTEGRATED_PHY:
872 /*
873 * Configure DM as current source, DP as current sink
874 * and enable battery charging comparators.
875 */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200876 ulpi_write(phy, 0x8, 0x85);
877 ulpi_write(phy, 0x2, 0x85);
878 ulpi_write(phy, 0x1, 0x85);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530879 break;
880 default:
881 break;
882 }
883}
884
885static bool msm_chg_check_primary_det(struct msm_otg *motg)
886{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200887 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530888 u32 chg_det;
889 bool ret = false;
890
891 switch (motg->pdata->phy_type) {
892 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200893 chg_det = ulpi_read(phy, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530894 ret = chg_det & (1 << 4);
895 break;
896 case SNPS_28NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200897 chg_det = ulpi_read(phy, 0x87);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530898 ret = chg_det & 1;
899 break;
900 default:
901 break;
902 }
903 return ret;
904}
905
906static void msm_chg_enable_primary_det(struct msm_otg *motg)
907{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200908 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530909 u32 chg_det;
910
911 switch (motg->pdata->phy_type) {
912 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200913 chg_det = ulpi_read(phy, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530914 /* enable chg detection */
915 chg_det &= ~(1 << 0);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200916 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530917 break;
918 case SNPS_28NM_INTEGRATED_PHY:
919 /*
920 * Configure DP as current source, DM as current sink
921 * and enable battery charging comparators.
922 */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200923 ulpi_write(phy, 0x2, 0x85);
924 ulpi_write(phy, 0x1, 0x85);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530925 break;
926 default:
927 break;
928 }
929}
930
931static bool msm_chg_check_dcd(struct msm_otg *motg)
932{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200933 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530934 u32 line_state;
935 bool ret = false;
936
937 switch (motg->pdata->phy_type) {
938 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200939 line_state = ulpi_read(phy, 0x15);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530940 ret = !(line_state & 1);
941 break;
942 case SNPS_28NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200943 line_state = ulpi_read(phy, 0x87);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530944 ret = line_state & 2;
945 break;
946 default:
947 break;
948 }
949 return ret;
950}
951
952static void msm_chg_disable_dcd(struct msm_otg *motg)
953{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200954 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530955 u32 chg_det;
956
957 switch (motg->pdata->phy_type) {
958 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200959 chg_det = ulpi_read(phy, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530960 chg_det &= ~(1 << 5);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200961 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530962 break;
963 case SNPS_28NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200964 ulpi_write(phy, 0x10, 0x86);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530965 break;
966 default:
967 break;
968 }
969}
970
971static void msm_chg_enable_dcd(struct msm_otg *motg)
972{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200973 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530974 u32 chg_det;
975
976 switch (motg->pdata->phy_type) {
977 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200978 chg_det = ulpi_read(phy, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530979 /* Turn on D+ current source */
980 chg_det |= (1 << 5);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200981 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530982 break;
983 case SNPS_28NM_INTEGRATED_PHY:
984 /* Data contact detection enable */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200985 ulpi_write(phy, 0x10, 0x85);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530986 break;
987 default:
988 break;
989 }
990}
991
992static void msm_chg_block_on(struct msm_otg *motg)
993{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200994 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530995 u32 func_ctrl, chg_det;
996
997 /* put the controller in non-driving mode */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +0200998 func_ctrl = ulpi_read(phy, ULPI_FUNC_CTRL);
Pavankumar Kondetid8608522011-05-04 10:19:47 +0530999 func_ctrl &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
1000 func_ctrl |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001001 ulpi_write(phy, func_ctrl, ULPI_FUNC_CTRL);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301002
1003 switch (motg->pdata->phy_type) {
1004 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001005 chg_det = ulpi_read(phy, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301006 /* control chg block via ULPI */
1007 chg_det &= ~(1 << 3);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001008 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301009 /* Turn on chg detect block */
1010 chg_det &= ~(1 << 1);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001011 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301012 udelay(20);
1013 break;
1014 case SNPS_28NM_INTEGRATED_PHY:
1015 /* Clear charger detecting control bits */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001016 ulpi_write(phy, 0x3F, 0x86);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301017 /* Clear alt interrupt latch and enable bits */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001018 ulpi_write(phy, 0x1F, 0x92);
1019 ulpi_write(phy, 0x1F, 0x95);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301020 udelay(100);
1021 break;
1022 default:
1023 break;
1024 }
1025}
1026
1027static void msm_chg_block_off(struct msm_otg *motg)
1028{
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001029 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301030 u32 func_ctrl, chg_det;
1031
1032 switch (motg->pdata->phy_type) {
1033 case CI_45NM_INTEGRATED_PHY:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001034 chg_det = ulpi_read(phy, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301035 /* Turn off charger block */
1036 chg_det |= ~(1 << 1);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001037 ulpi_write(phy, chg_det, 0x34);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301038 break;
1039 case SNPS_28NM_INTEGRATED_PHY:
1040 /* Clear charger detecting control bits */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001041 ulpi_write(phy, 0x3F, 0x86);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301042 /* Clear alt interrupt latch and enable bits */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001043 ulpi_write(phy, 0x1F, 0x92);
1044 ulpi_write(phy, 0x1F, 0x95);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301045 break;
1046 default:
1047 break;
1048 }
1049
1050 /* put the controller in normal mode */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001051 func_ctrl = ulpi_read(phy, ULPI_FUNC_CTRL);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301052 func_ctrl &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
1053 func_ctrl |= ULPI_FUNC_CTRL_OPMODE_NORMAL;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001054 ulpi_write(phy, func_ctrl, ULPI_FUNC_CTRL);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301055}
1056
1057#define MSM_CHG_DCD_POLL_TIME (100 * HZ/1000) /* 100 msec */
1058#define MSM_CHG_DCD_MAX_RETRIES 6 /* Tdcd_tmout = 6 * 100 msec */
1059#define MSM_CHG_PRIMARY_DET_TIME (40 * HZ/1000) /* TVDPSRC_ON */
1060#define MSM_CHG_SECONDARY_DET_TIME (40 * HZ/1000) /* TVDMSRC_ON */
1061static void msm_chg_detect_work(struct work_struct *w)
1062{
1063 struct msm_otg *motg = container_of(w, struct msm_otg, chg_work.work);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001064 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301065 bool is_dcd, tmout, vout;
1066 unsigned long delay;
1067
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001068 dev_dbg(phy->dev, "chg detection work\n");
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301069 switch (motg->chg_state) {
1070 case USB_CHG_STATE_UNDEFINED:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001071 pm_runtime_get_sync(phy->dev);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301072 msm_chg_block_on(motg);
1073 msm_chg_enable_dcd(motg);
1074 motg->chg_state = USB_CHG_STATE_WAIT_FOR_DCD;
1075 motg->dcd_retries = 0;
1076 delay = MSM_CHG_DCD_POLL_TIME;
1077 break;
1078 case USB_CHG_STATE_WAIT_FOR_DCD:
1079 is_dcd = msm_chg_check_dcd(motg);
1080 tmout = ++motg->dcd_retries == MSM_CHG_DCD_MAX_RETRIES;
1081 if (is_dcd || tmout) {
1082 msm_chg_disable_dcd(motg);
1083 msm_chg_enable_primary_det(motg);
1084 delay = MSM_CHG_PRIMARY_DET_TIME;
1085 motg->chg_state = USB_CHG_STATE_DCD_DONE;
1086 } else {
1087 delay = MSM_CHG_DCD_POLL_TIME;
1088 }
1089 break;
1090 case USB_CHG_STATE_DCD_DONE:
1091 vout = msm_chg_check_primary_det(motg);
1092 if (vout) {
1093 msm_chg_enable_secondary_det(motg);
1094 delay = MSM_CHG_SECONDARY_DET_TIME;
1095 motg->chg_state = USB_CHG_STATE_PRIMARY_DONE;
1096 } else {
1097 motg->chg_type = USB_SDP_CHARGER;
1098 motg->chg_state = USB_CHG_STATE_DETECTED;
1099 delay = 0;
1100 }
1101 break;
1102 case USB_CHG_STATE_PRIMARY_DONE:
1103 vout = msm_chg_check_secondary_det(motg);
1104 if (vout)
1105 motg->chg_type = USB_DCP_CHARGER;
1106 else
1107 motg->chg_type = USB_CDP_CHARGER;
1108 motg->chg_state = USB_CHG_STATE_SECONDARY_DONE;
1109 /* fall through */
1110 case USB_CHG_STATE_SECONDARY_DONE:
1111 motg->chg_state = USB_CHG_STATE_DETECTED;
1112 case USB_CHG_STATE_DETECTED:
1113 msm_chg_block_off(motg);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001114 dev_dbg(phy->dev, "charger = %d\n", motg->chg_type);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301115 schedule_work(&motg->sm_work);
1116 return;
1117 default:
1118 return;
1119 }
1120
1121 schedule_delayed_work(&motg->chg_work, delay);
1122}
1123
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301124/*
1125 * We support OTG, Peripheral only and Host only configurations. In case
1126 * of OTG, mode switch (host-->peripheral/peripheral-->host) can happen
1127 * via Id pin status or user request (debugfs). Id/BSV interrupts are not
1128 * enabled when switch is controlled by user and default mode is supplied
1129 * by board file, which can be changed by userspace later.
1130 */
1131static void msm_otg_init_sm(struct msm_otg *motg)
1132{
1133 struct msm_otg_platform_data *pdata = motg->pdata;
1134 u32 otgsc = readl(USB_OTGSC);
1135
1136 switch (pdata->mode) {
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001137 case USB_DR_MODE_OTG:
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301138 if (pdata->otg_control == OTG_PHY_CONTROL) {
1139 if (otgsc & OTGSC_ID)
1140 set_bit(ID, &motg->inputs);
1141 else
1142 clear_bit(ID, &motg->inputs);
1143
1144 if (otgsc & OTGSC_BSV)
1145 set_bit(B_SESS_VLD, &motg->inputs);
1146 else
1147 clear_bit(B_SESS_VLD, &motg->inputs);
1148 } else if (pdata->otg_control == OTG_USER_CONTROL) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301149 set_bit(ID, &motg->inputs);
1150 clear_bit(B_SESS_VLD, &motg->inputs);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301151 }
1152 break;
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001153 case USB_DR_MODE_HOST:
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301154 clear_bit(ID, &motg->inputs);
1155 break;
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001156 case USB_DR_MODE_PERIPHERAL:
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301157 set_bit(ID, &motg->inputs);
1158 if (otgsc & OTGSC_BSV)
1159 set_bit(B_SESS_VLD, &motg->inputs);
1160 else
1161 clear_bit(B_SESS_VLD, &motg->inputs);
1162 break;
1163 default:
1164 break;
1165 }
1166}
1167
1168static void msm_otg_sm_work(struct work_struct *w)
1169{
1170 struct msm_otg *motg = container_of(w, struct msm_otg, sm_work);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001171 struct usb_otg *otg = motg->phy.otg;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301172
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001173 switch (otg->phy->state) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301174 case OTG_STATE_UNDEFINED:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001175 dev_dbg(otg->phy->dev, "OTG_STATE_UNDEFINED state\n");
1176 msm_otg_reset(otg->phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301177 msm_otg_init_sm(motg);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001178 otg->phy->state = OTG_STATE_B_IDLE;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301179 /* FALL THROUGH */
1180 case OTG_STATE_B_IDLE:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001181 dev_dbg(otg->phy->dev, "OTG_STATE_B_IDLE state\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301182 if (!test_bit(ID, &motg->inputs) && otg->host) {
1183 /* disable BSV bit */
1184 writel(readl(USB_OTGSC) & ~OTGSC_BSVIE, USB_OTGSC);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001185 msm_otg_start_host(otg->phy, 1);
1186 otg->phy->state = OTG_STATE_A_HOST;
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301187 } else if (test_bit(B_SESS_VLD, &motg->inputs)) {
1188 switch (motg->chg_state) {
1189 case USB_CHG_STATE_UNDEFINED:
1190 msm_chg_detect_work(&motg->chg_work.work);
1191 break;
1192 case USB_CHG_STATE_DETECTED:
1193 switch (motg->chg_type) {
1194 case USB_DCP_CHARGER:
1195 msm_otg_notify_charger(motg,
1196 IDEV_CHG_MAX);
1197 break;
1198 case USB_CDP_CHARGER:
1199 msm_otg_notify_charger(motg,
1200 IDEV_CHG_MAX);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001201 msm_otg_start_peripheral(otg->phy, 1);
1202 otg->phy->state
1203 = OTG_STATE_B_PERIPHERAL;
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301204 break;
1205 case USB_SDP_CHARGER:
1206 msm_otg_notify_charger(motg, IUNIT);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001207 msm_otg_start_peripheral(otg->phy, 1);
1208 otg->phy->state
1209 = OTG_STATE_B_PERIPHERAL;
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301210 break;
1211 default:
1212 break;
1213 }
1214 break;
1215 default:
1216 break;
1217 }
1218 } else {
1219 /*
1220 * If charger detection work is pending, decrement
1221 * the pm usage counter to balance with the one that
1222 * is incremented in charger detection work.
1223 */
1224 if (cancel_delayed_work_sync(&motg->chg_work)) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001225 pm_runtime_put_sync(otg->phy->dev);
1226 msm_otg_reset(otg->phy);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301227 }
1228 msm_otg_notify_charger(motg, 0);
1229 motg->chg_state = USB_CHG_STATE_UNDEFINED;
1230 motg->chg_type = USB_INVALID_CHARGER;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301231 }
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001232 pm_runtime_put_sync(otg->phy->dev);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301233 break;
1234 case OTG_STATE_B_PERIPHERAL:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001235 dev_dbg(otg->phy->dev, "OTG_STATE_B_PERIPHERAL state\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301236 if (!test_bit(B_SESS_VLD, &motg->inputs) ||
1237 !test_bit(ID, &motg->inputs)) {
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301238 msm_otg_notify_charger(motg, 0);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001239 msm_otg_start_peripheral(otg->phy, 0);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301240 motg->chg_state = USB_CHG_STATE_UNDEFINED;
1241 motg->chg_type = USB_INVALID_CHARGER;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001242 otg->phy->state = OTG_STATE_B_IDLE;
1243 msm_otg_reset(otg->phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301244 schedule_work(w);
1245 }
1246 break;
1247 case OTG_STATE_A_HOST:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001248 dev_dbg(otg->phy->dev, "OTG_STATE_A_HOST state\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301249 if (test_bit(ID, &motg->inputs)) {
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001250 msm_otg_start_host(otg->phy, 0);
1251 otg->phy->state = OTG_STATE_B_IDLE;
1252 msm_otg_reset(otg->phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301253 schedule_work(w);
1254 }
1255 break;
1256 default:
1257 break;
1258 }
1259}
1260
1261static irqreturn_t msm_otg_irq(int irq, void *data)
1262{
1263 struct msm_otg *motg = data;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001264 struct usb_phy *phy = &motg->phy;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301265 u32 otgsc = 0;
1266
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301267 if (atomic_read(&motg->in_lpm)) {
1268 disable_irq_nosync(irq);
1269 motg->async_int = 1;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001270 pm_runtime_get(phy->dev);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301271 return IRQ_HANDLED;
1272 }
1273
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301274 otgsc = readl(USB_OTGSC);
1275 if (!(otgsc & (OTGSC_IDIS | OTGSC_BSVIS)))
1276 return IRQ_NONE;
1277
1278 if ((otgsc & OTGSC_IDIS) && (otgsc & OTGSC_IDIE)) {
1279 if (otgsc & OTGSC_ID)
1280 set_bit(ID, &motg->inputs);
1281 else
1282 clear_bit(ID, &motg->inputs);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001283 dev_dbg(phy->dev, "ID set/clear\n");
1284 pm_runtime_get_noresume(phy->dev);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301285 } else if ((otgsc & OTGSC_BSVIS) && (otgsc & OTGSC_BSVIE)) {
1286 if (otgsc & OTGSC_BSV)
1287 set_bit(B_SESS_VLD, &motg->inputs);
1288 else
1289 clear_bit(B_SESS_VLD, &motg->inputs);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001290 dev_dbg(phy->dev, "BSV set/clear\n");
1291 pm_runtime_get_noresume(phy->dev);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301292 }
1293
1294 writel(otgsc, USB_OTGSC);
1295 schedule_work(&motg->sm_work);
1296 return IRQ_HANDLED;
1297}
1298
1299static int msm_otg_mode_show(struct seq_file *s, void *unused)
1300{
1301 struct msm_otg *motg = s->private;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001302 struct usb_otg *otg = motg->phy.otg;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301303
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001304 switch (otg->phy->state) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301305 case OTG_STATE_A_HOST:
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +03001306 seq_puts(s, "host\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301307 break;
1308 case OTG_STATE_B_PERIPHERAL:
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +03001309 seq_puts(s, "peripheral\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301310 break;
1311 default:
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +03001312 seq_puts(s, "none\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301313 break;
1314 }
1315
1316 return 0;
1317}
1318
1319static int msm_otg_mode_open(struct inode *inode, struct file *file)
1320{
1321 return single_open(file, msm_otg_mode_show, inode->i_private);
1322}
1323
1324static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
1325 size_t count, loff_t *ppos)
1326{
Pavankumar Kondetie2904ee2011-02-15 09:42:35 +05301327 struct seq_file *s = file->private_data;
1328 struct msm_otg *motg = s->private;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301329 char buf[16];
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001330 struct usb_otg *otg = motg->phy.otg;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301331 int status = count;
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001332 enum usb_dr_mode req_mode;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301333
1334 memset(buf, 0x00, sizeof(buf));
1335
1336 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) {
1337 status = -EFAULT;
1338 goto out;
1339 }
1340
1341 if (!strncmp(buf, "host", 4)) {
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001342 req_mode = USB_DR_MODE_HOST;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301343 } else if (!strncmp(buf, "peripheral", 10)) {
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001344 req_mode = USB_DR_MODE_PERIPHERAL;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301345 } else if (!strncmp(buf, "none", 4)) {
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001346 req_mode = USB_DR_MODE_UNKNOWN;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301347 } else {
1348 status = -EINVAL;
1349 goto out;
1350 }
1351
1352 switch (req_mode) {
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001353 case USB_DR_MODE_UNKNOWN:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001354 switch (otg->phy->state) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301355 case OTG_STATE_A_HOST:
1356 case OTG_STATE_B_PERIPHERAL:
1357 set_bit(ID, &motg->inputs);
1358 clear_bit(B_SESS_VLD, &motg->inputs);
1359 break;
1360 default:
1361 goto out;
1362 }
1363 break;
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001364 case USB_DR_MODE_PERIPHERAL:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001365 switch (otg->phy->state) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301366 case OTG_STATE_B_IDLE:
1367 case OTG_STATE_A_HOST:
1368 set_bit(ID, &motg->inputs);
1369 set_bit(B_SESS_VLD, &motg->inputs);
1370 break;
1371 default:
1372 goto out;
1373 }
1374 break;
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001375 case USB_DR_MODE_HOST:
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001376 switch (otg->phy->state) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301377 case OTG_STATE_B_IDLE:
1378 case OTG_STATE_B_PERIPHERAL:
1379 clear_bit(ID, &motg->inputs);
1380 break;
1381 default:
1382 goto out;
1383 }
1384 break;
1385 default:
1386 goto out;
1387 }
1388
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001389 pm_runtime_get_sync(otg->phy->dev);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301390 schedule_work(&motg->sm_work);
1391out:
1392 return status;
1393}
1394
1395const struct file_operations msm_otg_mode_fops = {
1396 .open = msm_otg_mode_open,
1397 .read = seq_read,
1398 .write = msm_otg_mode_write,
1399 .llseek = seq_lseek,
1400 .release = single_release,
1401};
1402
1403static struct dentry *msm_otg_dbg_root;
1404static struct dentry *msm_otg_dbg_mode;
1405
1406static int msm_otg_debugfs_init(struct msm_otg *motg)
1407{
1408 msm_otg_dbg_root = debugfs_create_dir("msm_otg", NULL);
1409
1410 if (!msm_otg_dbg_root || IS_ERR(msm_otg_dbg_root))
1411 return -ENODEV;
1412
1413 msm_otg_dbg_mode = debugfs_create_file("mode", S_IRUGO | S_IWUSR,
1414 msm_otg_dbg_root, motg, &msm_otg_mode_fops);
1415 if (!msm_otg_dbg_mode) {
1416 debugfs_remove(msm_otg_dbg_root);
1417 msm_otg_dbg_root = NULL;
1418 return -ENODEV;
1419 }
1420
1421 return 0;
1422}
1423
1424static void msm_otg_debugfs_cleanup(void)
1425{
1426 debugfs_remove(msm_otg_dbg_mode);
1427 debugfs_remove(msm_otg_dbg_root);
1428}
1429
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001430static struct of_device_id msm_otg_dt_match[] = {
1431 {
1432 .compatible = "qcom,usb-otg-ci",
1433 .data = (void *) CI_45NM_INTEGRATED_PHY
1434 },
1435 {
1436 .compatible = "qcom,usb-otg-snps",
1437 .data = (void *) SNPS_28NM_INTEGRATED_PHY
1438 },
1439 { }
1440};
1441MODULE_DEVICE_TABLE(of, msm_otg_dt_match);
1442
1443static int msm_otg_read_dt(struct platform_device *pdev, struct msm_otg *motg)
1444{
1445 struct msm_otg_platform_data *pdata;
1446 const struct of_device_id *id;
1447 struct device_node *node = pdev->dev.of_node;
1448 struct property *prop;
1449 int len, ret, words;
Ivan T. Ivanov01799b62014-04-28 16:34:22 +03001450 u32 val, tmp[3];
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001451
1452 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1453 if (!pdata)
1454 return -ENOMEM;
1455
1456 motg->pdata = pdata;
1457
1458 id = of_match_device(msm_otg_dt_match, &pdev->dev);
Felipe Balbib3025e62014-04-30 11:33:04 -05001459 pdata->phy_type = (enum msm_usb_phy_type) id->data;
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001460
Ivan T. Ivanova2734542014-04-28 16:34:16 +03001461 motg->link_rst = devm_reset_control_get(&pdev->dev, "link");
1462 if (IS_ERR(motg->link_rst))
1463 return PTR_ERR(motg->link_rst);
1464
1465 motg->phy_rst = devm_reset_control_get(&pdev->dev, "phy");
1466 if (IS_ERR(motg->phy_rst))
1467 return PTR_ERR(motg->phy_rst);
1468
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001469 pdata->mode = of_usb_get_dr_mode(node);
1470 if (pdata->mode == USB_DR_MODE_UNKNOWN)
1471 pdata->mode = USB_DR_MODE_OTG;
1472
1473 pdata->otg_control = OTG_PHY_CONTROL;
1474 if (!of_property_read_u32(node, "qcom,otg-control", &val))
1475 if (val == OTG_PMIC_CONTROL)
1476 pdata->otg_control = val;
1477
Ivan T. Ivanovcfa3ff52014-04-28 16:34:17 +03001478 if (!of_property_read_u32(node, "qcom,phy-num", &val) && val < 2)
1479 motg->phy_number = val;
1480
Ivan T. Ivanov01799b62014-04-28 16:34:22 +03001481 motg->vdd_levels[VDD_LEVEL_NONE] = USB_PHY_SUSP_DIG_VOL;
1482 motg->vdd_levels[VDD_LEVEL_MIN] = USB_PHY_VDD_DIG_VOL_MIN;
1483 motg->vdd_levels[VDD_LEVEL_MAX] = USB_PHY_VDD_DIG_VOL_MAX;
1484
1485 if (of_get_property(node, "qcom,vdd-levels", &len) &&
1486 len == sizeof(tmp)) {
1487 of_property_read_u32_array(node, "qcom,vdd-levels",
1488 tmp, len / sizeof(*tmp));
1489 motg->vdd_levels[VDD_LEVEL_NONE] = tmp[VDD_LEVEL_NONE];
1490 motg->vdd_levels[VDD_LEVEL_MIN] = tmp[VDD_LEVEL_MIN];
1491 motg->vdd_levels[VDD_LEVEL_MAX] = tmp[VDD_LEVEL_MAX];
1492 }
1493
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001494 prop = of_find_property(node, "qcom,phy-init-sequence", &len);
1495 if (!prop || !len)
1496 return 0;
1497
1498 words = len / sizeof(u32);
1499
1500 if (words >= ULPI_EXT_VENDOR_SPECIFIC) {
1501 dev_warn(&pdev->dev, "Too big PHY init sequence %d\n", words);
1502 return 0;
1503 }
1504
1505 pdata->phy_init_seq = devm_kzalloc(&pdev->dev, len, GFP_KERNEL);
1506 if (!pdata->phy_init_seq) {
1507 dev_warn(&pdev->dev, "No space for PHY init sequence\n");
1508 return 0;
1509 }
1510
1511 ret = of_property_read_u32_array(node, "qcom,phy-init-sequence",
1512 pdata->phy_init_seq, words);
1513 if (!ret)
1514 pdata->phy_init_sz = words;
1515
1516 return 0;
1517}
1518
Ivan T. Ivanov06a6ec42014-04-28 16:34:07 +03001519static int msm_otg_probe(struct platform_device *pdev)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301520{
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001521 struct regulator_bulk_data regs[3];
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301522 int ret = 0;
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001523 struct device_node *np = pdev->dev.of_node;
1524 struct msm_otg_platform_data *pdata;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301525 struct resource *res;
1526 struct msm_otg *motg;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001527 struct usb_phy *phy;
Tim Bird30bf8662014-04-28 16:34:20 +03001528 void __iomem *phy_select;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301529
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001530 motg = devm_kzalloc(&pdev->dev, sizeof(struct msm_otg), GFP_KERNEL);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301531 if (!motg) {
1532 dev_err(&pdev->dev, "unable to allocate msm_otg\n");
1533 return -ENOMEM;
1534 }
1535
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001536 pdata = dev_get_platdata(&pdev->dev);
1537 if (!pdata) {
1538 if (!np)
1539 return -ENXIO;
1540 ret = msm_otg_read_dt(pdev, motg);
1541 if (ret)
1542 return ret;
1543 }
1544
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001545 motg->phy.otg = devm_kzalloc(&pdev->dev, sizeof(struct usb_otg),
1546 GFP_KERNEL);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001547 if (!motg->phy.otg) {
1548 dev_err(&pdev->dev, "unable to allocate msm_otg\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001549 return -ENOMEM;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001550 }
1551
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001552 phy = &motg->phy;
1553 phy->dev = &pdev->dev;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301554
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001555 motg->phy_reset_clk = devm_clk_get(&pdev->dev,
1556 np ? "phy" : "usb_phy_clk");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301557 if (IS_ERR(motg->phy_reset_clk)) {
1558 dev_err(&pdev->dev, "failed to get usb_phy_clk\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001559 return PTR_ERR(motg->phy_reset_clk);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301560 }
1561
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001562 motg->clk = devm_clk_get(&pdev->dev, np ? "core" : "usb_hs_clk");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301563 if (IS_ERR(motg->clk)) {
1564 dev_err(&pdev->dev, "failed to get usb_hs_clk\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001565 return PTR_ERR(motg->clk);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301566 }
Anji jonnala0f73cac2011-05-04 10:19:46 +05301567
1568 /*
1569 * If USB Core is running its protocol engine based on CORE CLK,
1570 * CORE CLK must be running at >55Mhz for correct HSUSB
1571 * operation and USB core cannot tolerate frequency changes on
Ivan T. Ivanovff0e4a62014-04-28 16:34:12 +03001572 * CORE CLK.
Anji jonnala0f73cac2011-05-04 10:19:46 +05301573 */
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001574 motg->pclk = devm_clk_get(&pdev->dev, np ? "iface" : "usb_hs_pclk");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301575 if (IS_ERR(motg->pclk)) {
1576 dev_err(&pdev->dev, "failed to get usb_hs_pclk\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001577 return PTR_ERR(motg->pclk);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301578 }
1579
1580 /*
1581 * USB core clock is not present on all MSM chips. This
1582 * clock is introduced to remove the dependency on AXI
1583 * bus frequency.
1584 */
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001585 motg->core_clk = devm_clk_get(&pdev->dev,
1586 np ? "alt_core" : "usb_hs_core_clk");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301587
1588 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
Dan Carpenter2ea7b142014-05-19 23:35:19 +03001589 if (!res)
1590 return -EINVAL;
1591 motg->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
1592 if (!motg->regs)
1593 return -ENOMEM;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301594
Tim Bird30bf8662014-04-28 16:34:20 +03001595 /*
1596 * NOTE: The PHYs can be multiplexed between the chipidea controller
1597 * and the dwc3 controller, using a single bit. It is important that
1598 * the dwc3 driver does not set this bit in an incompatible way.
1599 */
1600 if (motg->phy_number) {
1601 phy_select = devm_ioremap_nocache(&pdev->dev, USB2_PHY_SEL, 4);
1602 if (IS_ERR(phy_select))
1603 return PTR_ERR(phy_select);
1604 /* Enable second PHY with the OTG port */
Felipe Balbi24597492014-04-30 11:35:22 -05001605 writel(0x1, phy_select);
Tim Bird30bf8662014-04-28 16:34:20 +03001606 }
1607
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301608 dev_info(&pdev->dev, "OTG regs = %p\n", motg->regs);
1609
1610 motg->irq = platform_get_irq(pdev, 0);
Ivan T. Ivanovf60c1142014-04-28 16:34:14 +03001611 if (motg->irq < 0) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301612 dev_err(&pdev->dev, "platform_get_irq failed\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001613 return motg->irq;
1614 }
1615
Ivan T. Ivanovf5ef2372014-04-28 16:34:13 +03001616 regs[0].supply = "vddcx";
1617 regs[1].supply = "v3p3";
1618 regs[2].supply = "v1p8";
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001619
1620 ret = devm_regulator_bulk_get(motg->phy.dev, ARRAY_SIZE(regs), regs);
1621 if (ret)
1622 return ret;
1623
1624 motg->vddcx = regs[0].consumer;
1625 motg->v3p3 = regs[1].consumer;
1626 motg->v1p8 = regs[2].consumer;
1627
1628 clk_set_rate(motg->clk, 60000000);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301629
Stephen Boydb99a8f62013-06-17 10:43:10 -07001630 clk_prepare_enable(motg->clk);
1631 clk_prepare_enable(motg->pclk);
Anji jonnala11aa5c42011-05-04 10:19:48 +05301632
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001633 if (!IS_ERR(motg->core_clk))
1634 clk_prepare_enable(motg->core_clk);
1635
Anji jonnala11aa5c42011-05-04 10:19:48 +05301636 ret = msm_hsusb_init_vddcx(motg, 1);
1637 if (ret) {
1638 dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001639 goto disable_clks;
Anji jonnala11aa5c42011-05-04 10:19:48 +05301640 }
1641
1642 ret = msm_hsusb_ldo_init(motg, 1);
1643 if (ret) {
1644 dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001645 goto disable_vddcx;
Anji jonnala11aa5c42011-05-04 10:19:48 +05301646 }
Ivan T. Ivanov37cfdaf2014-04-28 16:34:06 +03001647 ret = msm_hsusb_ldo_set_mode(motg, 1);
Anji jonnala11aa5c42011-05-04 10:19:48 +05301648 if (ret) {
1649 dev_err(&pdev->dev, "hsusb vreg enable failed\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001650 goto disable_ldo;
Anji jonnala11aa5c42011-05-04 10:19:48 +05301651 }
1652
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301653 writel(0, USB_USBINTR);
1654 writel(0, USB_OTGSC);
1655
1656 INIT_WORK(&motg->sm_work, msm_otg_sm_work);
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301657 INIT_DELAYED_WORK(&motg->chg_work, msm_chg_detect_work);
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001658 ret = devm_request_irq(&pdev->dev, motg->irq, msm_otg_irq, IRQF_SHARED,
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301659 "msm_otg", motg);
1660 if (ret) {
1661 dev_err(&pdev->dev, "request irq failed\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001662 goto disable_ldo;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301663 }
1664
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +03001665 phy->init = msm_phy_init;
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001666 phy->set_power = msm_otg_set_power;
Ivan T. Ivanov349907c2014-04-28 16:34:21 +03001667 phy->notify_disconnect = msm_phy_notify_disconnect;
Ivan T. Ivanove695abb2014-04-28 16:34:23 +03001668 phy->type = USB_PHY_TYPE_USB2;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301669
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001670 phy->io_ops = &msm_otg_io_ops;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301671
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001672 phy->otg->phy = &motg->phy;
1673 phy->otg->set_host = msm_otg_set_host;
1674 phy->otg->set_peripheral = msm_otg_set_peripheral;
1675
Ivan T. Ivanovd69c6f52014-04-28 16:34:18 +03001676 msm_usb_reset(phy);
1677
Ivan T. Ivanove695abb2014-04-28 16:34:23 +03001678 ret = usb_add_phy_dev(&motg->phy);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301679 if (ret) {
Kishon Vijay Abraham I721002e2012-06-22 17:02:45 +05301680 dev_err(&pdev->dev, "usb_add_phy failed\n");
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001681 goto disable_ldo;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301682 }
1683
1684 platform_set_drvdata(pdev, motg);
1685 device_init_wakeup(&pdev->dev, 1);
1686
Ivan T. Ivanov971232c2014-04-28 16:34:11 +03001687 if (motg->pdata->mode == USB_DR_MODE_OTG &&
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001688 motg->pdata->otg_control == OTG_USER_CONTROL) {
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301689 ret = msm_otg_debugfs_init(motg);
1690 if (ret)
Ivan T. Ivanov3aca0fa2014-04-28 16:34:10 +03001691 dev_dbg(&pdev->dev, "Can not create mode change file\n");
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301692 }
1693
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301694 pm_runtime_set_active(&pdev->dev);
1695 pm_runtime_enable(&pdev->dev);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301696
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301697 return 0;
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001698
1699disable_ldo:
1700 msm_hsusb_ldo_init(motg, 0);
1701disable_vddcx:
1702 msm_hsusb_init_vddcx(motg, 0);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301703disable_clks:
Stephen Boydb99a8f62013-06-17 10:43:10 -07001704 clk_disable_unprepare(motg->pclk);
1705 clk_disable_unprepare(motg->clk);
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001706 if (!IS_ERR(motg->core_clk))
1707 clk_disable_unprepare(motg->core_clk);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301708 return ret;
1709}
1710
Bill Pembertonfb4e98a2012-11-19 13:26:20 -05001711static int msm_otg_remove(struct platform_device *pdev)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301712{
1713 struct msm_otg *motg = platform_get_drvdata(pdev);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001714 struct usb_phy *phy = &motg->phy;
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301715 int cnt = 0;
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301716
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001717 if (phy->otg->host || phy->otg->gadget)
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301718 return -EBUSY;
1719
1720 msm_otg_debugfs_cleanup();
Pavankumar Kondetid8608522011-05-04 10:19:47 +05301721 cancel_delayed_work_sync(&motg->chg_work);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301722 cancel_work_sync(&motg->sm_work);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301723
Pavankumar Kondeti70187732011-02-15 09:42:34 +05301724 pm_runtime_resume(&pdev->dev);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301725
1726 device_init_wakeup(&pdev->dev, 0);
1727 pm_runtime_disable(&pdev->dev);
1728
Kishon Vijay Abraham I662dca52012-06-22 17:02:46 +05301729 usb_remove_phy(phy);
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001730 disable_irq(motg->irq);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301731
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301732 /*
1733 * Put PHY in low power mode.
1734 */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001735 ulpi_read(phy, 0x14);
1736 ulpi_write(phy, 0x08, 0x09);
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301737
1738 writel(readl(USB_PORTSC) | PORTSC_PHCD, USB_PORTSC);
1739 while (cnt < PHY_SUSPEND_TIMEOUT_USEC) {
1740 if (readl(USB_PORTSC) & PORTSC_PHCD)
1741 break;
1742 udelay(1);
1743 cnt++;
1744 }
1745 if (cnt >= PHY_SUSPEND_TIMEOUT_USEC)
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001746 dev_err(phy->dev, "Unable to suspend PHY\n");
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301747
Stephen Boydb99a8f62013-06-17 10:43:10 -07001748 clk_disable_unprepare(motg->pclk);
1749 clk_disable_unprepare(motg->clk);
Ivan T. Ivanov6b99c68e2014-04-28 16:34:08 +03001750 if (!IS_ERR(motg->core_clk))
Stephen Boydb99a8f62013-06-17 10:43:10 -07001751 clk_disable_unprepare(motg->core_clk);
Anji jonnala11aa5c42011-05-04 10:19:48 +05301752 msm_hsusb_ldo_init(motg, 0);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301753
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301754 pm_runtime_set_suspended(&pdev->dev);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301755
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301756 return 0;
1757}
1758
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301759#ifdef CONFIG_PM_RUNTIME
1760static int msm_otg_runtime_idle(struct device *dev)
1761{
1762 struct msm_otg *motg = dev_get_drvdata(dev);
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001763 struct usb_otg *otg = motg->phy.otg;
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301764
1765 dev_dbg(dev, "OTG runtime idle\n");
1766
1767 /*
1768 * It is observed some times that a spurious interrupt
1769 * comes when PHY is put into LPM immediately after PHY reset.
1770 * This 1 sec delay also prevents entering into LPM immediately
1771 * after asynchronous interrupt.
1772 */
Heikki Krogerus1d4c9292012-02-13 13:24:09 +02001773 if (otg->phy->state != OTG_STATE_UNDEFINED)
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301774 pm_schedule_suspend(dev, 1000);
1775
1776 return -EAGAIN;
1777}
1778
1779static int msm_otg_runtime_suspend(struct device *dev)
1780{
1781 struct msm_otg *motg = dev_get_drvdata(dev);
1782
1783 dev_dbg(dev, "OTG runtime suspend\n");
1784 return msm_otg_suspend(motg);
1785}
1786
1787static int msm_otg_runtime_resume(struct device *dev)
1788{
1789 struct msm_otg *motg = dev_get_drvdata(dev);
1790
1791 dev_dbg(dev, "OTG runtime resume\n");
1792 return msm_otg_resume(motg);
1793}
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301794#endif
1795
Pavankumar Kondeti70187732011-02-15 09:42:34 +05301796#ifdef CONFIG_PM_SLEEP
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301797static int msm_otg_pm_suspend(struct device *dev)
1798{
1799 struct msm_otg *motg = dev_get_drvdata(dev);
1800
1801 dev_dbg(dev, "OTG PM suspend\n");
1802 return msm_otg_suspend(motg);
1803}
1804
1805static int msm_otg_pm_resume(struct device *dev)
1806{
1807 struct msm_otg *motg = dev_get_drvdata(dev);
1808 int ret;
1809
1810 dev_dbg(dev, "OTG PM resume\n");
1811
1812 ret = msm_otg_resume(motg);
1813 if (ret)
1814 return ret;
1815
1816 /*
1817 * Runtime PM Documentation recommends bringing the
1818 * device to full powered state upon resume.
1819 */
1820 pm_runtime_disable(dev);
1821 pm_runtime_set_active(dev);
1822 pm_runtime_enable(dev);
1823
1824 return 0;
1825}
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301826#endif
1827
1828static const struct dev_pm_ops msm_otg_dev_pm_ops = {
Pavankumar Kondeti70187732011-02-15 09:42:34 +05301829 SET_SYSTEM_SLEEP_PM_OPS(msm_otg_pm_suspend, msm_otg_pm_resume)
1830 SET_RUNTIME_PM_OPS(msm_otg_runtime_suspend, msm_otg_runtime_resume,
1831 msm_otg_runtime_idle)
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301832};
1833
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301834static struct platform_driver msm_otg_driver = {
Ivan T. Ivanov06a6ec42014-04-28 16:34:07 +03001835 .probe = msm_otg_probe,
Bill Pemberton76904172012-11-19 13:21:08 -05001836 .remove = msm_otg_remove,
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301837 .driver = {
1838 .name = DRIVER_NAME,
1839 .owner = THIS_MODULE,
Pavankumar Kondeti87c01042010-12-07 17:53:58 +05301840 .pm = &msm_otg_dev_pm_ops,
Ivan T. Ivanov8364f9a2014-04-28 16:34:15 +03001841 .of_match_table = msm_otg_dt_match,
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301842 },
1843};
1844
Ivan T. Ivanov06a6ec42014-04-28 16:34:07 +03001845module_platform_driver(msm_otg_driver);
Pavankumar Kondetie0c201f2010-12-07 17:53:55 +05301846
1847MODULE_LICENSE("GPL v2");
1848MODULE_DESCRIPTION("MSM USB transceiver driver");