mtk-smi.c 15.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
Yong Wu's avatar
Yong Wu committed
2 3 4 5 6 7 8 9 10
/*
 * Copyright (c) 2015-2016 MediaTek Inc.
 * Author: Yong Wu <yong.wu@mediatek.com>
 */
#include <linux/clk.h>
#include <linux/component.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/io.h>
11
#include <linux/module.h>
Yong Wu's avatar
Yong Wu committed
12 13 14 15 16
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <soc/mediatek/smi.h>
17
#include <dt-bindings/memory/mt2701-larb-port.h>
18
#include <dt-bindings/memory/mtk-memory-port.h>
Yong Wu's avatar
Yong Wu committed
19

20
/* mt8173 */
Yong Wu's avatar
Yong Wu committed
21
#define SMI_LARB_MMU_EN		0xf00
22

23 24 25
/* mt8167 */
#define MT8167_SMI_LARB_MMU_EN	0xfc0

26
/* mt2701 */
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
#define REG_SMI_SECUR_CON_BASE		0x5c0

/* every register control 8 port, register offset 0x4 */
#define REG_SMI_SECUR_CON_OFFSET(id)	(((id) >> 3) << 2)
#define REG_SMI_SECUR_CON_ADDR(id)	\
	(REG_SMI_SECUR_CON_BASE + REG_SMI_SECUR_CON_OFFSET(id))

/*
 * every port have 4 bit to control, bit[port + 3] control virtual or physical,
 * bit[port + 2 : port + 1] control the domain, bit[port] control the security
 * or non-security.
 */
#define SMI_SECUR_CON_VAL_MSK(id)	(~(0xf << (((id) & 0x7) << 2)))
#define SMI_SECUR_CON_VAL_VIRT(id)	BIT((((id) & 0x7) << 2) + 3)
/* mt2701 domain should be set to 3 */
#define SMI_SECUR_CON_VAL_DOMAIN(id)	(0x3 << ((((id) & 0x7) << 2) + 1))

44 45 46
/* mt2712 */
#define SMI_LARB_NONSEC_CON(id)	(0x380 + ((id) * 4))
#define F_MMU_EN		BIT(0)
47 48 49 50
#define BANK_SEL(id)		({			\
	u32 _id = (id) & 0x3;				\
	(_id << 8 | _id << 10 | _id << 12 | _id << 14);	\
})
51

52 53 54 55 56 57
/* SMI COMMON */
#define SMI_BUS_SEL			0x220
#define SMI_BUS_LARB_SHIFT(larbid)	((larbid) << 1)
/* All are MMU0 defaultly. Only specialize mmu1 here. */
#define F_MMU1_LARB(larbid)		(0x1 << SMI_BUS_LARB_SHIFT(larbid))

58 59 60 61 62 63 64
enum mtk_smi_gen {
	MTK_SMI_GEN1,
	MTK_SMI_GEN2
};

struct mtk_smi_common_plat {
	enum mtk_smi_gen gen;
65
	bool             has_gals;
66
	u32              bus_sel; /* Balance some larbs to enter mmu0 or mmu1 */
67 68
};

69 70
struct mtk_smi_larb_gen {
	int port_in_larb[MTK_LARB_NR_MAX + 1];
71
	void (*config_port)(struct device *dev);
72
	unsigned int			larb_direct_to_common_mask;
73
	bool				has_gals;
74
};
Yong Wu's avatar
Yong Wu committed
75 76

struct mtk_smi {
77 78
	struct device			*dev;
	struct clk			*clk_apb, *clk_smi;
79
	struct clk			*clk_gals0, *clk_gals1;
80
	struct clk			*clk_async; /*only needed by mt2701*/
81 82 83 84
	union {
		void __iomem		*smi_ao_base; /* only for gen1 */
		void __iomem		*base;	      /* only for gen2 */
	};
85
	const struct mtk_smi_common_plat *plat;
Yong Wu's avatar
Yong Wu committed
86 87 88
};

struct mtk_smi_larb { /* larb: local arbiter */
89 90 91 92 93 94
	struct mtk_smi			smi;
	void __iomem			*base;
	struct device			*smi_common_dev;
	const struct mtk_smi_larb_gen	*larb_gen;
	int				larbid;
	u32				*mmu;
95
	unsigned char			*bank;
96 97
};

98
static int mtk_smi_clk_enable(const struct mtk_smi *smi)
Yong Wu's avatar
Yong Wu committed
99 100 101 102 103
{
	int ret;

	ret = clk_prepare_enable(smi->clk_apb);
	if (ret)
104
		return ret;
Yong Wu's avatar
Yong Wu committed
105 106 107 108 109

	ret = clk_prepare_enable(smi->clk_smi);
	if (ret)
		goto err_disable_apb;

110 111 112 113 114 115 116 117
	ret = clk_prepare_enable(smi->clk_gals0);
	if (ret)
		goto err_disable_smi;

	ret = clk_prepare_enable(smi->clk_gals1);
	if (ret)
		goto err_disable_gals0;

Yong Wu's avatar
Yong Wu committed
118 119
	return 0;

120 121 122 123
err_disable_gals0:
	clk_disable_unprepare(smi->clk_gals0);
err_disable_smi:
	clk_disable_unprepare(smi->clk_smi);
Yong Wu's avatar
Yong Wu committed
124 125 126 127 128
err_disable_apb:
	clk_disable_unprepare(smi->clk_apb);
	return ret;
}

129
static void mtk_smi_clk_disable(const struct mtk_smi *smi)
Yong Wu's avatar
Yong Wu committed
130
{
131 132
	clk_disable_unprepare(smi->clk_gals1);
	clk_disable_unprepare(smi->clk_gals0);
Yong Wu's avatar
Yong Wu committed
133 134 135 136 137 138
	clk_disable_unprepare(smi->clk_smi);
	clk_disable_unprepare(smi->clk_apb);
}

int mtk_smi_larb_get(struct device *larbdev)
{
139
	int ret = pm_runtime_get_sync(larbdev);
Yong Wu's avatar
Yong Wu committed
140

141
	return (ret < 0) ? ret : 0;
Yong Wu's avatar
Yong Wu committed
142
}
143
EXPORT_SYMBOL_GPL(mtk_smi_larb_get);
Yong Wu's avatar
Yong Wu committed
144 145 146

void mtk_smi_larb_put(struct device *larbdev)
{
147
	pm_runtime_put_sync(larbdev);
Yong Wu's avatar
Yong Wu committed
148
}
149
EXPORT_SYMBOL_GPL(mtk_smi_larb_put);
Yong Wu's avatar
Yong Wu committed
150 151 152 153 154

static int
mtk_smi_larb_bind(struct device *dev, struct device *master, void *data)
{
	struct mtk_smi_larb *larb = dev_get_drvdata(dev);
155
	struct mtk_smi_larb_iommu *larb_mmu = data;
Yong Wu's avatar
Yong Wu committed
156 157
	unsigned int         i;

158
	for (i = 0; i < MTK_LARB_NR_MAX; i++) {
159
		if (dev == larb_mmu[i].dev) {
160
			larb->larbid = i;
161
			larb->mmu = &larb_mmu[i].mmu;
162
			larb->bank = larb_mmu[i].bank;
Yong Wu's avatar
Yong Wu committed
163 164 165 166 167 168
			return 0;
		}
	}
	return -ENODEV;
}

169
static void mtk_smi_larb_config_port_gen2_general(struct device *dev)
170 171
{
	struct mtk_smi_larb *larb = dev_get_drvdata(dev);
172 173
	u32 reg;
	int i;
174

175
	if (BIT(larb->larbid) & larb->larb_gen->larb_direct_to_common_mask)
176 177 178 179 180
		return;

	for_each_set_bit(i, (unsigned long *)larb->mmu, 32) {
		reg = readl_relaxed(larb->base + SMI_LARB_NONSEC_CON(i));
		reg |= F_MMU_EN;
181
		reg |= BANK_SEL(larb->bank[i]);
182 183
		writel(reg, larb->base + SMI_LARB_NONSEC_CON(i));
	}
184 185
}

186 187 188 189 190 191
static void mtk_smi_larb_config_port_mt8173(struct device *dev)
{
	struct mtk_smi_larb *larb = dev_get_drvdata(dev);

	writel(*larb->mmu, larb->base + SMI_LARB_MMU_EN);
}
192

193 194 195 196 197 198 199
static void mtk_smi_larb_config_port_mt8167(struct device *dev)
{
	struct mtk_smi_larb *larb = dev_get_drvdata(dev);

	writel(*larb->mmu, larb->base + MT8167_SMI_LARB_MMU_EN);
}

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
static void mtk_smi_larb_config_port_gen1(struct device *dev)
{
	struct mtk_smi_larb *larb = dev_get_drvdata(dev);
	const struct mtk_smi_larb_gen *larb_gen = larb->larb_gen;
	struct mtk_smi *common = dev_get_drvdata(larb->smi_common_dev);
	int i, m4u_port_id, larb_port_num;
	u32 sec_con_val, reg_val;

	m4u_port_id = larb_gen->port_in_larb[larb->larbid];
	larb_port_num = larb_gen->port_in_larb[larb->larbid + 1]
			- larb_gen->port_in_larb[larb->larbid];

	for (i = 0; i < larb_port_num; i++, m4u_port_id++) {
		if (*larb->mmu & BIT(i)) {
			/* bit[port + 3] controls the virtual or physical */
			sec_con_val = SMI_SECUR_CON_VAL_VIRT(m4u_port_id);
		} else {
			/* do not need to enable m4u for this port */
			continue;
		}
		reg_val = readl(common->smi_ao_base
			+ REG_SMI_SECUR_CON_ADDR(m4u_port_id));
		reg_val &= SMI_SECUR_CON_VAL_MSK(m4u_port_id);
		reg_val |= sec_con_val;
		reg_val |= SMI_SECUR_CON_VAL_DOMAIN(m4u_port_id);
		writel(reg_val,
			common->smi_ao_base
			+ REG_SMI_SECUR_CON_ADDR(m4u_port_id));
	}
}

Yong Wu's avatar
Yong Wu committed
231 232 233 234 235 236 237 238 239 240 241
static void
mtk_smi_larb_unbind(struct device *dev, struct device *master, void *data)
{
	/* Do nothing as the iommu is always enabled. */
}

static const struct component_ops mtk_smi_larb_component_ops = {
	.bind = mtk_smi_larb_bind,
	.unbind = mtk_smi_larb_unbind,
};

242 243
static const struct mtk_smi_larb_gen mtk_smi_larb_mt8173 = {
	/* mt8173 do not need the port in larb */
244
	.config_port = mtk_smi_larb_config_port_mt8173,
245 246
};

247 248 249 250 251
static const struct mtk_smi_larb_gen mtk_smi_larb_mt8167 = {
	/* mt8167 do not need the port in larb */
	.config_port = mtk_smi_larb_config_port_mt8167,
};

252 253 254 255 256 257 258 259
static const struct mtk_smi_larb_gen mtk_smi_larb_mt2701 = {
	.port_in_larb = {
		LARB0_PORT_OFFSET, LARB1_PORT_OFFSET,
		LARB2_PORT_OFFSET, LARB3_PORT_OFFSET
	},
	.config_port = mtk_smi_larb_config_port_gen1,
};

260
static const struct mtk_smi_larb_gen mtk_smi_larb_mt2712 = {
261 262
	.config_port                = mtk_smi_larb_config_port_gen2_general,
	.larb_direct_to_common_mask = BIT(8) | BIT(9),      /* bdpsys */
263 264
};

265 266 267 268 269 270 271
static const struct mtk_smi_larb_gen mtk_smi_larb_mt6779 = {
	.config_port  = mtk_smi_larb_config_port_gen2_general,
	.larb_direct_to_common_mask =
		BIT(4) | BIT(6) | BIT(11) | BIT(12) | BIT(13),
		/* DUMMY | IPU0 | IPU1 | CCU | MDLA */
};

272 273 274 275 276 277 278
static const struct mtk_smi_larb_gen mtk_smi_larb_mt8183 = {
	.has_gals                   = true,
	.config_port                = mtk_smi_larb_config_port_gen2_general,
	.larb_direct_to_common_mask = BIT(2) | BIT(3) | BIT(7),
				      /* IPU0 | IPU1 | CCU */
};

279 280 281 282
static const struct mtk_smi_larb_gen mtk_smi_larb_mt8192 = {
	.config_port                = mtk_smi_larb_config_port_gen2_general,
};

283
static const struct of_device_id mtk_smi_larb_of_ids[] = {
284 285 286 287
	{
		.compatible = "mediatek,mt8167-smi-larb",
		.data = &mtk_smi_larb_mt8167
	},
288 289 290 291 292 293 294 295
	{
		.compatible = "mediatek,mt8173-smi-larb",
		.data = &mtk_smi_larb_mt8173
	},
	{
		.compatible = "mediatek,mt2701-smi-larb",
		.data = &mtk_smi_larb_mt2701
	},
296 297 298 299
	{
		.compatible = "mediatek,mt2712-smi-larb",
		.data = &mtk_smi_larb_mt2712
	},
300 301 302 303
	{
		.compatible = "mediatek,mt6779-smi-larb",
		.data = &mtk_smi_larb_mt6779
	},
304 305 306 307
	{
		.compatible = "mediatek,mt8183-smi-larb",
		.data = &mtk_smi_larb_mt8183
	},
308 309 310 311
	{
		.compatible = "mediatek,mt8192-smi-larb",
		.data = &mtk_smi_larb_mt8192
	},
312 313 314
	{}
};

Yong Wu's avatar
Yong Wu committed
315 316 317 318 319 320 321 322 323 324 325 326
static int mtk_smi_larb_probe(struct platform_device *pdev)
{
	struct mtk_smi_larb *larb;
	struct resource *res;
	struct device *dev = &pdev->dev;
	struct device_node *smi_node;
	struct platform_device *smi_pdev;

	larb = devm_kzalloc(dev, sizeof(*larb), GFP_KERNEL);
	if (!larb)
		return -ENOMEM;

327
	larb->larb_gen = of_device_get_match_data(dev);
Yong Wu's avatar
Yong Wu committed
328 329 330 331 332 333 334 335 336 337 338 339
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	larb->base = devm_ioremap_resource(dev, res);
	if (IS_ERR(larb->base))
		return PTR_ERR(larb->base);

	larb->smi.clk_apb = devm_clk_get(dev, "apb");
	if (IS_ERR(larb->smi.clk_apb))
		return PTR_ERR(larb->smi.clk_apb);

	larb->smi.clk_smi = devm_clk_get(dev, "smi");
	if (IS_ERR(larb->smi.clk_smi))
		return PTR_ERR(larb->smi.clk_smi);
340 341 342 343 344 345 346 347 348

	if (larb->larb_gen->has_gals) {
		/* The larbs may still haven't gals even if the SoC support.*/
		larb->smi.clk_gals0 = devm_clk_get(dev, "gals");
		if (PTR_ERR(larb->smi.clk_gals0) == -ENOENT)
			larb->smi.clk_gals0 = NULL;
		else if (IS_ERR(larb->smi.clk_gals0))
			return PTR_ERR(larb->smi.clk_gals0);
	}
Yong Wu's avatar
Yong Wu committed
349 350 351 352 353 354 355 356 357
	larb->smi.dev = dev;

	smi_node = of_parse_phandle(dev->of_node, "mediatek,smi", 0);
	if (!smi_node)
		return -EINVAL;

	smi_pdev = of_find_device_by_node(smi_node);
	of_node_put(smi_node);
	if (smi_pdev) {
358 359
		if (!platform_get_drvdata(smi_pdev))
			return -EPROBE_DEFER;
Yong Wu's avatar
Yong Wu committed
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
		larb->smi_common_dev = &smi_pdev->dev;
	} else {
		dev_err(dev, "Failed to get the smi_common device\n");
		return -EINVAL;
	}

	pm_runtime_enable(dev);
	platform_set_drvdata(pdev, larb);
	return component_add(dev, &mtk_smi_larb_component_ops);
}

static int mtk_smi_larb_remove(struct platform_device *pdev)
{
	pm_runtime_disable(&pdev->dev);
	component_del(&pdev->dev, &mtk_smi_larb_component_ops);
	return 0;
}

378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
static int __maybe_unused mtk_smi_larb_resume(struct device *dev)
{
	struct mtk_smi_larb *larb = dev_get_drvdata(dev);
	const struct mtk_smi_larb_gen *larb_gen = larb->larb_gen;
	int ret;

	/* Power on smi-common. */
	ret = pm_runtime_get_sync(larb->smi_common_dev);
	if (ret < 0) {
		dev_err(dev, "Failed to pm get for smi-common(%d).\n", ret);
		return ret;
	}

	ret = mtk_smi_clk_enable(&larb->smi);
	if (ret < 0) {
		dev_err(dev, "Failed to enable clock(%d).\n", ret);
		pm_runtime_put_sync(larb->smi_common_dev);
		return ret;
	}

	/* Configure the basic setting for this larb */
	larb_gen->config_port(dev);

	return 0;
}

static int __maybe_unused mtk_smi_larb_suspend(struct device *dev)
{
	struct mtk_smi_larb *larb = dev_get_drvdata(dev);

	mtk_smi_clk_disable(&larb->smi);
	pm_runtime_put_sync(larb->smi_common_dev);
	return 0;
}

static const struct dev_pm_ops smi_larb_pm_ops = {
	SET_RUNTIME_PM_OPS(mtk_smi_larb_suspend, mtk_smi_larb_resume, NULL)
415 416
	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
				     pm_runtime_force_resume)
417 418
};

Yong Wu's avatar
Yong Wu committed
419 420
static struct platform_driver mtk_smi_larb_driver = {
	.probe	= mtk_smi_larb_probe,
421
	.remove	= mtk_smi_larb_remove,
Yong Wu's avatar
Yong Wu committed
422 423 424
	.driver	= {
		.name = "mtk-smi-larb",
		.of_match_table = mtk_smi_larb_of_ids,
425
		.pm             = &smi_larb_pm_ops,
Yong Wu's avatar
Yong Wu committed
426 427 428
	}
};

429 430 431 432 433 434 435 436
static const struct mtk_smi_common_plat mtk_smi_common_gen1 = {
	.gen = MTK_SMI_GEN1,
};

static const struct mtk_smi_common_plat mtk_smi_common_gen2 = {
	.gen = MTK_SMI_GEN2,
};

437 438 439 440 441 442 443
static const struct mtk_smi_common_plat mtk_smi_common_mt6779 = {
	.gen		= MTK_SMI_GEN2,
	.has_gals	= true,
	.bus_sel	= F_MMU1_LARB(1) | F_MMU1_LARB(2) | F_MMU1_LARB(4) |
			  F_MMU1_LARB(5) | F_MMU1_LARB(6) | F_MMU1_LARB(7),
};

444 445 446
static const struct mtk_smi_common_plat mtk_smi_common_mt8183 = {
	.gen      = MTK_SMI_GEN2,
	.has_gals = true,
447 448
	.bus_sel  = F_MMU1_LARB(1) | F_MMU1_LARB(2) | F_MMU1_LARB(5) |
		    F_MMU1_LARB(7),
449 450
};

451 452 453 454 455 456 457
static const struct mtk_smi_common_plat mtk_smi_common_mt8192 = {
	.gen      = MTK_SMI_GEN2,
	.has_gals = true,
	.bus_sel  = F_MMU1_LARB(1) | F_MMU1_LARB(2) | F_MMU1_LARB(5) |
		    F_MMU1_LARB(6),
};

458 459 460
static const struct of_device_id mtk_smi_common_of_ids[] = {
	{
		.compatible = "mediatek,mt8173-smi-common",
461
		.data = &mtk_smi_common_gen2,
462
	},
463 464 465 466
	{
		.compatible = "mediatek,mt8167-smi-common",
		.data = &mtk_smi_common_gen2,
	},
467 468
	{
		.compatible = "mediatek,mt2701-smi-common",
469
		.data = &mtk_smi_common_gen1,
470
	},
471 472
	{
		.compatible = "mediatek,mt2712-smi-common",
473
		.data = &mtk_smi_common_gen2,
474
	},
475 476 477 478
	{
		.compatible = "mediatek,mt6779-smi-common",
		.data = &mtk_smi_common_mt6779,
	},
479 480 481 482
	{
		.compatible = "mediatek,mt8183-smi-common",
		.data = &mtk_smi_common_mt8183,
	},
483 484 485 486
	{
		.compatible = "mediatek,mt8192-smi-common",
		.data = &mtk_smi_common_mt8192,
	},
487 488 489
	{}
};

Yong Wu's avatar
Yong Wu committed
490 491 492 493
static int mtk_smi_common_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct mtk_smi *common;
494
	struct resource *res;
495
	int ret;
Yong Wu's avatar
Yong Wu committed
496 497 498 499 500

	common = devm_kzalloc(dev, sizeof(*common), GFP_KERNEL);
	if (!common)
		return -ENOMEM;
	common->dev = dev;
501
	common->plat = of_device_get_match_data(dev);
Yong Wu's avatar
Yong Wu committed
502 503 504 505 506 507 508 509 510

	common->clk_apb = devm_clk_get(dev, "apb");
	if (IS_ERR(common->clk_apb))
		return PTR_ERR(common->clk_apb);

	common->clk_smi = devm_clk_get(dev, "smi");
	if (IS_ERR(common->clk_smi))
		return PTR_ERR(common->clk_smi);

511 512 513 514 515 516 517 518 519 520
	if (common->plat->has_gals) {
		common->clk_gals0 = devm_clk_get(dev, "gals0");
		if (IS_ERR(common->clk_gals0))
			return PTR_ERR(common->clk_gals0);

		common->clk_gals1 = devm_clk_get(dev, "gals1");
		if (IS_ERR(common->clk_gals1))
			return PTR_ERR(common->clk_gals1);
	}

521 522 523 524 525 526
	/*
	 * for mtk smi gen 1, we need to get the ao(always on) base to config
	 * m4u port, and we need to enable the aync clock for transform the smi
	 * clock into emi clock domain, but for mtk smi gen2, there's no smi ao
	 * base.
	 */
527
	if (common->plat->gen == MTK_SMI_GEN1) {
528 529 530 531 532 533 534 535 536
		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
		common->smi_ao_base = devm_ioremap_resource(dev, res);
		if (IS_ERR(common->smi_ao_base))
			return PTR_ERR(common->smi_ao_base);

		common->clk_async = devm_clk_get(dev, "async");
		if (IS_ERR(common->clk_async))
			return PTR_ERR(common->clk_async);

537 538 539
		ret = clk_prepare_enable(common->clk_async);
		if (ret)
			return ret;
540 541 542 543 544
	} else {
		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
		common->base = devm_ioremap_resource(dev, res);
		if (IS_ERR(common->base))
			return PTR_ERR(common->base);
545
	}
Yong Wu's avatar
Yong Wu committed
546 547 548 549 550 551 552 553 554 555 556
	pm_runtime_enable(dev);
	platform_set_drvdata(pdev, common);
	return 0;
}

static int mtk_smi_common_remove(struct platform_device *pdev)
{
	pm_runtime_disable(&pdev->dev);
	return 0;
}

557 558 559
static int __maybe_unused mtk_smi_common_resume(struct device *dev)
{
	struct mtk_smi *common = dev_get_drvdata(dev);
560
	u32 bus_sel = common->plat->bus_sel;
561 562 563 564 565 566 567
	int ret;

	ret = mtk_smi_clk_enable(common);
	if (ret) {
		dev_err(common->dev, "Failed to enable clock(%d).\n", ret);
		return ret;
	}
568 569 570

	if (common->plat->gen == MTK_SMI_GEN2 && bus_sel)
		writel(bus_sel, common->base + SMI_BUS_SEL);
571 572 573 574 575 576 577 578 579 580 581 582 583
	return 0;
}

static int __maybe_unused mtk_smi_common_suspend(struct device *dev)
{
	struct mtk_smi *common = dev_get_drvdata(dev);

	mtk_smi_clk_disable(common);
	return 0;
}

static const struct dev_pm_ops smi_common_pm_ops = {
	SET_RUNTIME_PM_OPS(mtk_smi_common_suspend, mtk_smi_common_resume, NULL)
584 585
	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
				     pm_runtime_force_resume)
586 587
};

Yong Wu's avatar
Yong Wu committed
588 589 590 591 592 593
static struct platform_driver mtk_smi_common_driver = {
	.probe	= mtk_smi_common_probe,
	.remove = mtk_smi_common_remove,
	.driver	= {
		.name = "mtk-smi-common",
		.of_match_table = mtk_smi_common_of_ids,
594
		.pm             = &smi_common_pm_ops,
Yong Wu's avatar
Yong Wu committed
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
	}
};

static int __init mtk_smi_init(void)
{
	int ret;

	ret = platform_driver_register(&mtk_smi_common_driver);
	if (ret != 0) {
		pr_err("Failed to register SMI driver\n");
		return ret;
	}

	ret = platform_driver_register(&mtk_smi_larb_driver);
	if (ret != 0) {
		pr_err("Failed to register SMI-LARB driver\n");
		goto err_unreg_smi;
	}
	return ret;

err_unreg_smi:
	platform_driver_unregister(&mtk_smi_common_driver);
	return ret;
}
619

620
module_init(mtk_smi_init);