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-07-17 07:47:22 -06:00
|
|
|
#include <linux/mfd/syscon.h>
|
|
|
|
#include <linux/regmap.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
|
|
|
|
|
2015-07-17 07:47:22 -06:00
|
|
|
#define SATA_PLL_SOFT_RESET BIT(18)
|
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
#define PIPE3_PHY_PWRCTL_CLK_CMD_MASK 0x003FC000
|
|
|
|
#define PIPE3_PHY_PWRCTL_CLK_CMD_SHIFT 14
|
|
|
|
|
|
|
|
#define PIPE3_PHY_PWRCTL_CLK_FREQ_MASK 0xFFC00000
|
|
|
|
#define PIPE3_PHY_PWRCTL_CLK_FREQ_SHIFT 22
|
|
|
|
|
|
|
|
#define PIPE3_PHY_TX_RX_POWERON 0x3
|
|
|
|
#define PIPE3_PHY_TX_RX_POWEROFF 0x0
|
|
|
|
|
2015-12-21 01:54:11 -07:00
|
|
|
#define PCIE_PCS_MASK 0xFF0000
|
|
|
|
#define PCIE_PCS_DELAY_COUNT_SHIFT 0x10
|
|
|
|
|
2013-01-24 19:51:48 -07:00
|
|
|
/*
|
|
|
|
* 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-12-21 01:54:10 -07:00
|
|
|
struct regmap *phy_power_syscon; /* ctrl. reg. acces */
|
2015-12-21 01:54:11 -07:00
|
|
|
struct regmap *pcs_syscon; /* ctrl. reg. acces */
|
2015-07-17 07:47:22 -06:00
|
|
|
struct regmap *dpll_reset_syscon; /* ctrl. reg. acces */
|
|
|
|
unsigned int dpll_reset_reg; /* reg. index within syscon */
|
2015-12-21 01:54:10 -07:00
|
|
|
unsigned int power_reg; /* power reg. index within syscon */
|
2015-12-21 01:54:11 -07:00
|
|
|
unsigned int pcie_pcs_reg; /* pcs reg. index in syscon */
|
2015-07-17 07:47:22 -06:00
|
|
|
bool sata_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
|
|
|
}
|
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy);
|
|
|
|
static void ti_pipe3_disable_clocks(struct ti_pipe3 *phy);
|
|
|
|
|
2014-03-03 04:38:12 -07:00
|
|
|
static int ti_pipe3_power_off(struct phy *x)
|
|
|
|
{
|
2015-12-21 01:54:10 -07:00
|
|
|
u32 val;
|
|
|
|
int ret;
|
2014-03-03 04:38:12 -07:00
|
|
|
struct ti_pipe3 *phy = phy_get_drvdata(x);
|
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
if (!phy->phy_power_syscon) {
|
|
|
|
omap_control_phy_power(phy->control_dev, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-03-03 04:38:12 -07:00
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
val = PIPE3_PHY_TX_RX_POWEROFF << PIPE3_PHY_PWRCTL_CLK_CMD_SHIFT;
|
|
|
|
|
|
|
|
ret = regmap_update_bits(phy->phy_power_syscon, phy->power_reg,
|
|
|
|
PIPE3_PHY_PWRCTL_CLK_CMD_MASK, val);
|
|
|
|
return ret;
|
2014-03-03 04:38:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ti_pipe3_power_on(struct phy *x)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
2015-12-21 01:54:10 -07:00
|
|
|
u32 val;
|
|
|
|
u32 mask;
|
|
|
|
int ret;
|
|
|
|
unsigned long rate;
|
2014-03-03 04:38:12 -07:00
|
|
|
struct ti_pipe3 *phy = phy_get_drvdata(x);
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
if (!phy->phy_power_syscon) {
|
|
|
|
omap_control_phy_power(phy->control_dev, 1);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-01-24 19:51:48 -07:00
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
rate = clk_get_rate(phy->sys_clk);
|
|
|
|
if (!rate) {
|
|
|
|
dev_err(phy->dev, "Invalid clock rate\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
rate = rate / 1000000;
|
|
|
|
mask = OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_CMD_MASK |
|
|
|
|
OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_FREQ_MASK;
|
|
|
|
val = PIPE3_PHY_TX_RX_POWERON << PIPE3_PHY_PWRCTL_CLK_CMD_SHIFT;
|
|
|
|
val |= rate << OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_FREQ_SHIFT;
|
|
|
|
|
|
|
|
ret = regmap_update_bits(phy->phy_power_syscon, phy->power_reg,
|
|
|
|
mask, val);
|
|
|
|
return ret;
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
ti_pipe3_enable_clocks(phy);
|
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")) {
|
2015-12-21 01:54:11 -07:00
|
|
|
if (!phy->pcs_syscon) {
|
|
|
|
omap_control_pcie_pcs(phy->control_dev, 0x96);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = 0x96 << OMAP_CTRL_PCIE_PCS_DELAY_COUNT_SHIFT;
|
|
|
|
ret = regmap_update_bits(phy->pcs_syscon, phy->pcie_pcs_reg,
|
|
|
|
PCIE_PCS_MASK, val);
|
|
|
|
return ret;
|
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
|
|
|
|
2016-05-18 06:28:06 -06:00
|
|
|
/* SATA has issues if re-programmed when locked */
|
2014-03-06 07:38:43 -07:00
|
|
|
val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_STATUS);
|
2016-05-18 06:28:06 -06:00
|
|
|
if ((val & PLL_LOCK) && of_device_is_compatible(phy->dev->of_node,
|
|
|
|
"ti,phy-pipe3-sata"))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Program the DPLL */
|
|
|
|
ret = ti_pipe3_dpll_program(phy);
|
|
|
|
if (ret) {
|
|
|
|
ti_pipe3_disable_clocks(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;
|
|
|
|
|
2015-07-17 07:47:22 -06:00
|
|
|
/* If dpll_reset_syscon is not present we wont power down SATA DPLL
|
|
|
|
* due to Errata i783
|
|
|
|
*/
|
|
|
|
if (of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata") &&
|
|
|
|
!phy->dpll_reset_syscon)
|
2014-03-06 07:38:44 -07:00
|
|
|
return 0;
|
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
/* PCIe doesn't have internal DPLL */
|
|
|
|
if (!of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-pcie")) {
|
|
|
|
/* 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);
|
2014-03-06 07:38:43 -07:00
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
/* 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;
|
|
|
|
}
|
2014-03-06 07:38:43 -07:00
|
|
|
}
|
|
|
|
|
2015-07-17 07:47:22 -06:00
|
|
|
/* i783: SATA needs control bit toggle after PLL unlock */
|
|
|
|
if (of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata")) {
|
|
|
|
regmap_update_bits(phy->dpll_reset_syscon, phy->dpll_reset_reg,
|
|
|
|
SATA_PLL_SOFT_RESET, SATA_PLL_SOFT_RESET);
|
|
|
|
regmap_update_bits(phy->dpll_reset_syscon, phy->dpll_reset_reg,
|
|
|
|
SATA_PLL_SOFT_RESET, 0);
|
|
|
|
}
|
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
ti_pipe3_disable_clocks(phy);
|
|
|
|
|
2014-03-06 07:38:43 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2015-07-15 01:33:51 -06:00
|
|
|
static const struct phy_ops ops = {
|
2014-03-03 04:38:12 -07:00
|
|
|
.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[];
|
|
|
|
|
2015-12-21 01:54:06 -07:00
|
|
|
static int ti_pipe3_get_clk(struct ti_pipe3 *phy)
|
2013-01-24 19:51:48 -07:00
|
|
|
{
|
2014-06-25 11:52:56 -06:00
|
|
|
struct clk *clk;
|
2015-12-21 01:54:06 -07:00
|
|
|
struct device *dev = phy->dev;
|
|
|
|
struct device_node *node = dev->of_node;
|
2014-03-06 07:38:42 -07:00
|
|
|
|
2015-12-21 01:54:05 -07:00
|
|
|
phy->refclk = devm_clk_get(dev, "refclk");
|
2015-01-13 05:23:20 -07:00
|
|
|
if (IS_ERR(phy->refclk)) {
|
2015-12-21 01:54:05 -07:00
|
|
|
dev_err(dev, "unable to get refclk\n");
|
2015-01-13 05:23:20 -07:00
|
|
|
/* 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")) {
|
2015-12-21 01:54:05 -07:00
|
|
|
phy->wkupclk = devm_clk_get(dev, "wkupclk");
|
2014-03-06 07:38:42 -07:00
|
|
|
if (IS_ERR(phy->wkupclk)) {
|
2015-12-21 01:54:05 -07:00
|
|
|
dev_err(dev, "unable to get wkupclk\n");
|
2014-03-06 07:38:42 -07:00
|
|
|
return PTR_ERR(phy->wkupclk);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
phy->wkupclk = ERR_PTR(-ENODEV);
|
2015-12-21 01:54:06 -07:00
|
|
|
}
|
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
if (!of_device_is_compatible(node, "ti,phy-pipe3-pcie") ||
|
|
|
|
phy->phy_power_syscon) {
|
2015-12-21 01:54:06 -07:00
|
|
|
phy->sys_clk = devm_clk_get(dev, "sysclk");
|
|
|
|
if (IS_ERR(phy->sys_clk)) {
|
|
|
|
dev_err(dev, "unable to get sysclk\n");
|
|
|
|
return -EINVAL;
|
2015-07-17 07:47:22 -06:00
|
|
|
}
|
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-12-21 01:54:05 -07:00
|
|
|
clk = devm_clk_get(dev, "dpll_ref");
|
2014-06-25 11:52:56 -06:00
|
|
|
if (IS_ERR(clk)) {
|
2015-12-21 01:54:05 -07:00
|
|
|
dev_err(dev, "unable to get dpll ref clk\n");
|
2014-06-25 11:52:56 -06:00
|
|
|
return PTR_ERR(clk);
|
|
|
|
}
|
|
|
|
clk_set_rate(clk, 1500000000);
|
|
|
|
|
2015-12-21 01:54:05 -07:00
|
|
|
clk = devm_clk_get(dev, "dpll_ref_m2");
|
2014-06-25 11:52:56 -06:00
|
|
|
if (IS_ERR(clk)) {
|
2015-12-21 01:54:05 -07:00
|
|
|
dev_err(dev, "unable to get dpll ref m2 clk\n");
|
2014-06-25 11:52:56 -06:00
|
|
|
return PTR_ERR(clk);
|
|
|
|
}
|
|
|
|
clk_set_rate(clk, 100000000);
|
|
|
|
|
2015-12-21 01:54:05 -07:00
|
|
|
clk = devm_clk_get(dev, "phy-div");
|
2014-06-25 11:52:56 -06:00
|
|
|
if (IS_ERR(clk)) {
|
2015-12-21 01:54:05 -07:00
|
|
|
dev_err(dev, "unable to get phy-div clk\n");
|
2014-06-25 11:52:56 -06:00
|
|
|
return PTR_ERR(clk);
|
|
|
|
}
|
|
|
|
clk_set_rate(clk, 100000000);
|
|
|
|
|
2015-12-21 01:54:05 -07:00
|
|
|
phy->div_clk = devm_clk_get(dev, "div-clk");
|
2014-06-25 11:52:56 -06:00
|
|
|
if (IS_ERR(phy->div_clk)) {
|
2015-12-21 01:54:05 -07:00
|
|
|
dev_err(dev, "unable to get div-clk\n");
|
2014-06-25 11:52:56 -06:00
|
|
|
return PTR_ERR(phy->div_clk);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
phy->div_clk = ERR_PTR(-ENODEV);
|
2013-01-24 19:51:48 -07:00
|
|
|
}
|
|
|
|
|
2015-12-21 01:54:06 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-12-21 01:54:07 -07:00
|
|
|
static int ti_pipe3_get_sysctrl(struct ti_pipe3 *phy)
|
|
|
|
{
|
|
|
|
struct device *dev = phy->dev;
|
|
|
|
struct device_node *node = dev->of_node;
|
|
|
|
struct device_node *control_node;
|
|
|
|
struct platform_device *control_pdev;
|
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
phy->phy_power_syscon = syscon_regmap_lookup_by_phandle(node,
|
|
|
|
"syscon-phy-power");
|
|
|
|
if (IS_ERR(phy->phy_power_syscon)) {
|
|
|
|
dev_dbg(dev,
|
|
|
|
"can't get syscon-phy-power, using control device\n");
|
|
|
|
phy->phy_power_syscon = NULL;
|
|
|
|
} else {
|
|
|
|
if (of_property_read_u32_index(node,
|
|
|
|
"syscon-phy-power", 1,
|
|
|
|
&phy->power_reg)) {
|
|
|
|
dev_err(dev, "couldn't get power reg. offset\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2015-12-21 01:54:07 -07:00
|
|
|
}
|
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
if (!phy->phy_power_syscon) {
|
|
|
|
control_node = of_parse_phandle(node, "ctrl-module", 0);
|
|
|
|
if (!control_node) {
|
|
|
|
dev_err(dev, "Failed to get control device phandle\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2015-12-21 01:54:07 -07:00
|
|
|
|
2015-12-21 01:54:10 -07:00
|
|
|
control_pdev = of_find_device_by_node(control_node);
|
|
|
|
if (!control_pdev) {
|
|
|
|
dev_err(dev, "Failed to get control device\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
phy->control_dev = &control_pdev->dev;
|
|
|
|
}
|
2015-12-21 01:54:07 -07:00
|
|
|
|
2015-12-21 01:54:11 -07:00
|
|
|
if (of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
|
|
|
|
phy->pcs_syscon = syscon_regmap_lookup_by_phandle(node,
|
|
|
|
"syscon-pcs");
|
|
|
|
if (IS_ERR(phy->pcs_syscon)) {
|
|
|
|
dev_dbg(dev,
|
|
|
|
"can't get syscon-pcs, using omap control\n");
|
|
|
|
phy->pcs_syscon = NULL;
|
|
|
|
} else {
|
|
|
|
if (of_property_read_u32_index(node,
|
|
|
|
"syscon-pcs", 1,
|
|
|
|
&phy->pcie_pcs_reg)) {
|
|
|
|
dev_err(dev,
|
|
|
|
"couldn't get pcie pcs reg. offset\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-21 01:54:07 -07:00
|
|
|
if (of_device_is_compatible(node, "ti,phy-pipe3-sata")) {
|
|
|
|
phy->dpll_reset_syscon = syscon_regmap_lookup_by_phandle(node,
|
|
|
|
"syscon-pllreset");
|
|
|
|
if (IS_ERR(phy->dpll_reset_syscon)) {
|
|
|
|
dev_info(dev,
|
|
|
|
"can't get syscon-pllreset, sata dpll won't idle\n");
|
|
|
|
phy->dpll_reset_syscon = NULL;
|
|
|
|
} else {
|
|
|
|
if (of_property_read_u32_index(node,
|
|
|
|
"syscon-pllreset", 1,
|
|
|
|
&phy->dpll_reset_reg)) {
|
|
|
|
dev_err(dev,
|
|
|
|
"couldn't get pllreset reg. offset\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-12-21 01:54:08 -07:00
|
|
|
static int ti_pipe3_get_pll_base(struct ti_pipe3 *phy)
|
|
|
|
{
|
|
|
|
struct resource *res;
|
|
|
|
const struct of_device_id *match;
|
|
|
|
struct device *dev = phy->dev;
|
|
|
|
struct device_node *node = dev->of_node;
|
|
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
|
|
|
|
if (of_device_is_compatible(node, "ti,phy-pipe3-pcie"))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
match = of_match_device(ti_pipe3_id_table, dev);
|
|
|
|
if (!match)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
phy->dpll_map = (struct pipe3_dpll_map *)match->data;
|
|
|
|
if (!phy->dpll_map) {
|
|
|
|
dev_err(dev, "no DPLL data\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
|
|
|
|
"pll_ctrl");
|
|
|
|
phy->pll_ctrl_base = devm_ioremap_resource(dev, res);
|
|
|
|
if (IS_ERR(phy->pll_ctrl_base))
|
|
|
|
return PTR_ERR(phy->pll_ctrl_base);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-12-21 01:54:06 -07:00
|
|
|
static int ti_pipe3_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct ti_pipe3 *phy;
|
|
|
|
struct phy *generic_phy;
|
|
|
|
struct phy_provider *phy_provider;
|
|
|
|
struct device_node *node = pdev->dev.of_node;
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL);
|
|
|
|
if (!phy)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
phy->dev = dev;
|
|
|
|
|
2015-12-21 01:54:08 -07:00
|
|
|
ret = ti_pipe3_get_pll_base(phy);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2015-12-21 01:54:06 -07:00
|
|
|
|
2015-12-21 01:54:07 -07:00
|
|
|
ret = ti_pipe3_get_sysctrl(phy);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2015-12-21 01:54:06 -07:00
|
|
|
|
|
|
|
ret = ti_pipe3_get_clk(phy);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-01-24 19:51:48 -07:00
|
|
|
platform_set_drvdata(pdev, phy);
|
2015-12-21 01:54:05 -07:00
|
|
|
pm_runtime_enable(dev);
|
2015-07-17 07:47:22 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Prevent auto-disable of refclk for SATA PHY due to Errata i783
|
|
|
|
*/
|
|
|
|
if (of_device_is_compatible(node, "ti,phy-pipe3-sata")) {
|
|
|
|
if (!IS_ERR(phy->refclk)) {
|
2015-06-02 03:10:40 -06:00
|
|
|
clk_prepare_enable(phy->refclk);
|
2015-07-17 07:47:22 -06:00
|
|
|
phy->sata_refclk_enabled = true;
|
|
|
|
}
|
|
|
|
}
|
2014-03-03 04:38:12 -07:00
|
|
|
|
2015-12-21 01:54:05 -07:00
|
|
|
generic_phy = devm_phy_create(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);
|
2015-12-21 01:54:09 -07:00
|
|
|
|
|
|
|
ti_pipe3_power_off(generic_phy);
|
|
|
|
|
2015-12-21 01:54:05 -07:00
|
|
|
phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate);
|
2014-03-03 04:38:12 -07:00
|
|
|
if (IS_ERR(phy_provider))
|
|
|
|
return PTR_ERR(phy_provider);
|
|
|
|
|
2013-01-24 19:51:48 -07:00
|
|
|
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
|
|
|
{
|
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy)
|
2015-01-13 05:23:20 -07:00
|
|
|
{
|
2015-06-02 03:10:40 -06:00
|
|
|
int ret = 0;
|
2015-01-13 05:23:20 -07:00
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
if (!IS_ERR(phy->refclk)) {
|
2015-01-13 05:23:20 -07:00
|
|
|
ret = clk_prepare_enable(phy->refclk);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(phy->dev, "Failed to enable refclk %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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);
|
2015-06-02 03:10:40 -06:00
|
|
|
goto disable_refclk;
|
2014-03-06 22:57:09 -07:00
|
|
|
}
|
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);
|
2015-06-02 03:10:40 -06:00
|
|
|
goto disable_wkupclk;
|
2014-06-25 11:52:56 -06:00
|
|
|
}
|
|
|
|
}
|
2015-01-13 05:23:19 -07:00
|
|
|
|
2013-01-24 19:51:48 -07:00
|
|
|
return 0;
|
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
disable_wkupclk:
|
2014-06-25 11:52:56 -06:00
|
|
|
if (!IS_ERR(phy->wkupclk))
|
|
|
|
clk_disable_unprepare(phy->wkupclk);
|
|
|
|
|
2015-06-02 03:10:40 -06:00
|
|
|
disable_refclk:
|
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:19 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ti_pipe3_disable_clocks(struct ti_pipe3 *phy)
|
|
|
|
{
|
|
|
|
if (!IS_ERR(phy->wkupclk))
|
|
|
|
clk_disable_unprepare(phy->wkupclk);
|
2015-07-17 07:47:22 -06:00
|
|
|
if (!IS_ERR(phy->refclk)) {
|
2015-06-02 03:10:40 -06:00
|
|
|
clk_disable_unprepare(phy->refclk);
|
2015-07-17 07:47:22 -06:00
|
|
|
/*
|
|
|
|
* SATA refclk needs an additional disable as we left it
|
|
|
|
* on in probe to avoid Errata i783
|
|
|
|
*/
|
|
|
|
if (phy->sata_refclk_enabled) {
|
|
|
|
clk_disable_unprepare(phy->refclk);
|
|
|
|
phy->sata_refclk_enabled = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-13 05:23:19 -07:00
|
|
|
if (!IS_ERR(phy->div_clk))
|
|
|
|
clk_disable_unprepare(phy->div_clk);
|
|
|
|
}
|
|
|
|
|
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-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");
|