2011-03-10 01:28:55 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2010 Google, Inc.
|
2013-05-16 16:13:02 +02:00
|
|
|
* Copyright (C) 2013 NVIDIA Corporation
|
2011-03-10 01:28:55 +01:00
|
|
|
*
|
|
|
|
* Author:
|
|
|
|
* Erik Gilling <konkers@google.com>
|
|
|
|
* Benoit Goby <benoit@android.com>
|
2013-05-16 16:13:02 +02:00
|
|
|
* Venu Byravarasu <vbyravarasu@nvidia.com>
|
2011-03-10 01:28:55 +01:00
|
|
|
*
|
|
|
|
* This software is licensed under the terms of the GNU General Public
|
|
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
|
|
* may be copied, distributed, and modified under those terms.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/resource.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/err.h>
|
2012-03-02 21:58:42 +01:00
|
|
|
#include <linux/export.h>
|
2013-06-13 19:24:08 +02:00
|
|
|
#include <linux/module.h>
|
2011-03-10 01:28:55 +01:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/gpio.h>
|
2013-01-16 04:30:20 +01:00
|
|
|
#include <linux/of.h>
|
2013-08-12 15:06:51 +02:00
|
|
|
#include <linux/of_device.h>
|
2012-04-12 23:46:49 +02:00
|
|
|
#include <linux/of_gpio.h>
|
2011-03-10 01:28:55 +01:00
|
|
|
#include <linux/usb/otg.h>
|
|
|
|
#include <linux/usb/ulpi.h>
|
2013-07-25 20:38:08 +02:00
|
|
|
#include <linux/usb/of.h>
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
#include <linux/usb/ehci_def.h>
|
2012-09-05 15:20:23 +02:00
|
|
|
#include <linux/usb/tegra_usb_phy.h>
|
2013-07-17 09:37:49 +02:00
|
|
|
#include <linux/regulator/consumer.h>
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
#define ULPI_VIEWPORT 0x170
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
/* PORTSC PTS/PHCD bits, Tegra20 only */
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
#define TEGRA_USB_PORTSC1 0x184
|
|
|
|
#define TEGRA_USB_PORTSC1_PTS(x) (((x) & 0x3) << 30)
|
|
|
|
#define TEGRA_USB_PORTSC1_PHCD (1 << 23)
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
/* HOSTPC1 PTS/PHCD bits, Tegra30 and above */
|
|
|
|
#define TEGRA_USB_HOSTPC1_DEVLC 0x1b4
|
|
|
|
#define TEGRA_USB_HOSTPC1_DEVLC_PTS(x) (((x) & 0x7) << 29)
|
|
|
|
#define TEGRA_USB_HOSTPC1_DEVLC_PHCD (1 << 22)
|
|
|
|
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
/* Bits of PORTSC1, which will get cleared by writing 1 into them */
|
|
|
|
#define TEGRA_PORTSC1_RWC_BITS (PORT_CSC | PORT_PEC | PORT_OCC)
|
|
|
|
|
2011-03-10 01:28:55 +01:00
|
|
|
#define USB_SUSP_CTRL 0x400
|
|
|
|
#define USB_WAKE_ON_CNNT_EN_DEV (1 << 3)
|
|
|
|
#define USB_WAKE_ON_DISCON_EN_DEV (1 << 4)
|
|
|
|
#define USB_SUSP_CLR (1 << 5)
|
|
|
|
#define USB_PHY_CLK_VALID (1 << 7)
|
|
|
|
#define UTMIP_RESET (1 << 11)
|
|
|
|
#define UHSIC_RESET (1 << 11)
|
|
|
|
#define UTMIP_PHY_ENABLE (1 << 12)
|
|
|
|
#define ULPI_PHY_ENABLE (1 << 13)
|
|
|
|
#define USB_SUSP_SET (1 << 14)
|
|
|
|
#define USB_WAKEUP_DEBOUNCE_COUNT(x) (((x) & 0x7) << 16)
|
|
|
|
|
|
|
|
#define USB1_LEGACY_CTRL 0x410
|
|
|
|
#define USB1_NO_LEGACY_MODE (1 << 0)
|
|
|
|
#define USB1_VBUS_SENSE_CTL_MASK (3 << 1)
|
|
|
|
#define USB1_VBUS_SENSE_CTL_VBUS_WAKEUP (0 << 1)
|
|
|
|
#define USB1_VBUS_SENSE_CTL_AB_SESS_VLD_OR_VBUS_WAKEUP \
|
|
|
|
(1 << 1)
|
|
|
|
#define USB1_VBUS_SENSE_CTL_AB_SESS_VLD (2 << 1)
|
|
|
|
#define USB1_VBUS_SENSE_CTL_A_SESS_VLD (3 << 1)
|
|
|
|
|
|
|
|
#define ULPI_TIMING_CTRL_0 0x424
|
|
|
|
#define ULPI_OUTPUT_PINMUX_BYP (1 << 10)
|
|
|
|
#define ULPI_CLKOUT_PINMUX_BYP (1 << 11)
|
|
|
|
|
|
|
|
#define ULPI_TIMING_CTRL_1 0x428
|
|
|
|
#define ULPI_DATA_TRIMMER_LOAD (1 << 0)
|
|
|
|
#define ULPI_DATA_TRIMMER_SEL(x) (((x) & 0x7) << 1)
|
|
|
|
#define ULPI_STPDIRNXT_TRIMMER_LOAD (1 << 16)
|
|
|
|
#define ULPI_STPDIRNXT_TRIMMER_SEL(x) (((x) & 0x7) << 17)
|
|
|
|
#define ULPI_DIR_TRIMMER_LOAD (1 << 24)
|
|
|
|
#define ULPI_DIR_TRIMMER_SEL(x) (((x) & 0x7) << 25)
|
|
|
|
|
|
|
|
#define UTMIP_PLL_CFG1 0x804
|
|
|
|
#define UTMIP_XTAL_FREQ_COUNT(x) (((x) & 0xfff) << 0)
|
|
|
|
#define UTMIP_PLLU_ENABLE_DLY_COUNT(x) (((x) & 0x1f) << 27)
|
|
|
|
|
|
|
|
#define UTMIP_XCVR_CFG0 0x808
|
|
|
|
#define UTMIP_XCVR_SETUP(x) (((x) & 0xf) << 0)
|
2013-08-12 15:06:50 +02:00
|
|
|
#define UTMIP_XCVR_SETUP_MSB(x) ((((x) & 0x70) >> 4) << 22)
|
2011-03-10 01:28:55 +01:00
|
|
|
#define UTMIP_XCVR_LSRSLEW(x) (((x) & 0x3) << 8)
|
|
|
|
#define UTMIP_XCVR_LSFSLEW(x) (((x) & 0x3) << 10)
|
|
|
|
#define UTMIP_FORCE_PD_POWERDOWN (1 << 14)
|
|
|
|
#define UTMIP_FORCE_PD2_POWERDOWN (1 << 16)
|
|
|
|
#define UTMIP_FORCE_PDZI_POWERDOWN (1 << 18)
|
2013-08-12 15:06:50 +02:00
|
|
|
#define UTMIP_XCVR_LSBIAS_SEL (1 << 21)
|
2013-08-12 15:06:53 +02:00
|
|
|
#define UTMIP_XCVR_HSSLEW(x) (((x) & 0x3) << 4)
|
|
|
|
#define UTMIP_XCVR_HSSLEW_MSB(x) ((((x) & 0x1fc) >> 2) << 25)
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
#define UTMIP_BIAS_CFG0 0x80c
|
|
|
|
#define UTMIP_OTGPD (1 << 11)
|
|
|
|
#define UTMIP_BIASPD (1 << 10)
|
2013-08-12 15:06:53 +02:00
|
|
|
#define UTMIP_HSSQUELCH_LEVEL(x) (((x) & 0x3) << 0)
|
|
|
|
#define UTMIP_HSDISCON_LEVEL(x) (((x) & 0x3) << 2)
|
|
|
|
#define UTMIP_HSDISCON_LEVEL_MSB(x) ((((x) & 0x4) >> 2) << 24)
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
#define UTMIP_HSRX_CFG0 0x810
|
|
|
|
#define UTMIP_ELASTIC_LIMIT(x) (((x) & 0x1f) << 10)
|
|
|
|
#define UTMIP_IDLE_WAIT(x) (((x) & 0x1f) << 15)
|
|
|
|
|
|
|
|
#define UTMIP_HSRX_CFG1 0x814
|
|
|
|
#define UTMIP_HS_SYNC_START_DLY(x) (((x) & 0x1f) << 1)
|
|
|
|
|
|
|
|
#define UTMIP_TX_CFG0 0x820
|
|
|
|
#define UTMIP_FS_PREABMLE_J (1 << 19)
|
|
|
|
#define UTMIP_HS_DISCON_DISABLE (1 << 8)
|
|
|
|
|
|
|
|
#define UTMIP_MISC_CFG0 0x824
|
|
|
|
#define UTMIP_DPDM_OBSERVE (1 << 26)
|
|
|
|
#define UTMIP_DPDM_OBSERVE_SEL(x) (((x) & 0xf) << 27)
|
|
|
|
#define UTMIP_DPDM_OBSERVE_SEL_FS_J UTMIP_DPDM_OBSERVE_SEL(0xf)
|
|
|
|
#define UTMIP_DPDM_OBSERVE_SEL_FS_K UTMIP_DPDM_OBSERVE_SEL(0xe)
|
|
|
|
#define UTMIP_DPDM_OBSERVE_SEL_FS_SE1 UTMIP_DPDM_OBSERVE_SEL(0xd)
|
|
|
|
#define UTMIP_DPDM_OBSERVE_SEL_FS_SE0 UTMIP_DPDM_OBSERVE_SEL(0xc)
|
|
|
|
#define UTMIP_SUSPEND_EXIT_ON_EDGE (1 << 22)
|
|
|
|
|
|
|
|
#define UTMIP_MISC_CFG1 0x828
|
|
|
|
#define UTMIP_PLL_ACTIVE_DLY_COUNT(x) (((x) & 0x1f) << 18)
|
|
|
|
#define UTMIP_PLLU_STABLE_COUNT(x) (((x) & 0xfff) << 6)
|
|
|
|
|
|
|
|
#define UTMIP_DEBOUNCE_CFG0 0x82c
|
|
|
|
#define UTMIP_BIAS_DEBOUNCE_A(x) (((x) & 0xffff) << 0)
|
|
|
|
|
|
|
|
#define UTMIP_BAT_CHRG_CFG0 0x830
|
|
|
|
#define UTMIP_PD_CHRG (1 << 0)
|
|
|
|
|
|
|
|
#define UTMIP_SPARE_CFG0 0x834
|
|
|
|
#define FUSE_SETUP_SEL (1 << 3)
|
|
|
|
|
|
|
|
#define UTMIP_XCVR_CFG1 0x838
|
|
|
|
#define UTMIP_FORCE_PDDISC_POWERDOWN (1 << 0)
|
|
|
|
#define UTMIP_FORCE_PDCHRP_POWERDOWN (1 << 2)
|
|
|
|
#define UTMIP_FORCE_PDDR_POWERDOWN (1 << 4)
|
|
|
|
#define UTMIP_XCVR_TERM_RANGE_ADJ(x) (((x) & 0xf) << 18)
|
|
|
|
|
|
|
|
#define UTMIP_BIAS_CFG1 0x83c
|
|
|
|
#define UTMIP_BIAS_PDTRK_COUNT(x) (((x) & 0x1f) << 3)
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
/* For Tegra30 and above only, the address is different in Tegra20 */
|
|
|
|
#define USB_USBMODE 0x1f8
|
|
|
|
#define USB_USBMODE_MASK (3 << 0)
|
|
|
|
#define USB_USBMODE_HOST (3 << 0)
|
|
|
|
#define USB_USBMODE_DEVICE (2 << 0)
|
|
|
|
|
2011-03-10 01:28:55 +01:00
|
|
|
static DEFINE_SPINLOCK(utmip_pad_lock);
|
|
|
|
static int utmip_pad_count;
|
|
|
|
|
|
|
|
struct tegra_xtal_freq {
|
|
|
|
int freq;
|
|
|
|
u8 enable_delay;
|
|
|
|
u8 stable_count;
|
|
|
|
u8 active_delay;
|
|
|
|
u8 xtal_freq_count;
|
|
|
|
u16 debounce;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct tegra_xtal_freq tegra_freq_table[] = {
|
|
|
|
{
|
|
|
|
.freq = 12000000,
|
|
|
|
.enable_delay = 0x02,
|
|
|
|
.stable_count = 0x2F,
|
|
|
|
.active_delay = 0x04,
|
|
|
|
.xtal_freq_count = 0x76,
|
|
|
|
.debounce = 0x7530,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.freq = 13000000,
|
|
|
|
.enable_delay = 0x02,
|
|
|
|
.stable_count = 0x33,
|
|
|
|
.active_delay = 0x05,
|
|
|
|
.xtal_freq_count = 0x7F,
|
|
|
|
.debounce = 0x7EF4,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.freq = 19200000,
|
|
|
|
.enable_delay = 0x03,
|
|
|
|
.stable_count = 0x4B,
|
|
|
|
.active_delay = 0x06,
|
|
|
|
.xtal_freq_count = 0xBB,
|
|
|
|
.debounce = 0xBB80,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.freq = 26000000,
|
|
|
|
.enable_delay = 0x04,
|
|
|
|
.stable_count = 0x66,
|
|
|
|
.active_delay = 0x09,
|
|
|
|
.xtal_freq_count = 0xFE,
|
|
|
|
.debounce = 0xFDE8,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
static void set_pts(struct tegra_usb_phy *phy, u8 pts_val)
|
|
|
|
{
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
unsigned long val;
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
if (phy->soc_config->has_hostpc) {
|
|
|
|
val = readl(base + TEGRA_USB_HOSTPC1_DEVLC);
|
|
|
|
val &= ~TEGRA_USB_HOSTPC1_DEVLC_PTS(~0);
|
|
|
|
val |= TEGRA_USB_HOSTPC1_DEVLC_PTS(pts_val);
|
|
|
|
writel(val, base + TEGRA_USB_HOSTPC1_DEVLC);
|
|
|
|
} else {
|
|
|
|
val = readl(base + TEGRA_USB_PORTSC1) & ~TEGRA_PORTSC1_RWC_BITS;
|
|
|
|
val &= ~TEGRA_USB_PORTSC1_PTS(~0);
|
|
|
|
val |= TEGRA_USB_PORTSC1_PTS(pts_val);
|
|
|
|
writel(val, base + TEGRA_USB_PORTSC1);
|
|
|
|
}
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void set_phcd(struct tegra_usb_phy *phy, bool enable)
|
|
|
|
{
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
unsigned long val;
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
if (phy->soc_config->has_hostpc) {
|
|
|
|
val = readl(base + TEGRA_USB_HOSTPC1_DEVLC);
|
|
|
|
if (enable)
|
|
|
|
val |= TEGRA_USB_HOSTPC1_DEVLC_PHCD;
|
|
|
|
else
|
|
|
|
val &= ~TEGRA_USB_HOSTPC1_DEVLC_PHCD;
|
|
|
|
writel(val, base + TEGRA_USB_HOSTPC1_DEVLC);
|
|
|
|
} else {
|
|
|
|
val = readl(base + TEGRA_USB_PORTSC1) & ~PORT_RWC_BITS;
|
|
|
|
if (enable)
|
|
|
|
val |= TEGRA_USB_PORTSC1_PHCD;
|
|
|
|
else
|
|
|
|
val &= ~TEGRA_USB_PORTSC1_PHCD;
|
|
|
|
writel(val, base + TEGRA_USB_PORTSC1);
|
|
|
|
}
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
}
|
|
|
|
|
2011-03-10 01:28:55 +01:00
|
|
|
static int utmip_pad_open(struct tegra_usb_phy *phy)
|
|
|
|
{
|
2013-07-25 20:38:01 +02:00
|
|
|
phy->pad_clk = devm_clk_get(phy->u_phy.dev, "utmi-pads");
|
2011-03-10 01:28:55 +01:00
|
|
|
if (IS_ERR(phy->pad_clk)) {
|
|
|
|
pr_err("%s: can't get utmip pad clock\n", __func__);
|
|
|
|
return PTR_ERR(phy->pad_clk);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void utmip_pad_power_on(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long val, flags;
|
|
|
|
void __iomem *base = phy->pad_regs;
|
2013-08-12 15:06:53 +02:00
|
|
|
struct tegra_utmip_config *config = phy->config;
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2012-06-05 06:29:35 +02:00
|
|
|
clk_prepare_enable(phy->pad_clk);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
spin_lock_irqsave(&utmip_pad_lock, flags);
|
|
|
|
|
|
|
|
if (utmip_pad_count++ == 0) {
|
|
|
|
val = readl(base + UTMIP_BIAS_CFG0);
|
|
|
|
val &= ~(UTMIP_OTGPD | UTMIP_BIASPD);
|
2013-08-12 15:06:53 +02:00
|
|
|
|
|
|
|
if (phy->soc_config->requires_extra_tuning_parameters) {
|
|
|
|
val &= ~(UTMIP_HSSQUELCH_LEVEL(~0) |
|
|
|
|
UTMIP_HSDISCON_LEVEL(~0) |
|
|
|
|
UTMIP_HSDISCON_LEVEL_MSB(~0));
|
|
|
|
|
|
|
|
val |= UTMIP_HSSQUELCH_LEVEL(config->hssquelch_level);
|
|
|
|
val |= UTMIP_HSDISCON_LEVEL(config->hsdiscon_level);
|
|
|
|
val |= UTMIP_HSDISCON_LEVEL_MSB(config->hsdiscon_level);
|
|
|
|
}
|
2011-03-10 01:28:55 +01:00
|
|
|
writel(val, base + UTMIP_BIAS_CFG0);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&utmip_pad_lock, flags);
|
|
|
|
|
2012-06-05 06:29:35 +02:00
|
|
|
clk_disable_unprepare(phy->pad_clk);
|
2011-03-10 01:28:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int utmip_pad_power_off(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long val, flags;
|
|
|
|
void __iomem *base = phy->pad_regs;
|
|
|
|
|
|
|
|
if (!utmip_pad_count) {
|
|
|
|
pr_err("%s: utmip pad already powered off\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-06-05 06:29:35 +02:00
|
|
|
clk_prepare_enable(phy->pad_clk);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
spin_lock_irqsave(&utmip_pad_lock, flags);
|
|
|
|
|
|
|
|
if (--utmip_pad_count == 0) {
|
|
|
|
val = readl(base + UTMIP_BIAS_CFG0);
|
|
|
|
val |= UTMIP_OTGPD | UTMIP_BIASPD;
|
|
|
|
writel(val, base + UTMIP_BIAS_CFG0);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&utmip_pad_lock, flags);
|
|
|
|
|
2012-06-05 06:29:35 +02:00
|
|
|
clk_disable_unprepare(phy->pad_clk);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int utmi_wait_register(void __iomem *reg, u32 mask, u32 result)
|
|
|
|
{
|
|
|
|
unsigned long timeout = 2000;
|
|
|
|
do {
|
|
|
|
if ((readl(reg) & mask) == result)
|
|
|
|
return 0;
|
|
|
|
udelay(1);
|
|
|
|
timeout--;
|
|
|
|
} while (timeout);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void utmi_phy_clk_disable(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
|
2013-01-16 04:30:20 +01:00
|
|
|
if (phy->is_legacy_phy) {
|
2011-03-10 01:28:55 +01:00
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val |= USB_SUSP_SET;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val &= ~USB_SUSP_SET;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
2013-01-17 21:15:37 +01:00
|
|
|
} else
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
set_phcd(phy, true);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
if (utmi_wait_register(base + USB_SUSP_CTRL, USB_PHY_CLK_VALID, 0) < 0)
|
|
|
|
pr_err("%s: timeout waiting for phy to stabilize\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void utmi_phy_clk_enable(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
|
2013-01-16 04:30:20 +01:00
|
|
|
if (phy->is_legacy_phy) {
|
2011-03-10 01:28:55 +01:00
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val |= USB_SUSP_CLR;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val &= ~USB_SUSP_CLR;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
2013-01-17 21:15:37 +01:00
|
|
|
} else
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
set_phcd(phy, false);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
if (utmi_wait_register(base + USB_SUSP_CTRL, USB_PHY_CLK_VALID,
|
|
|
|
USB_PHY_CLK_VALID))
|
|
|
|
pr_err("%s: timeout waiting for phy to stabilize\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int utmi_phy_power_on(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
struct tegra_utmip_config *config = phy->config;
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val |= UTMIP_RESET;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
|
2013-01-16 04:30:20 +01:00
|
|
|
if (phy->is_legacy_phy) {
|
2011-03-10 01:28:55 +01:00
|
|
|
val = readl(base + USB1_LEGACY_CTRL);
|
|
|
|
val |= USB1_NO_LEGACY_MODE;
|
|
|
|
writel(val, base + USB1_LEGACY_CTRL);
|
|
|
|
}
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_TX_CFG0);
|
2013-08-12 15:06:50 +02:00
|
|
|
val |= UTMIP_FS_PREABMLE_J;
|
2011-03-10 01:28:55 +01:00
|
|
|
writel(val, base + UTMIP_TX_CFG0);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_HSRX_CFG0);
|
|
|
|
val &= ~(UTMIP_IDLE_WAIT(~0) | UTMIP_ELASTIC_LIMIT(~0));
|
|
|
|
val |= UTMIP_IDLE_WAIT(config->idle_wait_delay);
|
|
|
|
val |= UTMIP_ELASTIC_LIMIT(config->elastic_limit);
|
|
|
|
writel(val, base + UTMIP_HSRX_CFG0);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_HSRX_CFG1);
|
|
|
|
val &= ~UTMIP_HS_SYNC_START_DLY(~0);
|
|
|
|
val |= UTMIP_HS_SYNC_START_DLY(config->hssync_start_delay);
|
|
|
|
writel(val, base + UTMIP_HSRX_CFG1);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_DEBOUNCE_CFG0);
|
|
|
|
val &= ~UTMIP_BIAS_DEBOUNCE_A(~0);
|
|
|
|
val |= UTMIP_BIAS_DEBOUNCE_A(phy->freq->debounce);
|
|
|
|
writel(val, base + UTMIP_DEBOUNCE_CFG0);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_MISC_CFG0);
|
|
|
|
val &= ~UTMIP_SUSPEND_EXIT_ON_EDGE;
|
|
|
|
writel(val, base + UTMIP_MISC_CFG0);
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
if (!phy->soc_config->utmi_pll_config_in_car_module) {
|
|
|
|
val = readl(base + UTMIP_MISC_CFG1);
|
|
|
|
val &= ~(UTMIP_PLL_ACTIVE_DLY_COUNT(~0) |
|
|
|
|
UTMIP_PLLU_STABLE_COUNT(~0));
|
|
|
|
val |= UTMIP_PLL_ACTIVE_DLY_COUNT(phy->freq->active_delay) |
|
|
|
|
UTMIP_PLLU_STABLE_COUNT(phy->freq->stable_count);
|
|
|
|
writel(val, base + UTMIP_MISC_CFG1);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_PLL_CFG1);
|
|
|
|
val &= ~(UTMIP_XTAL_FREQ_COUNT(~0) |
|
|
|
|
UTMIP_PLLU_ENABLE_DLY_COUNT(~0));
|
|
|
|
val |= UTMIP_XTAL_FREQ_COUNT(phy->freq->xtal_freq_count) |
|
|
|
|
UTMIP_PLLU_ENABLE_DLY_COUNT(phy->freq->enable_delay);
|
|
|
|
writel(val, base + UTMIP_PLL_CFG1);
|
|
|
|
}
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-07-25 20:38:09 +02:00
|
|
|
if (phy->mode == USB_DR_MODE_PERIPHERAL) {
|
2011-03-10 01:28:55 +01:00
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val &= ~(USB_WAKE_ON_CNNT_EN_DEV | USB_WAKE_ON_DISCON_EN_DEV);
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
2013-08-12 15:06:50 +02:00
|
|
|
|
|
|
|
val = readl(base + UTMIP_BAT_CHRG_CFG0);
|
|
|
|
val &= ~UTMIP_PD_CHRG;
|
|
|
|
writel(val, base + UTMIP_BAT_CHRG_CFG0);
|
|
|
|
} else {
|
|
|
|
val = readl(base + UTMIP_BAT_CHRG_CFG0);
|
|
|
|
val |= UTMIP_PD_CHRG;
|
|
|
|
writel(val, base + UTMIP_BAT_CHRG_CFG0);
|
2011-03-10 01:28:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
utmip_pad_power_on(phy);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_XCVR_CFG0);
|
|
|
|
val &= ~(UTMIP_FORCE_PD_POWERDOWN | UTMIP_FORCE_PD2_POWERDOWN |
|
2013-08-12 15:06:50 +02:00
|
|
|
UTMIP_FORCE_PDZI_POWERDOWN | UTMIP_XCVR_LSBIAS_SEL |
|
|
|
|
UTMIP_XCVR_SETUP(~0) | UTMIP_XCVR_SETUP_MSB(~0) |
|
2013-08-12 15:06:53 +02:00
|
|
|
UTMIP_XCVR_LSFSLEW(~0) | UTMIP_XCVR_LSRSLEW(~0));
|
|
|
|
|
|
|
|
if (!config->xcvr_setup_use_fuses) {
|
|
|
|
val |= UTMIP_XCVR_SETUP(config->xcvr_setup);
|
|
|
|
val |= UTMIP_XCVR_SETUP_MSB(config->xcvr_setup);
|
|
|
|
}
|
2011-03-10 01:28:55 +01:00
|
|
|
val |= UTMIP_XCVR_LSFSLEW(config->xcvr_lsfslew);
|
|
|
|
val |= UTMIP_XCVR_LSRSLEW(config->xcvr_lsrslew);
|
2013-08-12 15:06:53 +02:00
|
|
|
|
|
|
|
if (phy->soc_config->requires_extra_tuning_parameters) {
|
|
|
|
val &= ~(UTMIP_XCVR_HSSLEW(~0) | UTMIP_XCVR_HSSLEW_MSB(~0));
|
|
|
|
val |= UTMIP_XCVR_HSSLEW(config->xcvr_hsslew);
|
|
|
|
val |= UTMIP_XCVR_HSSLEW_MSB(config->xcvr_hsslew);
|
|
|
|
}
|
2011-03-10 01:28:55 +01:00
|
|
|
writel(val, base + UTMIP_XCVR_CFG0);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_XCVR_CFG1);
|
|
|
|
val &= ~(UTMIP_FORCE_PDDISC_POWERDOWN | UTMIP_FORCE_PDCHRP_POWERDOWN |
|
|
|
|
UTMIP_FORCE_PDDR_POWERDOWN | UTMIP_XCVR_TERM_RANGE_ADJ(~0));
|
|
|
|
val |= UTMIP_XCVR_TERM_RANGE_ADJ(config->term_range_adj);
|
|
|
|
writel(val, base + UTMIP_XCVR_CFG1);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_BIAS_CFG1);
|
|
|
|
val &= ~UTMIP_BIAS_PDTRK_COUNT(~0);
|
|
|
|
val |= UTMIP_BIAS_PDTRK_COUNT(0x5);
|
|
|
|
writel(val, base + UTMIP_BIAS_CFG1);
|
|
|
|
|
2013-08-12 15:06:53 +02:00
|
|
|
val = readl(base + UTMIP_SPARE_CFG0);
|
|
|
|
if (config->xcvr_setup_use_fuses)
|
|
|
|
val |= FUSE_SETUP_SEL;
|
|
|
|
else
|
|
|
|
val &= ~FUSE_SETUP_SEL;
|
|
|
|
writel(val, base + UTMIP_SPARE_CFG0);
|
|
|
|
|
|
|
|
if (!phy->is_legacy_phy) {
|
2011-03-10 01:28:55 +01:00
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val |= UTMIP_PHY_ENABLE;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
}
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val &= ~UTMIP_RESET;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
|
2013-01-16 04:30:20 +01:00
|
|
|
if (phy->is_legacy_phy) {
|
2011-03-10 01:28:55 +01:00
|
|
|
val = readl(base + USB1_LEGACY_CTRL);
|
|
|
|
val &= ~USB1_VBUS_SENSE_CTL_MASK;
|
|
|
|
val |= USB1_VBUS_SENSE_CTL_A_SESS_VLD;
|
|
|
|
writel(val, base + USB1_LEGACY_CTRL);
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val &= ~USB_SUSP_SET;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
}
|
|
|
|
|
|
|
|
utmi_phy_clk_enable(phy);
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
if (phy->soc_config->requires_usbmode_setup) {
|
|
|
|
val = readl(base + USB_USBMODE);
|
|
|
|
val &= ~USB_USBMODE_MASK;
|
|
|
|
if (phy->mode == USB_DR_MODE_HOST)
|
|
|
|
val |= USB_USBMODE_HOST;
|
|
|
|
else
|
|
|
|
val |= USB_USBMODE_DEVICE;
|
|
|
|
writel(val, base + USB_USBMODE);
|
|
|
|
}
|
|
|
|
|
2013-01-17 21:15:37 +01:00
|
|
|
if (!phy->is_legacy_phy)
|
USB: EHCI: tegra: fix circular module dependencies
The Tegra EHCI driver directly calls various functions in the Tegra USB
PHY driver. The reverse is also true; the PHY driver calls into the EHCI
driver. This is problematic when the two are built as modules.
The calls from the PHY to EHCI driver were originally added in commit
bbdabdb "usb: add APIs to access host registers from Tegra PHY", for the
following reasons:
1) The register being touched is an EHCI register, so logically only the
EHCI driver should touch it.
2) (1) implies that some locking may be needed to correctly implement the
r/m/w access to this shared register.
3) We were expecting to pass only the PHY register space to the Tegra PHY
driver, and hence it would not have access to touch the shared
registers.
To solve this, that commit added functions in the EHCI driver to touch the
shared register on behalf of the PHY driver.
In practice, we ended up not having any locking in the implementaiton of
those functions, and I've been led to believe this is safe. Equally, (3)
did not happen either. Hence, it is possible for the PHY driver to touch
the shared register directly.
Given that, this patch moves the code to touch the shared register back
into the PHY driver, to eliminate the module problems. If we actually
need locking or co-ordination in the future, I propose we put the lock
support into some pre-existing core module, or into a third separate
module, in order to avoid the circular dependencies.
I apologize for my contribution to code churn here.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Tested-by: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-06-13 19:24:11 +02:00
|
|
|
set_pts(phy, 0);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-05 15:20:23 +02:00
|
|
|
static int utmi_phy_power_off(struct tegra_usb_phy *phy)
|
2011-03-10 01:28:55 +01:00
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
|
|
|
|
utmi_phy_clk_disable(phy);
|
|
|
|
|
2013-07-25 20:38:09 +02:00
|
|
|
if (phy->mode == USB_DR_MODE_PERIPHERAL) {
|
2011-03-10 01:28:55 +01:00
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val &= ~USB_WAKEUP_DEBOUNCE_COUNT(~0);
|
|
|
|
val |= USB_WAKE_ON_CNNT_EN_DEV | USB_WAKEUP_DEBOUNCE_COUNT(5);
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
}
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val |= UTMIP_RESET;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_BAT_CHRG_CFG0);
|
|
|
|
val |= UTMIP_PD_CHRG;
|
|
|
|
writel(val, base + UTMIP_BAT_CHRG_CFG0);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_XCVR_CFG0);
|
|
|
|
val |= UTMIP_FORCE_PD_POWERDOWN | UTMIP_FORCE_PD2_POWERDOWN |
|
|
|
|
UTMIP_FORCE_PDZI_POWERDOWN;
|
|
|
|
writel(val, base + UTMIP_XCVR_CFG0);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_XCVR_CFG1);
|
|
|
|
val |= UTMIP_FORCE_PDDISC_POWERDOWN | UTMIP_FORCE_PDCHRP_POWERDOWN |
|
|
|
|
UTMIP_FORCE_PDDR_POWERDOWN;
|
|
|
|
writel(val, base + UTMIP_XCVR_CFG1);
|
|
|
|
|
2012-09-05 15:20:23 +02:00
|
|
|
return utmip_pad_power_off(phy);
|
2011-03-10 01:28:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void utmi_phy_preresume(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_TX_CFG0);
|
|
|
|
val |= UTMIP_HS_DISCON_DISABLE;
|
|
|
|
writel(val, base + UTMIP_TX_CFG0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void utmi_phy_postresume(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_TX_CFG0);
|
|
|
|
val &= ~UTMIP_HS_DISCON_DISABLE;
|
|
|
|
writel(val, base + UTMIP_TX_CFG0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void utmi_phy_restore_start(struct tegra_usb_phy *phy,
|
|
|
|
enum tegra_usb_phy_port_speed port_speed)
|
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_MISC_CFG0);
|
|
|
|
val &= ~UTMIP_DPDM_OBSERVE_SEL(~0);
|
|
|
|
if (port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW)
|
|
|
|
val |= UTMIP_DPDM_OBSERVE_SEL_FS_K;
|
|
|
|
else
|
|
|
|
val |= UTMIP_DPDM_OBSERVE_SEL_FS_J;
|
|
|
|
writel(val, base + UTMIP_MISC_CFG0);
|
|
|
|
udelay(1);
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_MISC_CFG0);
|
|
|
|
val |= UTMIP_DPDM_OBSERVE;
|
|
|
|
writel(val, base + UTMIP_MISC_CFG0);
|
|
|
|
udelay(10);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void utmi_phy_restore_end(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
|
|
|
|
val = readl(base + UTMIP_MISC_CFG0);
|
|
|
|
val &= ~UTMIP_DPDM_OBSERVE;
|
|
|
|
writel(val, base + UTMIP_MISC_CFG0);
|
|
|
|
udelay(10);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ulpi_phy_power_on(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
unsigned long val;
|
|
|
|
void __iomem *base = phy->regs;
|
|
|
|
|
2013-05-16 16:13:01 +02:00
|
|
|
ret = gpio_direction_output(phy->reset_gpio, 0);
|
|
|
|
if (ret < 0) {
|
2013-07-25 20:38:01 +02:00
|
|
|
dev_err(phy->u_phy.dev, "gpio %d not set to 0\n",
|
|
|
|
phy->reset_gpio);
|
2013-05-16 16:13:01 +02:00
|
|
|
return ret;
|
|
|
|
}
|
2011-03-10 01:28:55 +01:00
|
|
|
msleep(5);
|
2013-05-16 16:13:01 +02:00
|
|
|
ret = gpio_direction_output(phy->reset_gpio, 1);
|
|
|
|
if (ret < 0) {
|
2013-07-25 20:38:01 +02:00
|
|
|
dev_err(phy->u_phy.dev, "gpio %d not set to 1\n",
|
|
|
|
phy->reset_gpio);
|
2013-05-16 16:13:01 +02:00
|
|
|
return ret;
|
|
|
|
}
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2012-06-05 06:29:35 +02:00
|
|
|
clk_prepare_enable(phy->clk);
|
2011-03-10 01:28:55 +01:00
|
|
|
msleep(1);
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val |= UHSIC_RESET;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
|
|
|
|
val = readl(base + ULPI_TIMING_CTRL_0);
|
|
|
|
val |= ULPI_OUTPUT_PINMUX_BYP | ULPI_CLKOUT_PINMUX_BYP;
|
|
|
|
writel(val, base + ULPI_TIMING_CTRL_0);
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val |= ULPI_PHY_ENABLE;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
|
|
|
|
val = 0;
|
|
|
|
writel(val, base + ULPI_TIMING_CTRL_1);
|
|
|
|
|
|
|
|
val |= ULPI_DATA_TRIMMER_SEL(4);
|
|
|
|
val |= ULPI_STPDIRNXT_TRIMMER_SEL(4);
|
|
|
|
val |= ULPI_DIR_TRIMMER_SEL(4);
|
|
|
|
writel(val, base + ULPI_TIMING_CTRL_1);
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
val |= ULPI_DATA_TRIMMER_LOAD;
|
|
|
|
val |= ULPI_STPDIRNXT_TRIMMER_LOAD;
|
|
|
|
val |= ULPI_DIR_TRIMMER_LOAD;
|
|
|
|
writel(val, base + ULPI_TIMING_CTRL_1);
|
|
|
|
|
|
|
|
/* Fix VbusInvalid due to floating VBUS */
|
2012-02-13 12:24:18 +01:00
|
|
|
ret = usb_phy_io_write(phy->ulpi, 0x40, 0x08);
|
2011-03-10 01:28:55 +01:00
|
|
|
if (ret) {
|
|
|
|
pr_err("%s: ulpi write failed\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-02-13 12:24:18 +01:00
|
|
|
ret = usb_phy_io_write(phy->ulpi, 0x80, 0x0B);
|
2011-03-10 01:28:55 +01:00
|
|
|
if (ret) {
|
|
|
|
pr_err("%s: ulpi write failed\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val |= USB_SUSP_CLR;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
udelay(100);
|
|
|
|
|
|
|
|
val = readl(base + USB_SUSP_CTRL);
|
|
|
|
val &= ~USB_SUSP_CLR;
|
|
|
|
writel(val, base + USB_SUSP_CTRL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-05 15:20:23 +02:00
|
|
|
static int ulpi_phy_power_off(struct tegra_usb_phy *phy)
|
2011-03-10 01:28:55 +01:00
|
|
|
{
|
|
|
|
clk_disable(phy->clk);
|
2013-05-16 16:13:00 +02:00
|
|
|
return gpio_direction_output(phy->reset_gpio, 0);
|
2012-09-05 15:20:23 +02:00
|
|
|
}
|
|
|
|
|
2014-07-04 03:09:39 +02:00
|
|
|
static void tegra_usb_phy_close(struct tegra_usb_phy *phy)
|
2012-09-05 15:20:23 +02:00
|
|
|
{
|
2013-07-17 09:37:49 +02:00
|
|
|
if (!IS_ERR(phy->vbus))
|
|
|
|
regulator_disable(phy->vbus);
|
|
|
|
|
2012-09-05 15:20:23 +02:00
|
|
|
clk_disable_unprepare(phy->pll_u);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tegra_usb_phy_power_on(struct tegra_usb_phy *phy)
|
|
|
|
{
|
2013-01-16 04:30:21 +01:00
|
|
|
if (phy->is_ulpi_phy)
|
2012-09-05 15:20:23 +02:00
|
|
|
return ulpi_phy_power_on(phy);
|
|
|
|
else
|
|
|
|
return utmi_phy_power_on(phy);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tegra_usb_phy_power_off(struct tegra_usb_phy *phy)
|
|
|
|
{
|
2013-01-16 04:30:21 +01:00
|
|
|
if (phy->is_ulpi_phy)
|
2012-09-05 15:20:23 +02:00
|
|
|
return ulpi_phy_power_off(phy);
|
|
|
|
else
|
|
|
|
return utmi_phy_power_off(phy);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tegra_usb_phy_suspend(struct usb_phy *x, int suspend)
|
|
|
|
{
|
|
|
|
struct tegra_usb_phy *phy = container_of(x, struct tegra_usb_phy, u_phy);
|
|
|
|
if (suspend)
|
|
|
|
return tegra_usb_phy_power_off(phy);
|
|
|
|
else
|
|
|
|
return tegra_usb_phy_power_on(phy);
|
2011-03-10 01:28:55 +01:00
|
|
|
}
|
|
|
|
|
2013-05-16 16:13:02 +02:00
|
|
|
static int ulpi_open(struct tegra_usb_phy *phy)
|
2011-03-10 01:28:55 +01:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2013-07-25 20:38:01 +02:00
|
|
|
phy->clk = devm_clk_get(phy->u_phy.dev, "ulpi-link");
|
2013-05-16 16:13:02 +02:00
|
|
|
if (IS_ERR(phy->clk)) {
|
|
|
|
pr_err("%s: can't get ulpi clock\n", __func__);
|
|
|
|
return PTR_ERR(phy->clk);
|
|
|
|
}
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-07-25 20:38:01 +02:00
|
|
|
err = devm_gpio_request(phy->u_phy.dev, phy->reset_gpio,
|
|
|
|
"ulpi_phy_reset_b");
|
2013-05-16 16:13:02 +02:00
|
|
|
if (err < 0) {
|
2013-07-25 20:38:01 +02:00
|
|
|
dev_err(phy->u_phy.dev, "request failed for gpio: %d\n",
|
2013-05-16 16:13:02 +02:00
|
|
|
phy->reset_gpio);
|
|
|
|
return err;
|
|
|
|
}
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-05-16 16:13:02 +02:00
|
|
|
err = gpio_direction_output(phy->reset_gpio, 0);
|
2013-05-16 16:12:59 +02:00
|
|
|
if (err < 0) {
|
2013-07-25 20:38:01 +02:00
|
|
|
dev_err(phy->u_phy.dev, "gpio %d direction not set to output\n",
|
2013-05-16 16:13:02 +02:00
|
|
|
phy->reset_gpio);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
phy->ulpi = otg_ulpi_create(&ulpi_viewport_access_ops, 0);
|
|
|
|
if (!phy->ulpi) {
|
2013-07-25 20:38:01 +02:00
|
|
|
dev_err(phy->u_phy.dev, "otg_ulpi_create returned NULL\n");
|
2013-05-16 16:13:02 +02:00
|
|
|
err = -ENOMEM;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
phy->ulpi->io_priv = phy->regs + ULPI_VIEWPORT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tegra_usb_phy_init(struct tegra_usb_phy *phy)
|
|
|
|
{
|
|
|
|
unsigned long parent_rate;
|
|
|
|
int i;
|
|
|
|
int err;
|
|
|
|
|
2013-07-25 20:38:01 +02:00
|
|
|
phy->pll_u = devm_clk_get(phy->u_phy.dev, "pll_u");
|
2011-03-10 01:28:55 +01:00
|
|
|
if (IS_ERR(phy->pll_u)) {
|
|
|
|
pr_err("Can't get pll_u clock\n");
|
2013-05-16 16:13:02 +02:00
|
|
|
return PTR_ERR(phy->pll_u);
|
2011-03-10 01:28:55 +01:00
|
|
|
}
|
2013-05-16 16:13:02 +02:00
|
|
|
|
|
|
|
err = clk_prepare_enable(phy->pll_u);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2011-03-10 01:28:55 +01:00
|
|
|
|
|
|
|
parent_rate = clk_get_rate(clk_get_parent(phy->pll_u));
|
|
|
|
for (i = 0; i < ARRAY_SIZE(tegra_freq_table); i++) {
|
|
|
|
if (tegra_freq_table[i].freq == parent_rate) {
|
|
|
|
phy->freq = &tegra_freq_table[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!phy->freq) {
|
|
|
|
pr_err("invalid pll_u parent rate %ld\n", parent_rate);
|
|
|
|
err = -EINVAL;
|
2013-05-16 16:13:02 +02:00
|
|
|
goto fail;
|
2011-03-10 01:28:55 +01:00
|
|
|
}
|
|
|
|
|
2013-07-17 09:37:49 +02:00
|
|
|
if (!IS_ERR(phy->vbus)) {
|
|
|
|
err = regulator_enable(phy->vbus);
|
|
|
|
if (err) {
|
2013-07-25 20:38:01 +02:00
|
|
|
dev_err(phy->u_phy.dev,
|
2013-07-17 09:37:49 +02:00
|
|
|
"failed to enable usb vbus regulator: %d\n",
|
|
|
|
err);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-16 16:13:02 +02:00
|
|
|
if (phy->is_ulpi_phy)
|
|
|
|
err = ulpi_open(phy);
|
|
|
|
else
|
|
|
|
err = utmip_pad_open(phy);
|
|
|
|
if (err < 0)
|
|
|
|
goto fail;
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-05-16 16:13:02 +02:00
|
|
|
return 0;
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-05-16 16:13:02 +02:00
|
|
|
fail:
|
2012-06-05 06:29:35 +02:00
|
|
|
clk_disable_unprepare(phy->pll_u);
|
2013-05-16 16:13:02 +02:00
|
|
|
return err;
|
2011-03-10 01:28:55 +01:00
|
|
|
}
|
|
|
|
|
2013-01-24 11:27:03 +01:00
|
|
|
void tegra_usb_phy_preresume(struct usb_phy *x)
|
2011-03-10 01:28:55 +01:00
|
|
|
{
|
2013-01-24 11:27:03 +01:00
|
|
|
struct tegra_usb_phy *phy = container_of(x, struct tegra_usb_phy, u_phy);
|
|
|
|
|
2013-01-16 04:30:21 +01:00
|
|
|
if (!phy->is_ulpi_phy)
|
2011-03-10 01:28:55 +01:00
|
|
|
utmi_phy_preresume(phy);
|
|
|
|
}
|
2012-03-02 21:58:42 +01:00
|
|
|
EXPORT_SYMBOL_GPL(tegra_usb_phy_preresume);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-01-24 11:27:03 +01:00
|
|
|
void tegra_usb_phy_postresume(struct usb_phy *x)
|
2011-03-10 01:28:55 +01:00
|
|
|
{
|
2013-01-24 11:27:03 +01:00
|
|
|
struct tegra_usb_phy *phy = container_of(x, struct tegra_usb_phy, u_phy);
|
|
|
|
|
2013-01-16 04:30:21 +01:00
|
|
|
if (!phy->is_ulpi_phy)
|
2011-03-10 01:28:55 +01:00
|
|
|
utmi_phy_postresume(phy);
|
|
|
|
}
|
2012-03-02 21:58:42 +01:00
|
|
|
EXPORT_SYMBOL_GPL(tegra_usb_phy_postresume);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-01-24 11:27:03 +01:00
|
|
|
void tegra_ehci_phy_restore_start(struct usb_phy *x,
|
2011-03-10 01:28:55 +01:00
|
|
|
enum tegra_usb_phy_port_speed port_speed)
|
|
|
|
{
|
2013-01-24 11:27:03 +01:00
|
|
|
struct tegra_usb_phy *phy = container_of(x, struct tegra_usb_phy, u_phy);
|
|
|
|
|
2013-01-16 04:30:21 +01:00
|
|
|
if (!phy->is_ulpi_phy)
|
2011-03-10 01:28:55 +01:00
|
|
|
utmi_phy_restore_start(phy, port_speed);
|
|
|
|
}
|
2012-03-02 21:58:42 +01:00
|
|
|
EXPORT_SYMBOL_GPL(tegra_ehci_phy_restore_start);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-01-24 11:27:03 +01:00
|
|
|
void tegra_ehci_phy_restore_end(struct usb_phy *x)
|
2011-03-10 01:28:55 +01:00
|
|
|
{
|
2013-01-24 11:27:03 +01:00
|
|
|
struct tegra_usb_phy *phy = container_of(x, struct tegra_usb_phy, u_phy);
|
|
|
|
|
2013-01-16 04:30:21 +01:00
|
|
|
if (!phy->is_ulpi_phy)
|
2011-03-10 01:28:55 +01:00
|
|
|
utmi_phy_restore_end(phy);
|
|
|
|
}
|
2012-03-02 21:58:42 +01:00
|
|
|
EXPORT_SYMBOL_GPL(tegra_ehci_phy_restore_end);
|
2011-03-10 01:28:55 +01:00
|
|
|
|
2013-07-17 08:31:01 +02:00
|
|
|
static int read_utmi_param(struct platform_device *pdev, const char *param,
|
|
|
|
u8 *dest)
|
|
|
|
{
|
|
|
|
u32 value;
|
|
|
|
int err = of_property_read_u32(pdev->dev.of_node, param, &value);
|
|
|
|
*dest = (u8)value;
|
|
|
|
if (err < 0)
|
|
|
|
dev_err(&pdev->dev, "Failed to read USB UTMI parameter %s: %d\n",
|
|
|
|
param, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int utmi_phy_probe(struct tegra_usb_phy *tegra_phy,
|
|
|
|
struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct resource *res;
|
|
|
|
int err;
|
|
|
|
struct tegra_utmip_config *config;
|
|
|
|
|
|
|
|
tegra_phy->is_ulpi_phy = false;
|
|
|
|
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
|
|
|
if (!res) {
|
|
|
|
dev_err(&pdev->dev, "Failed to get UTMI Pad regs\n");
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
tegra_phy->pad_regs = devm_ioremap(&pdev->dev, res->start,
|
|
|
|
resource_size(res));
|
2013-12-04 03:02:44 +01:00
|
|
|
if (!tegra_phy->pad_regs) {
|
2013-07-17 08:31:01 +02:00
|
|
|
dev_err(&pdev->dev, "Failed to remap UTMI Pad regs\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2014-07-21 13:37:37 +02:00
|
|
|
tegra_phy->config = devm_kzalloc(&pdev->dev, sizeof(*config),
|
|
|
|
GFP_KERNEL);
|
2014-10-14 09:56:13 +02:00
|
|
|
if (!tegra_phy->config)
|
2013-07-17 08:31:01 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
config = tegra_phy->config;
|
|
|
|
|
|
|
|
err = read_utmi_param(pdev, "nvidia,hssync-start-delay",
|
|
|
|
&config->hssync_start_delay);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = read_utmi_param(pdev, "nvidia,elastic-limit",
|
|
|
|
&config->elastic_limit);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = read_utmi_param(pdev, "nvidia,idle-wait-delay",
|
|
|
|
&config->idle_wait_delay);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = read_utmi_param(pdev, "nvidia,term-range-adj",
|
|
|
|
&config->term_range_adj);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = read_utmi_param(pdev, "nvidia,xcvr-lsfslew",
|
|
|
|
&config->xcvr_lsfslew);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = read_utmi_param(pdev, "nvidia,xcvr-lsrslew",
|
|
|
|
&config->xcvr_lsrslew);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2013-08-12 15:06:53 +02:00
|
|
|
if (tegra_phy->soc_config->requires_extra_tuning_parameters) {
|
|
|
|
err = read_utmi_param(pdev, "nvidia,xcvr-hsslew",
|
|
|
|
&config->xcvr_hsslew);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = read_utmi_param(pdev, "nvidia,hssquelch-level",
|
|
|
|
&config->hssquelch_level);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = read_utmi_param(pdev, "nvidia,hsdiscon-level",
|
|
|
|
&config->hsdiscon_level);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
config->xcvr_setup_use_fuses = of_property_read_bool(
|
|
|
|
pdev->dev.of_node, "nvidia,xcvr-setup-use-fuses");
|
|
|
|
|
|
|
|
if (!config->xcvr_setup_use_fuses) {
|
|
|
|
err = read_utmi_param(pdev, "nvidia,xcvr-setup",
|
|
|
|
&config->xcvr_setup);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-07-17 08:31:01 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
static const struct tegra_phy_soc_config tegra20_soc_config = {
|
|
|
|
.utmi_pll_config_in_car_module = false,
|
|
|
|
.has_hostpc = false,
|
|
|
|
.requires_usbmode_setup = false,
|
|
|
|
.requires_extra_tuning_parameters = false,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct tegra_phy_soc_config tegra30_soc_config = {
|
|
|
|
.utmi_pll_config_in_car_module = true,
|
|
|
|
.has_hostpc = true,
|
|
|
|
.requires_usbmode_setup = true,
|
|
|
|
.requires_extra_tuning_parameters = true,
|
|
|
|
};
|
|
|
|
|
2014-06-18 06:43:50 +02:00
|
|
|
static const struct of_device_id tegra_usb_phy_id_table[] = {
|
2013-08-12 15:06:51 +02:00
|
|
|
{ .compatible = "nvidia,tegra30-usb-phy", .data = &tegra30_soc_config },
|
|
|
|
{ .compatible = "nvidia,tegra20-usb-phy", .data = &tegra20_soc_config },
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, tegra_usb_phy_id_table);
|
|
|
|
|
2013-05-16 16:13:02 +02:00
|
|
|
static int tegra_usb_phy_probe(struct platform_device *pdev)
|
|
|
|
{
|
2013-08-12 15:06:51 +02:00
|
|
|
const struct of_device_id *match;
|
2013-05-16 16:13:02 +02:00
|
|
|
struct resource *res;
|
|
|
|
struct tegra_usb_phy *tegra_phy = NULL;
|
|
|
|
struct device_node *np = pdev->dev.of_node;
|
2013-07-25 20:38:08 +02:00
|
|
|
enum usb_phy_interface phy_type;
|
2013-05-16 16:13:02 +02:00
|
|
|
int err;
|
|
|
|
|
|
|
|
tegra_phy = devm_kzalloc(&pdev->dev, sizeof(*tegra_phy), GFP_KERNEL);
|
2014-10-14 09:56:13 +02:00
|
|
|
if (!tegra_phy)
|
2013-05-16 16:13:02 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-08-12 15:06:51 +02:00
|
|
|
match = of_match_device(tegra_usb_phy_id_table, &pdev->dev);
|
|
|
|
if (!match) {
|
|
|
|
dev_err(&pdev->dev, "Error: No device match found\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
tegra_phy->soc_config = match->data;
|
|
|
|
|
2013-05-16 16:13:02 +02:00
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (!res) {
|
|
|
|
dev_err(&pdev->dev, "Failed to get I/O memory\n");
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
tegra_phy->regs = devm_ioremap(&pdev->dev, res->start,
|
|
|
|
resource_size(res));
|
|
|
|
if (!tegra_phy->regs) {
|
|
|
|
dev_err(&pdev->dev, "Failed to remap I/O memory\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
tegra_phy->is_legacy_phy =
|
|
|
|
of_property_read_bool(np, "nvidia,has-legacy-mode");
|
|
|
|
|
2013-07-25 20:38:08 +02:00
|
|
|
phy_type = of_usb_get_phy_mode(np);
|
2013-07-25 21:24:09 +02:00
|
|
|
switch (phy_type) {
|
|
|
|
case USBPHY_INTERFACE_MODE_UTMI:
|
2013-07-17 08:31:01 +02:00
|
|
|
err = utmi_phy_probe(tegra_phy, pdev);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2013-07-25 21:24:09 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case USBPHY_INTERFACE_MODE_ULPI:
|
2013-05-16 16:13:02 +02:00
|
|
|
tegra_phy->is_ulpi_phy = true;
|
|
|
|
|
|
|
|
tegra_phy->reset_gpio =
|
|
|
|
of_get_named_gpio(np, "nvidia,phy-reset-gpio", 0);
|
|
|
|
if (!gpio_is_valid(tegra_phy->reset_gpio)) {
|
|
|
|
dev_err(&pdev->dev, "invalid gpio: %d\n",
|
|
|
|
tegra_phy->reset_gpio);
|
|
|
|
return tegra_phy->reset_gpio;
|
|
|
|
}
|
2013-07-17 08:31:01 +02:00
|
|
|
tegra_phy->config = NULL;
|
2013-07-25 21:24:09 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2013-07-25 20:38:08 +02:00
|
|
|
dev_err(&pdev->dev, "phy_type is invalid or unsupported\n");
|
|
|
|
return -EINVAL;
|
2013-05-16 16:13:02 +02:00
|
|
|
}
|
|
|
|
|
2013-07-25 20:38:09 +02:00
|
|
|
if (of_find_property(np, "dr_mode", NULL))
|
2015-09-21 10:14:34 +02:00
|
|
|
tegra_phy->mode = usb_get_dr_mode(&pdev->dev);
|
2013-07-25 20:38:09 +02:00
|
|
|
else
|
|
|
|
tegra_phy->mode = USB_DR_MODE_HOST;
|
|
|
|
|
|
|
|
if (tegra_phy->mode == USB_DR_MODE_UNKNOWN) {
|
|
|
|
dev_err(&pdev->dev, "dr_mode is invalid\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-05-16 16:13:02 +02:00
|
|
|
|
2013-07-17 09:37:49 +02:00
|
|
|
/* On some boards, the VBUS regulator doesn't need to be controlled */
|
|
|
|
if (of_find_property(np, "vbus-supply", NULL)) {
|
|
|
|
tegra_phy->vbus = devm_regulator_get(&pdev->dev, "vbus");
|
|
|
|
if (IS_ERR(tegra_phy->vbus))
|
|
|
|
return PTR_ERR(tegra_phy->vbus);
|
|
|
|
} else {
|
|
|
|
dev_notice(&pdev->dev, "no vbus regulator");
|
|
|
|
tegra_phy->vbus = ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
2013-07-25 20:38:01 +02:00
|
|
|
tegra_phy->u_phy.dev = &pdev->dev;
|
2013-05-16 16:13:02 +02:00
|
|
|
err = tegra_usb_phy_init(tegra_phy);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
tegra_phy->u_phy.set_suspend = tegra_usb_phy_suspend;
|
|
|
|
|
2013-08-30 05:23:32 +02:00
|
|
|
platform_set_drvdata(pdev, tegra_phy);
|
2013-07-25 20:38:05 +02:00
|
|
|
|
|
|
|
err = usb_add_phy_dev(&tegra_phy->u_phy);
|
|
|
|
if (err < 0) {
|
2014-07-04 03:09:39 +02:00
|
|
|
tegra_usb_phy_close(tegra_phy);
|
2013-07-25 20:38:05 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tegra_usb_phy_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct tegra_usb_phy *tegra_phy = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
usb_remove_phy(&tegra_phy->u_phy);
|
2014-07-04 03:09:39 +02:00
|
|
|
tegra_usb_phy_close(tegra_phy);
|
2013-07-25 20:38:05 +02:00
|
|
|
|
2013-05-16 16:13:02 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct platform_driver tegra_usb_phy_driver = {
|
|
|
|
.probe = tegra_usb_phy_probe,
|
2013-07-25 20:38:05 +02:00
|
|
|
.remove = tegra_usb_phy_remove,
|
2013-05-16 16:13:02 +02:00
|
|
|
.driver = {
|
|
|
|
.name = "tegra-phy",
|
2013-09-30 06:14:47 +02:00
|
|
|
.of_match_table = tegra_usb_phy_id_table,
|
2013-05-16 16:13:02 +02:00
|
|
|
},
|
|
|
|
};
|
|
|
|
module_platform_driver(tegra_usb_phy_driver);
|
|
|
|
|
2013-06-13 19:24:08 +02:00
|
|
|
MODULE_DESCRIPTION("Tegra USB PHY driver");
|
|
|
|
MODULE_LICENSE("GPL v2");
|