phy-ti-pipe3.c 13.1 KB
Newer Older
1
/*
2
 * phy-ti-pipe3 - PIPE3 PHY driver.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * 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>
22
#include <linux/phy/phy.h>
23 24 25
#include <linux/of.h>
#include <linux/clk.h>
#include <linux/err.h>
26
#include <linux/io.h>
27 28
#include <linux/pm_runtime.h>
#include <linux/delay.h>
29
#include <linux/phy/omap_control_phy.h>
30
#include <linux/of_platform.h>
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

#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
48
#define	PLL_SD_SHIFT		10
49
#define	SET_PLL_GO		0x1
50 51
#define PLL_LDOPWDN		BIT(15)
#define PLL_TICOPWDN		BIT(16)
52 53 54 55 56
#define	PLL_LOCK		0x2
#define	PLL_IDLE		0x1

/*
 * This is an Empirical value that works, need to confirm the actual
57 58
 * value required for the PIPE3PHY_PLL_CONFIGURATION2.PLL_IDLE status
 * to be correctly reflected in the PIPE3PHY_PLL_STATUS register.
59
 */
60 61
#define PLL_IDLE_TIME	100	/* in milliseconds */
#define PLL_LOCK_TIME	100	/* in milliseconds */
62

63 64 65 66 67 68 69 70
struct pipe3_dpll_params {
	u16	m;
	u8	n;
	u8	freq:3;
	u8	sd;
	u32	mf;
};

71 72 73 74 75
struct pipe3_dpll_map {
	unsigned long rate;
	struct pipe3_dpll_params params;
};

76 77 78 79 80 81
struct ti_pipe3 {
	void __iomem		*pll_ctrl_base;
	struct device		*dev;
	struct device		*control_dev;
	struct clk		*wkupclk;
	struct clk		*sys_clk;
82
	struct clk		*refclk;
83
	struct clk		*div_clk;
84
	struct pipe3_dpll_map	*dpll_map;
85
	u8			id;
86 87
};

88
static struct pipe3_dpll_map dpll_map_usb[] = {
89 90 91 92 93 94
	{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 */
95 96 97 98 99 100 101 102 103 104 105
	{ },					/* 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 */
106 107
};

108 109 110 111 112 113 114 115 116 117 118
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);
}

119
static struct pipe3_dpll_params *ti_pipe3_get_dpll_params(struct ti_pipe3 *phy)
120
{
121 122
	unsigned long rate;
	struct pipe3_dpll_map *dpll_map = phy->dpll_map;
123

124 125 126 127 128
	rate = clk_get_rate(phy->sys_clk);

	for (; dpll_map->rate; dpll_map++) {
		if (rate == dpll_map->rate)
			return &dpll_map->params;
129 130
	}

131 132
	dev_err(phy->dev, "No DPLL configuration for %lu Hz SYS CLK\n", rate);

133
	return NULL;
134 135
}

136 137 138 139
static int ti_pipe3_power_off(struct phy *x)
{
	struct ti_pipe3 *phy = phy_get_drvdata(x);

140
	omap_control_phy_power(phy->control_dev, 0);
141 142 143 144 145

	return 0;
}

static int ti_pipe3_power_on(struct phy *x)
146
{
147
	struct ti_pipe3 *phy = phy_get_drvdata(x);
148

149
	omap_control_phy_power(phy->control_dev, 1);
150 151 152 153

	return 0;
}

154
static int ti_pipe3_dpll_wait_lock(struct ti_pipe3 *phy)
155 156 157 158
{
	u32		val;
	unsigned long	timeout;

159
	timeout = jiffies + msecs_to_jiffies(PLL_LOCK_TIME);
160
	do {
161
		cpu_relax();
162
		val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_STATUS);
163 164
		if (val & PLL_LOCK)
			break;
165 166 167 168 169 170 171 172
	} while (!time_after(jiffies, timeout));

	if (!(val & PLL_LOCK)) {
		dev_err(phy->dev, "DPLL failed to lock\n");
		return -EBUSY;
	}

	return 0;
173 174
}

175
static int ti_pipe3_dpll_program(struct ti_pipe3 *phy)
176 177
{
	u32			val;
178
	struct pipe3_dpll_params *dpll_params;
179

180 181
	dpll_params = ti_pipe3_get_dpll_params(phy);
	if (!dpll_params)
182 183
		return -EINVAL;

184
	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION1);
185
	val &= ~PLL_REGN_MASK;
186
	val |= dpll_params->n << PLL_REGN_SHIFT;
187
	ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION1, val);
188

189
	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION2);
190
	val &= ~PLL_SELFREQDCO_MASK;
191
	val |= dpll_params->freq << PLL_SELFREQDCO_SHIFT;
192
	ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION2, val);
193

194
	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION1);
195
	val &= ~PLL_REGM_MASK;
196
	val |= dpll_params->m << PLL_REGM_SHIFT;
197
	ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION1, val);
198

199
	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION4);
200
	val &= ~PLL_REGM_F_MASK;
201
	val |= dpll_params->mf << PLL_REGM_F_SHIFT;
202
	ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION4, val);
203

204
	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION3);
205
	val &= ~PLL_SD_MASK;
206
	val |= dpll_params->sd << PLL_SD_SHIFT;
207
	ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION3, val);
208

209
	ti_pipe3_writel(phy->pll_ctrl_base, PLL_GO, SET_PLL_GO);
210

211
	return ti_pipe3_dpll_wait_lock(phy);
212 213
}

214
static int ti_pipe3_init(struct phy *x)
215
{
216
	struct ti_pipe3 *phy = phy_get_drvdata(x);
217 218
	u32 val;
	int ret = 0;
219

220 221
	if (of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-pcie")) {
		omap_control_pcie_pcs(phy->control_dev, phy->id, 0xF1);
222
		return 0;
223
	}
224

225 226 227 228 229 230 231
	/* 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);
	}
232

233 234 235 236 237
	/* 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;
238

239
	return ret;
240 241
}

242 243 244 245 246 247
static int ti_pipe3_exit(struct phy *x)
{
	struct ti_pipe3 *phy = phy_get_drvdata(x);
	u32 val;
	unsigned long timeout;

248 249 250 251 252
	/* 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"))
253 254
		return 0;

255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
	/* 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;
}
277 278
static struct phy_ops ops = {
	.init		= ti_pipe3_init,
279
	.exit		= ti_pipe3_exit,
280 281 282 283 284
	.power_on	= ti_pipe3_power_on,
	.power_off	= ti_pipe3_power_off,
	.owner		= THIS_MODULE,
};

285 286 287 288
#ifdef CONFIG_OF
static const struct of_device_id ti_pipe3_id_table[];
#endif

289
static int ti_pipe3_probe(struct platform_device *pdev)
290
{
291 292 293
	struct ti_pipe3 *phy;
	struct phy *generic_phy;
	struct phy_provider *phy_provider;
294 295 296 297
	struct resource *res;
	struct device_node *node = pdev->dev.of_node;
	struct device_node *control_node;
	struct platform_device *control_pdev;
298
	const struct of_device_id *match;
299
	struct clk *clk;
300 301 302

	phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
	if (!phy) {
303
		dev_err(&pdev->dev, "unable to alloc mem for TI PIPE3 PHY\n");
304 305
		return -ENOMEM;
	}
306
	phy->dev		= &pdev->dev;
307

308 309 310 311 312
	if (!of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
		match = of_match_device(of_match_ptr(ti_pipe3_id_table),
					&pdev->dev);
		if (!match)
			return -EINVAL;
313

314 315 316 317 318
		phy->dpll_map = (struct pipe3_dpll_map *)match->data;
		if (!phy->dpll_map) {
			dev_err(&pdev->dev, "no DPLL data\n");
			return -EINVAL;
		}
319

320 321 322 323 324
		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);
325

326 327 328 329 330 331
		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;
		}
	}
332

333
	if (!of_device_is_compatible(node, "ti,phy-pipe3-sata")) {
334 335 336 337 338 339 340 341 342 343 344 345 346 347
		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);
		}

		phy->refclk = devm_clk_get(phy->dev, "refclk");
		if (IS_ERR(phy->refclk)) {
			dev_err(&pdev->dev, "unable to get refclk\n");
			return PTR_ERR(phy->refclk);
		}
	} else {
		phy->wkupclk = ERR_PTR(-ENODEV);
		phy->refclk = ERR_PTR(-ENODEV);
348 349
	}

350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
	if (of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
		if (of_property_read_u8(node, "id", &phy->id) < 0)
			phy->id = 1;

		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);
382 383
	}

384 385 386 387
	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;
388
	}
389

390 391 392 393 394 395 396
	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;
397

398
	omap_control_phy_power(phy->control_dev, 0);
399 400 401

	platform_set_drvdata(pdev, phy);
	pm_runtime_enable(phy->dev);
402 403 404 405 406 407 408 409 410 411 412

	generic_phy = devm_phy_create(phy->dev, &ops, NULL);
	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);

413 414 415 416 417
	pm_runtime_get(&pdev->dev);

	return 0;
}

418
static int ti_pipe3_remove(struct platform_device *pdev)
419 420 421 422 423 424 425 426 427 428
{
	if (!pm_runtime_suspended(&pdev->dev))
		pm_runtime_put(&pdev->dev);
	pm_runtime_disable(&pdev->dev);

	return 0;
}

#ifdef CONFIG_PM_RUNTIME

429
static int ti_pipe3_runtime_suspend(struct device *dev)
430
{
431
	struct ti_pipe3	*phy = dev_get_drvdata(dev);
432

433 434 435 436
	if (!IS_ERR(phy->wkupclk))
		clk_disable_unprepare(phy->wkupclk);
	if (!IS_ERR(phy->refclk))
		clk_disable_unprepare(phy->refclk);
437 438
	if (!IS_ERR(phy->div_clk))
		clk_disable_unprepare(phy->div_clk);
439 440 441 442

	return 0;
}

443
static int ti_pipe3_runtime_resume(struct device *dev)
444 445
{
	u32 ret = 0;
446
	struct ti_pipe3	*phy = dev_get_drvdata(dev);
447

448 449 450 451 452 453
	if (!IS_ERR(phy->refclk)) {
		ret = clk_prepare_enable(phy->refclk);
		if (ret) {
			dev_err(phy->dev, "Failed to enable refclk %d\n", ret);
			goto err1;
		}
454 455
	}

456 457 458 459 460 461
	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;
		}
462 463
	}

464 465 466 467 468 469 470
	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;
		}
	}
471 472
	return 0;

473 474 475 476
err3:
	if (!IS_ERR(phy->wkupclk))
		clk_disable_unprepare(phy->wkupclk);

477
err2:
478 479
	if (!IS_ERR(phy->refclk))
		clk_disable_unprepare(phy->refclk);
480 481 482 483 484

err1:
	return ret;
}

485 486 487
static const struct dev_pm_ops ti_pipe3_pm_ops = {
	SET_RUNTIME_PM_OPS(ti_pipe3_runtime_suspend,
			   ti_pipe3_runtime_resume, NULL)
488 489
};

490
#define DEV_PM_OPS     (&ti_pipe3_pm_ops)
491 492 493 494 495
#else
#define DEV_PM_OPS     NULL
#endif

#ifdef CONFIG_OF
496
static const struct of_device_id ti_pipe3_id_table[] = {
497 498 499 500 501 502 503 504 505 506 507 508
	{
		.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,
	},
509 510 511
	{
		.compatible = "ti,phy-pipe3-pcie",
	},
512 513
	{}
};
514
MODULE_DEVICE_TABLE(of, ti_pipe3_id_table);
515 516
#endif

517 518 519
static struct platform_driver ti_pipe3_driver = {
	.probe		= ti_pipe3_probe,
	.remove		= ti_pipe3_remove,
520
	.driver		= {
521
		.name	= "ti-pipe3",
522 523
		.owner	= THIS_MODULE,
		.pm	= DEV_PM_OPS,
524
		.of_match_table = of_match_ptr(ti_pipe3_id_table),
525 526 527
	},
};

528
module_platform_driver(ti_pipe3_driver);
529

530
MODULE_ALIAS("platform: ti_pipe3");
531
MODULE_AUTHOR("Texas Instruments Inc.");
532
MODULE_DESCRIPTION("TI PIPE3 phy driver");
533
MODULE_LICENSE("GPL v2");
新手
引导
客服 返回
顶部