2013-01-24 19:51:48 -07:00
|
|
|
/*
|
2014-03-03 04:38:12 -07:00
|
|
|
* phy-ti-pipe3 - PIPE3 PHY driver.
|
2013-01-24 19:51:48 -07:00
|
|
|
*
|
|
|
|
* Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Author: Kishon Vijay Abraham I <kishon@ti.com>
|
|
|
|
*
|
|
|
|
* 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/module.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/slab.h>
|
2014-03-03 04:38:12 -07:00
|
|
|
#include <linux/phy/phy.h>
|
2013-01-24 19:51:48 -07:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/err.h>
|
2014-03-03 04:38:12 -07:00
|
|
|
#include <linux/io.h>
|
2013-01-24 19:51:48 -07:00
|
|
|
#include <linux/pm_runtime.h>
|
|
|
|
#include <linux/delay.h>
|
2014-03-06 07:38:37 -07:00
|
|
|
#include <linux/phy/omap_control_phy.h>
|
2013-10-03 09:12:33 -06:00
|
|
|
#include <linux/of_platform.h>
|
2015-01-13 05:23:19 -07:00
|
|
|
#include <linux/spinlock.h>
|
2013-01-24 19:51:48 -07:00
|
|
|
|
|
|
|
#define PLL_STATUS 0x00000004
|
|
|
|
#define PLL_GO 0x00000008
|
|
|
|
#define PLL_CONFIGURATION1 0x0000000C
|
|
|
|
#define PLL_CONFIGURATION2 0x00000010
|
|
|
|
#define PLL_CONFIGURATION3 0x00000014
|
|
|
|
#define PLL_CONFIGURATION4 0x00000020
|
|
|
|
|
|
|
|
#define PLL_REGM_MASK 0x001FFE00
|
|
|
|
#define PLL_REGM_SHIFT 0x9
|
|
|
|
#define PLL_REGM_F_MASK 0x0003FFFF
|
|
|
|
#define PLL_REGM_F_SHIFT 0x0
|
|
|
|
#define PLL_REGN_MASK 0x000001FE
|
|
|
|
#define PLL_REGN_SHIFT 0x1
|
|
|
|
#define PLL_SELFREQDCO_MASK 0x0000000E
|
|
|
|
#define PLL_SELFREQDCO_SHIFT 0x1
|
|
|
|
#define PLL_SD_MASK 0x0003FC00
|
2014-03-06 22:57:09 -07:00
|
|
|
#define PLL_SD_SHIFT 10
|
2013-01-24 19:51:48 -07:00
|
|
|
#define SET_PLL_GO 0x1
|
2014-03-06 07:38:43 -07:00
|
|
|
#define PLL_LDOPWDN BIT(15)
|
|
|
|
#define PLL_TICOPWDN BIT(16)
|
2013-01-24 19:51:48 -07:00
|
|
|
#define PLL_LOCK 0x2
|
|
|
|
#define PLL_IDLE 0x1
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is an Empirical value that works, need to confirm the actual
|
2014-03-03 04:38:12 -07:00
|
|
|
* value required for the PIPE3PHY_PLL_CONFIGURATION2.PLL_IDLE status
|
|
|
|
* to be correctly reflected in the PIPE3PHY_PLL_STATUS register.
|
2013-01-24 19:51:48 -07:00
|
|
|
*/
|
2014-03-06 07:38:43 -07:00
|
|
|
#define PLL_IDLE_TIME 100 /* in milliseconds */
|
|
|
|
#define PLL_LOCK_TIME 100 /* in milliseconds */
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
struct pipe3_dpll_params {
|
|
|
|
u16 m;
|
|
|
|
u8 n;
|
|
|
|
u8 freq:3;
|
|
|
|
u8 sd;
|
|
|
|
u32 mf;
|
|
|
|
};
|
|
|
|
|
2014-03-06 23:13:39 -07:00
|
|
|
struct pipe3_dpll_map {
|
|
|
|
unsigned long rate;
|
|
|
|
struct pipe3_dpll_params params;
|
|
|
|
};
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
struct ti_pipe3 {
|
|
|
|
void __iomem *pll_ctrl_base;
|
|
|
|
struct device *dev;
|
|
|
|
struct device *control_dev;
|
|
|
|
struct clk *wkupclk;
|
|
|
|
struct clk *sys_clk;
|
2014-03-06 22:57:09 -07:00
|
|
|
struct clk *refclk;
|
2014-06-25 11:52:56 -06:00
|
|
|
struct clk *div_clk;
|
2014-03-06 23:13:39 -07:00
|
|
|
struct pipe3_dpll_map *dpll_map;
|
2015-01-13 05:23:19 -07:00
|
|
|
bool enabled;
|
|
|
|
spinlock_t lock; /* serialize clock enable/disable */
|
2015-01-13 05:23:20 -07:00
|
|
|
/* the below flag is needed specifically for SATA */
|
|
|
|
bool refclk_enabled;
|
2014-03-03 04:38:12 -07:00
|
|
|
};
|
|
|
|
|
2014-03-06 23:13:39 -07:00
|
|
|
static struct pipe3_dpll_map dpll_map_usb[] = {
|
2013-07-09 05:38:31 -06:00
|
|
|
{12000000, {1250, 5, 4, 20, 0} }, /* 12 MHz */
|
|
|
|
{16800000, {3125, 20, 4, 20, 0} }, /* 16.8 MHz */
|
|
|
|
{19200000, {1172, 8, 4, 20, 65537} }, /* 19.2 MHz */
|
|
|
|
{20000000, {1000, 7, 4, 10, 0} }, /* 20 MHz */
|
|
|
|
{26000000, {1250, 12, 4, 20, 0} }, /* 26 MHz */
|
|
|
|
{38400000, {3125, 47, 4, 20, 92843} }, /* 38.4 MHz */
|
2014-03-06 23:13:39 -07:00
|
|
|
{ }, /* Terminator */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct pipe3_dpll_map dpll_map_sata[] = {
|
|
|
|
{12000000, {1000, 7, 4, 6, 0} }, /* 12 MHz */
|
|
|
|
{16800000, {714, 7, 4, 6, 0} }, /* 16.8 MHz */
|
|
|
|
{19200000, {625, 7, 4, 6, 0} }, /* 19.2 MHz */
|
|
|
|
{20000000, {600, 7, 4, 6, 0} }, /* 20 MHz */
|
|
|
|
{26000000, {461, 7, 4, 6, 0} }, /* 26 MHz */
|
|
|
|
{38400000, {312, 7, 4, 6, 0} }, /* 38.4 MHz */
|
|
|
|
{ }, /* Terminator */
|
2013-01-24 19:51:48 -07:00
|
|
|
};
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static inline u32 ti_pipe3_readl(void __iomem *addr, unsigned offset)
|
|
|
|
{
|
|
|
|
return __raw_readl(addr + offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ti_pipe3_writel(void __iomem *addr, unsigned offset,
|
|
|
|
u32 data)
|
|
|
|
{
|
|
|
|
__raw_writel(data, addr + offset);
|
|
|
|
}
|
|
|
|
|
2014-03-06 23:13:39 -07:00
|
|
|
static struct pipe3_dpll_params *ti_pipe3_get_dpll_params(struct ti_pipe3 *phy)
|
2013-07-09 05:38:31 -06:00
|
|
|
{
|
2014-03-06 23:13:39 -07:00
|
|
|
unsigned long rate;
|
|
|
|
struct pipe3_dpll_map *dpll_map = phy->dpll_map;
|
2013-07-09 05:38:31 -06:00
|
|
|
|
2014-03-06 23:13:39 -07:00
|
|
|
rate = clk_get_rate(phy->sys_clk);
|
|
|
|
|
|
|
|
for (; dpll_map->rate; dpll_map++) {
|
|
|
|
if (rate == dpll_map->rate)
|
|
|
|
return &dpll_map->params;
|
2013-07-09 05:38:31 -06:00
|
|
|
}
|
|
|
|
|
2014-03-06 23:13:39 -07:00
|
|
|
dev_err(phy->dev, "No DPLL configuration for %lu Hz SYS CLK\n", rate);
|
|
|
|
|
2013-09-15 23:40:10 -06:00
|
|
|
return NULL;
|
2013-07-09 05:38:31 -06:00
|
|
|
}
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static int ti_pipe3_power_off(struct phy *x)
|
|
|
|
{
|
|
|
|
struct ti_pipe3 *phy = phy_get_drvdata(x);
|
|
|
|
|
2014-03-06 07:38:37 -07:00
|
|
|
omap_control_phy_power(phy->control_dev, 0);
|
2014-03-03 04:38:12 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ti_pipe3_power_on(struct phy *x)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
2014-03-03 04:38:12 -07:00
|
|
|
struct ti_pipe3 *phy = phy_get_drvdata(x);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
omap_control_phy_power(phy->control_dev, 1);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
static int ti_pipe3_dpll_wait_lock(struct ti_pipe3 *phy)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
unsigned long timeout;
|
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
timeout = jiffies + msecs_to_jiffies(PLL_LOCK_TIME);
|
2013-01-24 19:51:48 -07:00
|
|
|
do {
|
2014-03-06 07:38:43 -07:00
|
|
|
cpu_relax();
|
2014-03-03 04:38:12 -07:00
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_STATUS);
|
2013-01-24 19:51:48 -07:00
|
|
|
if (val & PLL_LOCK)
|
2015-03-03 05:04:55 -07:00
|
|
|
return 0;
|
2014-03-06 07:38:43 -07:00
|
|
|
} while (!time_after(jiffies, timeout));
|
|
|
|
|
2015-03-03 05:04:55 -07:00
|
|
|
dev_err(phy->dev, "DPLL failed to lock\n");
|
|
|
|
return -EBUSY;
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
static int ti_pipe3_dpll_program(struct ti_pipe3 *phy)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
|
|
|
u32 val;
|
2014-03-03 04:38:12 -07:00
|
|
|
struct pipe3_dpll_params *dpll_params;
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-06 23:13:39 -07:00
|
|
|
dpll_params = ti_pipe3_get_dpll_params(phy);
|
|
|
|
if (!dpll_params)
|
2013-01-24 19:51:48 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION1);
|
2013-01-24 19:51:48 -07:00
|
|
|
val &= ~PLL_REGN_MASK;
|
2013-07-09 05:38:31 -06:00
|
|
|
val |= dpll_params->n << PLL_REGN_SHIFT;
|
2014-03-03 04:38:12 -07:00
|
|
|
ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION1, val);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION2);
|
2013-01-24 19:51:48 -07:00
|
|
|
val &= ~PLL_SELFREQDCO_MASK;
|
2013-07-09 05:38:31 -06:00
|
|
|
val |= dpll_params->freq << PLL_SELFREQDCO_SHIFT;
|
2014-03-03 04:38:12 -07:00
|
|
|
ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION2, val);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION1);
|
2013-01-24 19:51:48 -07:00
|
|
|
val &= ~PLL_REGM_MASK;
|
2013-07-09 05:38:31 -06:00
|
|
|
val |= dpll_params->m << PLL_REGM_SHIFT;
|
2014-03-03 04:38:12 -07:00
|
|
|
ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION1, val);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION4);
|
2013-01-24 19:51:48 -07:00
|
|
|
val &= ~PLL_REGM_F_MASK;
|
2013-07-09 05:38:31 -06:00
|
|
|
val |= dpll_params->mf << PLL_REGM_F_SHIFT;
|
2014-03-03 04:38:12 -07:00
|
|
|
ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION4, val);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION3);
|
2013-01-24 19:51:48 -07:00
|
|
|
val &= ~PLL_SD_MASK;
|
2013-07-09 05:38:31 -06:00
|
|
|
val |= dpll_params->sd << PLL_SD_SHIFT;
|
2014-03-03 04:38:12 -07:00
|
|
|
ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION3, val);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
ti_pipe3_writel(phy->pll_ctrl_base, PLL_GO, SET_PLL_GO);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
return ti_pipe3_dpll_wait_lock(phy);
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static int ti_pipe3_init(struct phy *x)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
2014-03-03 04:38:12 -07:00
|
|
|
struct ti_pipe3 *phy = phy_get_drvdata(x);
|
2014-03-06 07:38:43 -07:00
|
|
|
u32 val;
|
|
|
|
int ret = 0;
|
2013-07-09 05:38:31 -06:00
|
|
|
|
phy: phy-ti-pipe3: fix inconsistent enumeration of PCIe gen2 cards
Prior to DRA74x silicon rev 1.1, pcie_pcs register bits 8-15 and bits 16-23
were used to configure RC delay count for phy1 and phy2 respectively.
phyid was used as index to distinguish the phys and to configure the delay
values appropriately.
As of DRA74x silicon rev 1.1, pcie_pcs register definition has changed.
Bits 16-23 are used to configure delay values for *both* phy1 and phy2.
Hence phyid is no longer required.
So, drop id field from ti_pipe3 structure and its subsequent references
for configuring pcie_pcs register.
Also, pcie_pcs register now needs to be configured with delay value of 0x96
at bit positions 16-23. See register description of CTRL_CORE_PCIE_PCS in
ARM572x TRM, SPRUHZ6, October 2014, section 18.5.2.2, table 18-1804.
This is needed to ensure Gen2 cards are enumerated consistently.
DRA72x silicon behaves same way as DRA74x rev 1.1 as far as this functionality
is considered.
Test results on DRA74x and DRA72x EVMs:
Before patch
------------
DRA74x ES 1.0: Gen1 cards work, Gen2 cards do not work (expected result due to
silicon errata)
DRA74x ES 1.1: Gen1 cards work, Gen2 cards do not work sometimes due to incorrect
programming of register
DRA72x: Gen1 cards work, Gen2 cards do not work sometimes due to incorrect
programming of register
After patch
-----------
DRA74x ES 1.0: Gen1 cards work, Gen2 cards do not work (expected result due to
silicon errata)
DRA74x ES 1.1: Gen1 cards work, Gen2 cards work consistently.
DRA72x: Gen1 and Gen2 cards enumerate consistently.
Signed-off-by: Vignesh R <vigneshr@ti.com>
Signed-off-by: Kishon Vijay Abraham I <kishon@ti.com>
2014-12-16 02:22:50 -07:00
|
|
|
/*
|
|
|
|
* Set pcie_pcs register to 0x96 for proper functioning of phy
|
|
|
|
* as recommended in AM572x TRM SPRUHZ6, section 18.5.2.2, table
|
|
|
|
* 18-1804.
|
|
|
|
*/
|
2014-06-25 11:52:57 -06:00
|
|
|
if (of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-pcie")) {
|
phy: phy-ti-pipe3: fix inconsistent enumeration of PCIe gen2 cards
Prior to DRA74x silicon rev 1.1, pcie_pcs register bits 8-15 and bits 16-23
were used to configure RC delay count for phy1 and phy2 respectively.
phyid was used as index to distinguish the phys and to configure the delay
values appropriately.
As of DRA74x silicon rev 1.1, pcie_pcs register definition has changed.
Bits 16-23 are used to configure delay values for *both* phy1 and phy2.
Hence phyid is no longer required.
So, drop id field from ti_pipe3 structure and its subsequent references
for configuring pcie_pcs register.
Also, pcie_pcs register now needs to be configured with delay value of 0x96
at bit positions 16-23. See register description of CTRL_CORE_PCIE_PCS in
ARM572x TRM, SPRUHZ6, October 2014, section 18.5.2.2, table 18-1804.
This is needed to ensure Gen2 cards are enumerated consistently.
DRA72x silicon behaves same way as DRA74x rev 1.1 as far as this functionality
is considered.
Test results on DRA74x and DRA72x EVMs:
Before patch
------------
DRA74x ES 1.0: Gen1 cards work, Gen2 cards do not work (expected result due to
silicon errata)
DRA74x ES 1.1: Gen1 cards work, Gen2 cards do not work sometimes due to incorrect
programming of register
DRA72x: Gen1 cards work, Gen2 cards do not work sometimes due to incorrect
programming of register
After patch
-----------
DRA74x ES 1.0: Gen1 cards work, Gen2 cards do not work (expected result due to
silicon errata)
DRA74x ES 1.1: Gen1 cards work, Gen2 cards work consistently.
DRA72x: Gen1 and Gen2 cards enumerate consistently.
Signed-off-by: Vignesh R <vigneshr@ti.com>
Signed-off-by: Kishon Vijay Abraham I <kishon@ti.com>
2014-12-16 02:22:50 -07:00
|
|
|
omap_control_pcie_pcs(phy->control_dev, 0x96);
|
2014-06-25 11:52:56 -06:00
|
|
|
return 0;
|
2014-06-25 11:52:57 -06:00
|
|
|
}
|
2014-06-25 11:52:56 -06:00
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
/* Bring it out of IDLE if it is IDLE */
|
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION2);
|
|
|
|
if (val & PLL_IDLE) {
|
|
|
|
val &= ~PLL_IDLE;
|
|
|
|
ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION2, val);
|
|
|
|
ret = ti_pipe3_dpll_wait_lock(phy);
|
|
|
|
}
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
/* Program the DPLL only if not locked */
|
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_STATUS);
|
|
|
|
if (!(val & PLL_LOCK))
|
|
|
|
if (ti_pipe3_dpll_program(phy))
|
|
|
|
return -EINVAL;
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
return ret;
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
static int ti_pipe3_exit(struct phy *x)
|
|
|
|
{
|
|
|
|
struct ti_pipe3 *phy = phy_get_drvdata(x);
|
|
|
|
u32 val;
|
|
|
|
unsigned long timeout;
|
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
/* SATA DPLL can't be powered down due to Errata i783 and PCIe
|
|
|
|
* does not have internal DPLL
|
|
|
|
*/
|
|
|
|
if (of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata") ||
|
|
|
|
of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-pcie"))
|
2014-03-06 07:38:44 -07:00
|
|
|
return 0;
|
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
/* Put DPLL in IDLE mode */
|
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION2);
|
|
|
|
val |= PLL_IDLE;
|
|
|
|
ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION2, val);
|
|
|
|
|
|
|
|
/* wait for LDO and Oscillator to power down */
|
|
|
|
timeout = jiffies + msecs_to_jiffies(PLL_IDLE_TIME);
|
|
|
|
do {
|
|
|
|
cpu_relax();
|
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_STATUS);
|
|
|
|
if ((val & PLL_TICOPWDN) && (val & PLL_LDOPWDN))
|
|
|
|
break;
|
|
|
|
} while (!time_after(jiffies, timeout));
|
|
|
|
|
|
|
|
if (!(val & PLL_TICOPWDN) || !(val & PLL_LDOPWDN)) {
|
|
|
|
dev_err(phy->dev, "Failed to power down: PLL_STATUS 0x%x\n",
|
|
|
|
val);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2014-03-03 04:38:12 -07:00
|
|
|
static struct phy_ops ops = {
|
|
|
|
.init = ti_pipe3_init,
|
2014-03-06 07:38:43 -07:00
|
|
|
.exit = ti_pipe3_exit,
|
2014-03-03 04:38:12 -07:00
|
|
|
.power_on = ti_pipe3_power_on,
|
|
|
|
.power_off = ti_pipe3_power_off,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2014-03-06 23:13:39 -07:00
|
|
|
static const struct of_device_id ti_pipe3_id_table[];
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static int ti_pipe3_probe(struct platform_device *pdev)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
2014-03-03 04:38:12 -07:00
|
|
|
struct ti_pipe3 *phy;
|
|
|
|
struct phy *generic_phy;
|
|
|
|
struct phy_provider *phy_provider;
|
2013-10-03 09:12:33 -06:00
|
|
|
struct resource *res;
|
|
|
|
struct device_node *node = pdev->dev.of_node;
|
|
|
|
struct device_node *control_node;
|
|
|
|
struct platform_device *control_pdev;
|
2014-03-06 23:13:39 -07:00
|
|
|
const struct of_device_id *match;
|
2014-06-25 11:52:56 -06:00
|
|
|
struct clk *clk;
|
2013-01-24 19:51:48 -07:00
|
|
|
|
|
|
|
phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
|
2014-08-15 06:40:11 -06:00
|
|
|
if (!phy)
|
2013-01-24 19:51:48 -07:00
|
|
|
return -ENOMEM;
|
2014-08-15 06:40:11 -06:00
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
phy->dev = &pdev->dev;
|
2015-01-13 05:23:19 -07:00
|
|
|
spin_lock_init(&phy->lock);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
if (!of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
|
2015-03-05 03:20:53 -07:00
|
|
|
match = of_match_device(ti_pipe3_id_table, &pdev->dev);
|
2014-06-25 11:52:56 -06:00
|
|
|
if (!match)
|
|
|
|
return -EINVAL;
|
2014-03-06 23:13:39 -07:00
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
phy->dpll_map = (struct pipe3_dpll_map *)match->data;
|
|
|
|
if (!phy->dpll_map) {
|
|
|
|
dev_err(&pdev->dev, "no DPLL data\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
|
|
|
|
"pll_ctrl");
|
|
|
|
phy->pll_ctrl_base = devm_ioremap_resource(&pdev->dev, res);
|
|
|
|
if (IS_ERR(phy->pll_ctrl_base))
|
|
|
|
return PTR_ERR(phy->pll_ctrl_base);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
phy->sys_clk = devm_clk_get(phy->dev, "sysclk");
|
|
|
|
if (IS_ERR(phy->sys_clk)) {
|
|
|
|
dev_err(&pdev->dev, "unable to get sysclk\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2014-03-06 07:38:42 -07:00
|
|
|
|
2015-01-13 05:23:20 -07:00
|
|
|
phy->refclk = devm_clk_get(phy->dev, "refclk");
|
|
|
|
if (IS_ERR(phy->refclk)) {
|
|
|
|
dev_err(&pdev->dev, "unable to get refclk\n");
|
|
|
|
/* older DTBs have missing refclk in SATA PHY
|
|
|
|
* so don't bail out in case of SATA PHY.
|
|
|
|
*/
|
|
|
|
if (!of_device_is_compatible(node, "ti,phy-pipe3-sata"))
|
|
|
|
return PTR_ERR(phy->refclk);
|
|
|
|
}
|
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
if (!of_device_is_compatible(node, "ti,phy-pipe3-sata")) {
|
2014-03-06 07:38:42 -07:00
|
|
|
phy->wkupclk = devm_clk_get(phy->dev, "wkupclk");
|
|
|
|
if (IS_ERR(phy->wkupclk)) {
|
|
|
|
dev_err(&pdev->dev, "unable to get wkupclk\n");
|
|
|
|
return PTR_ERR(phy->wkupclk);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
phy->wkupclk = ERR_PTR(-ENODEV);
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
if (of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
|
|
|
|
|
|
|
|
clk = devm_clk_get(phy->dev, "dpll_ref");
|
|
|
|
if (IS_ERR(clk)) {
|
|
|
|
dev_err(&pdev->dev, "unable to get dpll ref clk\n");
|
|
|
|
return PTR_ERR(clk);
|
|
|
|
}
|
|
|
|
clk_set_rate(clk, 1500000000);
|
|
|
|
|
|
|
|
clk = devm_clk_get(phy->dev, "dpll_ref_m2");
|
|
|
|
if (IS_ERR(clk)) {
|
|
|
|
dev_err(&pdev->dev, "unable to get dpll ref m2 clk\n");
|
|
|
|
return PTR_ERR(clk);
|
|
|
|
}
|
|
|
|
clk_set_rate(clk, 100000000);
|
|
|
|
|
|
|
|
clk = devm_clk_get(phy->dev, "phy-div");
|
|
|
|
if (IS_ERR(clk)) {
|
|
|
|
dev_err(&pdev->dev, "unable to get phy-div clk\n");
|
|
|
|
return PTR_ERR(clk);
|
|
|
|
}
|
|
|
|
clk_set_rate(clk, 100000000);
|
|
|
|
|
|
|
|
phy->div_clk = devm_clk_get(phy->dev, "div-clk");
|
|
|
|
if (IS_ERR(phy->div_clk)) {
|
|
|
|
dev_err(&pdev->dev, "unable to get div-clk\n");
|
|
|
|
return PTR_ERR(phy->div_clk);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
phy->div_clk = ERR_PTR(-ENODEV);
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
|
|
|
|
2013-10-03 09:12:33 -06:00
|
|
|
control_node = of_parse_phandle(node, "ctrl-module", 0);
|
|
|
|
if (!control_node) {
|
|
|
|
dev_err(&pdev->dev, "Failed to get control device phandle\n");
|
|
|
|
return -EINVAL;
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
2014-03-03 04:38:12 -07:00
|
|
|
|
2013-10-03 09:12:33 -06:00
|
|
|
control_pdev = of_find_device_by_node(control_node);
|
|
|
|
if (!control_pdev) {
|
|
|
|
dev_err(&pdev->dev, "Failed to get control device\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
phy->control_dev = &control_pdev->dev;
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-06 07:38:37 -07:00
|
|
|
omap_control_phy_power(phy->control_dev, 0);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
|
|
|
platform_set_drvdata(pdev, phy);
|
|
|
|
pm_runtime_enable(phy->dev);
|
2014-03-03 04:38:12 -07:00
|
|
|
|
2014-11-19 08:28:21 -07:00
|
|
|
generic_phy = devm_phy_create(phy->dev, NULL, &ops);
|
2014-03-03 04:38:12 -07:00
|
|
|
if (IS_ERR(generic_phy))
|
|
|
|
return PTR_ERR(generic_phy);
|
|
|
|
|
|
|
|
phy_set_drvdata(generic_phy, phy);
|
|
|
|
phy_provider = devm_of_phy_provider_register(phy->dev,
|
|
|
|
of_phy_simple_xlate);
|
|
|
|
if (IS_ERR(phy_provider))
|
|
|
|
return PTR_ERR(phy_provider);
|
|
|
|
|
2013-01-24 19:51:48 -07:00
|
|
|
pm_runtime_get(&pdev->dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static int ti_pipe3_remove(struct platform_device *pdev)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
|
|
|
if (!pm_runtime_suspended(&pdev->dev))
|
|
|
|
pm_runtime_put(&pdev->dev);
|
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-12 16:42:12 -07:00
|
|
|
#ifdef CONFIG_PM
|
2015-01-13 05:23:20 -07:00
|
|
|
static int ti_pipe3_enable_refclk(struct ti_pipe3 *phy)
|
|
|
|
{
|
|
|
|
if (!IS_ERR(phy->refclk) && !phy->refclk_enabled) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = clk_prepare_enable(phy->refclk);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(phy->dev, "Failed to enable refclk %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
phy->refclk_enabled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ti_pipe3_disable_refclk(struct ti_pipe3 *phy)
|
|
|
|
{
|
|
|
|
if (!IS_ERR(phy->refclk))
|
|
|
|
clk_disable_unprepare(phy->refclk);
|
|
|
|
|
|
|
|
phy->refclk_enabled = false;
|
|
|
|
}
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2015-01-13 05:23:19 -07:00
|
|
|
static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
2015-01-13 05:23:19 -07:00
|
|
|
int ret = 0;
|
|
|
|
unsigned long flags;
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2015-01-13 05:23:19 -07:00
|
|
|
spin_lock_irqsave(&phy->lock, flags);
|
|
|
|
if (phy->enabled)
|
|
|
|
goto err1;
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2015-01-13 05:23:20 -07:00
|
|
|
ret = ti_pipe3_enable_refclk(phy);
|
|
|
|
if (ret)
|
|
|
|
goto err1;
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-06 22:57:09 -07:00
|
|
|
if (!IS_ERR(phy->wkupclk)) {
|
|
|
|
ret = clk_prepare_enable(phy->wkupclk);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(phy->dev, "Failed to enable wkupclk %d\n", ret);
|
|
|
|
goto err2;
|
|
|
|
}
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
if (!IS_ERR(phy->div_clk)) {
|
|
|
|
ret = clk_prepare_enable(phy->div_clk);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(phy->dev, "Failed to enable div_clk %d\n", ret);
|
|
|
|
goto err3;
|
|
|
|
}
|
|
|
|
}
|
2015-01-13 05:23:19 -07:00
|
|
|
|
|
|
|
phy->enabled = true;
|
|
|
|
spin_unlock_irqrestore(&phy->lock, flags);
|
2013-01-24 19:51:48 -07:00
|
|
|
return 0;
|
|
|
|
|
2014-06-25 11:52:56 -06:00
|
|
|
err3:
|
|
|
|
if (!IS_ERR(phy->wkupclk))
|
|
|
|
clk_disable_unprepare(phy->wkupclk);
|
|
|
|
|
2013-01-24 19:51:48 -07:00
|
|
|
err2:
|
2014-03-06 22:57:09 -07:00
|
|
|
if (!IS_ERR(phy->refclk))
|
|
|
|
clk_disable_unprepare(phy->refclk);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2015-01-13 05:23:20 -07:00
|
|
|
ti_pipe3_disable_refclk(phy);
|
2013-01-24 19:51:48 -07:00
|
|
|
err1:
|
2015-01-13 05:23:19 -07:00
|
|
|
spin_unlock_irqrestore(&phy->lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ti_pipe3_disable_clocks(struct ti_pipe3 *phy)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&phy->lock, flags);
|
|
|
|
if (!phy->enabled) {
|
|
|
|
spin_unlock_irqrestore(&phy->lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!IS_ERR(phy->wkupclk))
|
|
|
|
clk_disable_unprepare(phy->wkupclk);
|
2015-01-13 05:23:20 -07:00
|
|
|
/* Don't disable refclk for SATA PHY due to Errata i783 */
|
|
|
|
if (!of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata"))
|
|
|
|
ti_pipe3_disable_refclk(phy);
|
2015-01-13 05:23:19 -07:00
|
|
|
if (!IS_ERR(phy->div_clk))
|
|
|
|
clk_disable_unprepare(phy->div_clk);
|
|
|
|
phy->enabled = false;
|
|
|
|
spin_unlock_irqrestore(&phy->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ti_pipe3_runtime_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct ti_pipe3 *phy = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
ti_pipe3_disable_clocks(phy);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ti_pipe3_runtime_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct ti_pipe3 *phy = dev_get_drvdata(dev);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
ret = ti_pipe3_enable_clocks(phy);
|
2013-01-24 19:51:48 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-01-13 05:23:19 -07:00
|
|
|
static int ti_pipe3_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct ti_pipe3 *phy = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
ti_pipe3_disable_clocks(phy);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ti_pipe3_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct ti_pipe3 *phy = dev_get_drvdata(dev);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = ti_pipe3_enable_clocks(phy);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
pm_runtime_disable(dev);
|
|
|
|
pm_runtime_set_active(dev);
|
|
|
|
pm_runtime_enable(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static const struct dev_pm_ops ti_pipe3_pm_ops = {
|
|
|
|
SET_RUNTIME_PM_OPS(ti_pipe3_runtime_suspend,
|
|
|
|
ti_pipe3_runtime_resume, NULL)
|
2015-01-13 05:23:19 -07:00
|
|
|
SET_SYSTEM_SLEEP_PM_OPS(ti_pipe3_suspend, ti_pipe3_resume)
|
2013-01-24 19:51:48 -07:00
|
|
|
};
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static const struct of_device_id ti_pipe3_id_table[] = {
|
2014-03-06 23:13:39 -07:00
|
|
|
{
|
|
|
|
.compatible = "ti,phy-usb3",
|
|
|
|
.data = dpll_map_usb,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap-usb3",
|
|
|
|
.data = dpll_map_usb,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,phy-pipe3-sata",
|
|
|
|
.data = dpll_map_sata,
|
|
|
|
},
|
2014-06-25 11:52:56 -06:00
|
|
|
{
|
|
|
|
.compatible = "ti,phy-pipe3-pcie",
|
|
|
|
},
|
2013-01-24 19:51:48 -07:00
|
|
|
{}
|
|
|
|
};
|
2014-03-03 04:38:12 -07:00
|
|
|
MODULE_DEVICE_TABLE(of, ti_pipe3_id_table);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static struct platform_driver ti_pipe3_driver = {
|
|
|
|
.probe = ti_pipe3_probe,
|
|
|
|
.remove = ti_pipe3_remove,
|
2013-01-24 19:51:48 -07:00
|
|
|
.driver = {
|
2014-03-03 04:38:12 -07:00
|
|
|
.name = "ti-pipe3",
|
2015-01-13 05:23:19 -07:00
|
|
|
.pm = &ti_pipe3_pm_ops,
|
2015-03-05 03:20:53 -07:00
|
|
|
.of_match_table = ti_pipe3_id_table,
|
2013-01-24 19:51:48 -07:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
module_platform_driver(ti_pipe3_driver);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2015-03-06 09:01:21 -07:00
|
|
|
MODULE_ALIAS("platform:ti_pipe3");
|
2013-01-24 19:51:48 -07:00
|
|
|
MODULE_AUTHOR("Texas Instruments Inc.");
|
2014-03-03 04:38:12 -07:00
|
|
|
MODULE_DESCRIPTION("TI PIPE3 phy driver");
|
2013-01-24 19:51:48 -07:00
|
|
|
MODULE_LICENSE("GPL v2");
|