drm/amdgpu: add uvd enc vm functions (v2)
[muen/linux.git] / drivers / memory / mtk-smi.c
1 /*
2  * Copyright (c) 2015-2016 MediaTek Inc.
3  * Author: Yong Wu <yong.wu@mediatek.com>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14 #include <linux/clk.h>
15 #include <linux/component.h>
16 #include <linux/device.h>
17 #include <linux/err.h>
18 #include <linux/io.h>
19 #include <linux/of.h>
20 #include <linux/of_platform.h>
21 #include <linux/platform_device.h>
22 #include <linux/pm_runtime.h>
23 #include <soc/mediatek/smi.h>
24 #include <dt-bindings/memory/mt2701-larb-port.h>
25
26 #define SMI_LARB_MMU_EN         0xf00
27 #define REG_SMI_SECUR_CON_BASE          0x5c0
28
29 /* every register control 8 port, register offset 0x4 */
30 #define REG_SMI_SECUR_CON_OFFSET(id)    (((id) >> 3) << 2)
31 #define REG_SMI_SECUR_CON_ADDR(id)      \
32         (REG_SMI_SECUR_CON_BASE + REG_SMI_SECUR_CON_OFFSET(id))
33
34 /*
35  * every port have 4 bit to control, bit[port + 3] control virtual or physical,
36  * bit[port + 2 : port + 1] control the domain, bit[port] control the security
37  * or non-security.
38  */
39 #define SMI_SECUR_CON_VAL_MSK(id)       (~(0xf << (((id) & 0x7) << 2)))
40 #define SMI_SECUR_CON_VAL_VIRT(id)      BIT((((id) & 0x7) << 2) + 3)
41 /* mt2701 domain should be set to 3 */
42 #define SMI_SECUR_CON_VAL_DOMAIN(id)    (0x3 << ((((id) & 0x7) << 2) + 1))
43
44 struct mtk_smi_larb_gen {
45         int port_in_larb[MTK_LARB_NR_MAX + 1];
46         void (*config_port)(struct device *);
47 };
48
49 struct mtk_smi {
50         struct device                   *dev;
51         struct clk                      *clk_apb, *clk_smi;
52         struct clk                      *clk_async; /*only needed by mt2701*/
53         void __iomem                    *smi_ao_base;
54 };
55
56 struct mtk_smi_larb { /* larb: local arbiter */
57         struct mtk_smi                  smi;
58         void __iomem                    *base;
59         struct device                   *smi_common_dev;
60         const struct mtk_smi_larb_gen   *larb_gen;
61         int                             larbid;
62         u32                             *mmu;
63 };
64
65 enum mtk_smi_gen {
66         MTK_SMI_GEN1,
67         MTK_SMI_GEN2
68 };
69
70 static int mtk_smi_enable(const struct mtk_smi *smi)
71 {
72         int ret;
73
74         ret = pm_runtime_get_sync(smi->dev);
75         if (ret < 0)
76                 return ret;
77
78         ret = clk_prepare_enable(smi->clk_apb);
79         if (ret)
80                 goto err_put_pm;
81
82         ret = clk_prepare_enable(smi->clk_smi);
83         if (ret)
84                 goto err_disable_apb;
85
86         return 0;
87
88 err_disable_apb:
89         clk_disable_unprepare(smi->clk_apb);
90 err_put_pm:
91         pm_runtime_put_sync(smi->dev);
92         return ret;
93 }
94
95 static void mtk_smi_disable(const struct mtk_smi *smi)
96 {
97         clk_disable_unprepare(smi->clk_smi);
98         clk_disable_unprepare(smi->clk_apb);
99         pm_runtime_put_sync(smi->dev);
100 }
101
102 int mtk_smi_larb_get(struct device *larbdev)
103 {
104         struct mtk_smi_larb *larb = dev_get_drvdata(larbdev);
105         const struct mtk_smi_larb_gen *larb_gen = larb->larb_gen;
106         struct mtk_smi *common = dev_get_drvdata(larb->smi_common_dev);
107         int ret;
108
109         /* Enable the smi-common's power and clocks */
110         ret = mtk_smi_enable(common);
111         if (ret)
112                 return ret;
113
114         /* Enable the larb's power and clocks */
115         ret = mtk_smi_enable(&larb->smi);
116         if (ret) {
117                 mtk_smi_disable(common);
118                 return ret;
119         }
120
121         /* Configure the iommu info for this larb */
122         larb_gen->config_port(larbdev);
123
124         return 0;
125 }
126 EXPORT_SYMBOL_GPL(mtk_smi_larb_get);
127
128 void mtk_smi_larb_put(struct device *larbdev)
129 {
130         struct mtk_smi_larb *larb = dev_get_drvdata(larbdev);
131         struct mtk_smi *common = dev_get_drvdata(larb->smi_common_dev);
132
133         /*
134          * Don't de-configure the iommu info for this larb since there may be
135          * several modules in this larb.
136          * The iommu info will be reset after power off.
137          */
138
139         mtk_smi_disable(&larb->smi);
140         mtk_smi_disable(common);
141 }
142 EXPORT_SYMBOL_GPL(mtk_smi_larb_put);
143
144 static int
145 mtk_smi_larb_bind(struct device *dev, struct device *master, void *data)
146 {
147         struct mtk_smi_larb *larb = dev_get_drvdata(dev);
148         struct mtk_smi_iommu *smi_iommu = data;
149         unsigned int         i;
150
151         for (i = 0; i < smi_iommu->larb_nr; i++) {
152                 if (dev == smi_iommu->larb_imu[i].dev) {
153                         /* The 'mmu' may be updated in iommu-attach/detach. */
154                         larb->mmu = &smi_iommu->larb_imu[i].mmu;
155                         return 0;
156                 }
157         }
158         return -ENODEV;
159 }
160
161 static void mtk_smi_larb_config_port(struct device *dev)
162 {
163         struct mtk_smi_larb *larb = dev_get_drvdata(dev);
164
165         writel(*larb->mmu, larb->base + SMI_LARB_MMU_EN);
166 }
167
168
169 static void mtk_smi_larb_config_port_gen1(struct device *dev)
170 {
171         struct mtk_smi_larb *larb = dev_get_drvdata(dev);
172         const struct mtk_smi_larb_gen *larb_gen = larb->larb_gen;
173         struct mtk_smi *common = dev_get_drvdata(larb->smi_common_dev);
174         int i, m4u_port_id, larb_port_num;
175         u32 sec_con_val, reg_val;
176
177         m4u_port_id = larb_gen->port_in_larb[larb->larbid];
178         larb_port_num = larb_gen->port_in_larb[larb->larbid + 1]
179                         - larb_gen->port_in_larb[larb->larbid];
180
181         for (i = 0; i < larb_port_num; i++, m4u_port_id++) {
182                 if (*larb->mmu & BIT(i)) {
183                         /* bit[port + 3] controls the virtual or physical */
184                         sec_con_val = SMI_SECUR_CON_VAL_VIRT(m4u_port_id);
185                 } else {
186                         /* do not need to enable m4u for this port */
187                         continue;
188                 }
189                 reg_val = readl(common->smi_ao_base
190                         + REG_SMI_SECUR_CON_ADDR(m4u_port_id));
191                 reg_val &= SMI_SECUR_CON_VAL_MSK(m4u_port_id);
192                 reg_val |= sec_con_val;
193                 reg_val |= SMI_SECUR_CON_VAL_DOMAIN(m4u_port_id);
194                 writel(reg_val,
195                         common->smi_ao_base
196                         + REG_SMI_SECUR_CON_ADDR(m4u_port_id));
197         }
198 }
199
200 static void
201 mtk_smi_larb_unbind(struct device *dev, struct device *master, void *data)
202 {
203         /* Do nothing as the iommu is always enabled. */
204 }
205
206 static const struct component_ops mtk_smi_larb_component_ops = {
207         .bind = mtk_smi_larb_bind,
208         .unbind = mtk_smi_larb_unbind,
209 };
210
211 static const struct mtk_smi_larb_gen mtk_smi_larb_mt8173 = {
212         /* mt8173 do not need the port in larb */
213         .config_port = mtk_smi_larb_config_port,
214 };
215
216 static const struct mtk_smi_larb_gen mtk_smi_larb_mt2701 = {
217         .port_in_larb = {
218                 LARB0_PORT_OFFSET, LARB1_PORT_OFFSET,
219                 LARB2_PORT_OFFSET, LARB3_PORT_OFFSET
220         },
221         .config_port = mtk_smi_larb_config_port_gen1,
222 };
223
224 static const struct of_device_id mtk_smi_larb_of_ids[] = {
225         {
226                 .compatible = "mediatek,mt8173-smi-larb",
227                 .data = &mtk_smi_larb_mt8173
228         },
229         {
230                 .compatible = "mediatek,mt2701-smi-larb",
231                 .data = &mtk_smi_larb_mt2701
232         },
233         {}
234 };
235
236 static int mtk_smi_larb_probe(struct platform_device *pdev)
237 {
238         struct mtk_smi_larb *larb;
239         struct resource *res;
240         struct device *dev = &pdev->dev;
241         struct device_node *smi_node;
242         struct platform_device *smi_pdev;
243         const struct of_device_id *of_id;
244
245         if (!dev->pm_domain)
246                 return -EPROBE_DEFER;
247
248         of_id = of_match_node(mtk_smi_larb_of_ids, pdev->dev.of_node);
249         if (!of_id)
250                 return -EINVAL;
251
252         larb = devm_kzalloc(dev, sizeof(*larb), GFP_KERNEL);
253         if (!larb)
254                 return -ENOMEM;
255
256         larb->larb_gen = of_id->data;
257         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
258         larb->base = devm_ioremap_resource(dev, res);
259         if (IS_ERR(larb->base))
260                 return PTR_ERR(larb->base);
261
262         larb->smi.clk_apb = devm_clk_get(dev, "apb");
263         if (IS_ERR(larb->smi.clk_apb))
264                 return PTR_ERR(larb->smi.clk_apb);
265
266         larb->smi.clk_smi = devm_clk_get(dev, "smi");
267         if (IS_ERR(larb->smi.clk_smi))
268                 return PTR_ERR(larb->smi.clk_smi);
269         larb->smi.dev = dev;
270
271         smi_node = of_parse_phandle(dev->of_node, "mediatek,smi", 0);
272         if (!smi_node)
273                 return -EINVAL;
274
275         smi_pdev = of_find_device_by_node(smi_node);
276         of_node_put(smi_node);
277         if (smi_pdev) {
278                 larb->smi_common_dev = &smi_pdev->dev;
279         } else {
280                 dev_err(dev, "Failed to get the smi_common device\n");
281                 return -EINVAL;
282         }
283
284         pm_runtime_enable(dev);
285         platform_set_drvdata(pdev, larb);
286         return component_add(dev, &mtk_smi_larb_component_ops);
287 }
288
289 static int mtk_smi_larb_remove(struct platform_device *pdev)
290 {
291         pm_runtime_disable(&pdev->dev);
292         component_del(&pdev->dev, &mtk_smi_larb_component_ops);
293         return 0;
294 }
295
296 static struct platform_driver mtk_smi_larb_driver = {
297         .probe  = mtk_smi_larb_probe,
298         .remove = mtk_smi_larb_remove,
299         .driver = {
300                 .name = "mtk-smi-larb",
301                 .of_match_table = mtk_smi_larb_of_ids,
302         }
303 };
304
305 static const struct of_device_id mtk_smi_common_of_ids[] = {
306         {
307                 .compatible = "mediatek,mt8173-smi-common",
308                 .data = (void *)MTK_SMI_GEN2
309         },
310         {
311                 .compatible = "mediatek,mt2701-smi-common",
312                 .data = (void *)MTK_SMI_GEN1
313         },
314         {}
315 };
316
317 static int mtk_smi_common_probe(struct platform_device *pdev)
318 {
319         struct device *dev = &pdev->dev;
320         struct mtk_smi *common;
321         struct resource *res;
322         const struct of_device_id *of_id;
323         enum mtk_smi_gen smi_gen;
324
325         if (!dev->pm_domain)
326                 return -EPROBE_DEFER;
327
328         common = devm_kzalloc(dev, sizeof(*common), GFP_KERNEL);
329         if (!common)
330                 return -ENOMEM;
331         common->dev = dev;
332
333         common->clk_apb = devm_clk_get(dev, "apb");
334         if (IS_ERR(common->clk_apb))
335                 return PTR_ERR(common->clk_apb);
336
337         common->clk_smi = devm_clk_get(dev, "smi");
338         if (IS_ERR(common->clk_smi))
339                 return PTR_ERR(common->clk_smi);
340
341         of_id = of_match_node(mtk_smi_common_of_ids, pdev->dev.of_node);
342         if (!of_id)
343                 return -EINVAL;
344
345         /*
346          * for mtk smi gen 1, we need to get the ao(always on) base to config
347          * m4u port, and we need to enable the aync clock for transform the smi
348          * clock into emi clock domain, but for mtk smi gen2, there's no smi ao
349          * base.
350          */
351         smi_gen = (enum mtk_smi_gen)of_id->data;
352         if (smi_gen == MTK_SMI_GEN1) {
353                 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
354                 common->smi_ao_base = devm_ioremap_resource(dev, res);
355                 if (IS_ERR(common->smi_ao_base))
356                         return PTR_ERR(common->smi_ao_base);
357
358                 common->clk_async = devm_clk_get(dev, "async");
359                 if (IS_ERR(common->clk_async))
360                         return PTR_ERR(common->clk_async);
361
362                 clk_prepare_enable(common->clk_async);
363         }
364         pm_runtime_enable(dev);
365         platform_set_drvdata(pdev, common);
366         return 0;
367 }
368
369 static int mtk_smi_common_remove(struct platform_device *pdev)
370 {
371         pm_runtime_disable(&pdev->dev);
372         return 0;
373 }
374
375 static struct platform_driver mtk_smi_common_driver = {
376         .probe  = mtk_smi_common_probe,
377         .remove = mtk_smi_common_remove,
378         .driver = {
379                 .name = "mtk-smi-common",
380                 .of_match_table = mtk_smi_common_of_ids,
381         }
382 };
383
384 static int __init mtk_smi_init(void)
385 {
386         int ret;
387
388         ret = platform_driver_register(&mtk_smi_common_driver);
389         if (ret != 0) {
390                 pr_err("Failed to register SMI driver\n");
391                 return ret;
392         }
393
394         ret = platform_driver_register(&mtk_smi_larb_driver);
395         if (ret != 0) {
396                 pr_err("Failed to register SMI-LARB driver\n");
397                 goto err_unreg_smi;
398         }
399         return ret;
400
401 err_unreg_smi:
402         platform_driver_unregister(&mtk_smi_common_driver);
403         return ret;
404 }
405
406 subsys_initcall(mtk_smi_init);