1 /* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/platform_device.h>
24 #include <linux/clk.h>
25 #include <linux/iommu.h>
26 #include <linux/interrupt.h>
27 #include <linux/err.h>
28 #include <linux/slab.h>
30 #include <mach/iommu_hw-8xxx.h>
31 #include <mach/iommu.h>
33 struct iommu_ctx_iter_data
{
41 static struct platform_device
*msm_iommu_root_dev
;
43 static int each_iommu_ctx(struct device
*dev
, void *data
)
45 struct iommu_ctx_iter_data
*res
= data
;
46 struct msm_iommu_ctx_dev
*c
= dev
->platform_data
;
48 if (!res
|| !c
|| !c
->name
|| !res
->name
)
51 if (!strcmp(res
->name
, c
->name
)) {
58 static int each_iommu(struct device
*dev
, void *data
)
60 return device_for_each_child(dev
, data
, each_iommu_ctx
);
63 struct device
*msm_iommu_get_ctx(const char *ctx_name
)
65 struct iommu_ctx_iter_data r
;
68 if (!msm_iommu_root_dev
) {
69 pr_err("No root IOMMU device.\n");
74 found
= device_for_each_child(&msm_iommu_root_dev
->dev
, &r
, each_iommu
);
77 pr_err("Could not find context <%s>\n", ctx_name
);
85 EXPORT_SYMBOL(msm_iommu_get_ctx
);
87 static void msm_iommu_reset(void __iomem
*base
)
93 SET_ESRRESTORE(base
, 0);
97 SET_TESTBUSCR(base
, 0);
99 SET_GLOBAL_TLBIALL(base
, 0);
100 SET_RPU_ACR(base
, 0);
101 SET_TLBLKCRWE(base
, 1);
102 ncb
= GET_NCB(base
)+1;
104 for (ctx
= 0; ctx
< ncb
; ctx
++) {
105 SET_BPRCOSH(base
, ctx
, 0);
106 SET_BPRCISH(base
, ctx
, 0);
107 SET_BPRCNSH(base
, ctx
, 0);
108 SET_BPSHCFG(base
, ctx
, 0);
109 SET_BPMTCFG(base
, ctx
, 0);
110 SET_ACTLR(base
, ctx
, 0);
111 SET_SCTLR(base
, ctx
, 0);
112 SET_FSRRESTORE(base
, ctx
, 0);
113 SET_TTBR0(base
, ctx
, 0);
114 SET_TTBR1(base
, ctx
, 0);
115 SET_TTBCR(base
, ctx
, 0);
116 SET_BFBCR(base
, ctx
, 0);
117 SET_PAR(base
, ctx
, 0);
118 SET_FAR(base
, ctx
, 0);
119 SET_CTX_TLBIALL(base
, ctx
, 0);
120 SET_TLBFLPTER(base
, ctx
, 0);
121 SET_TLBSLPTER(base
, ctx
, 0);
122 SET_TLBLKCR(base
, ctx
, 0);
123 SET_PRRR(base
, ctx
, 0);
124 SET_NMRR(base
, ctx
, 0);
125 SET_CONTEXTIDR(base
, ctx
, 0);
129 static int msm_iommu_probe(struct platform_device
*pdev
)
131 struct resource
*r
, *r2
;
132 struct clk
*iommu_clk
;
133 struct msm_iommu_drvdata
*drvdata
;
134 struct msm_iommu_dev
*iommu_dev
= pdev
->dev
.platform_data
;
135 void __iomem
*regs_base
;
137 int ret
= 0, ncb
, nm2v
, irq
;
139 if (pdev
->id
!= -1) {
140 drvdata
= kzalloc(sizeof(*drvdata
), GFP_KERNEL
);
152 if (iommu_dev
->clk_rate
!= 0) {
153 iommu_clk
= clk_get(&pdev
->dev
, "iommu_clk");
155 if (IS_ERR(iommu_clk
)) {
160 if (iommu_dev
->clk_rate
> 0) {
161 ret
= clk_set_rate(iommu_clk
,
162 iommu_dev
->clk_rate
);
169 ret
= clk_enable(iommu_clk
);
177 r
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
,
184 len
= r
->end
- r
->start
+ 1;
186 r2
= request_mem_region(r
->start
, len
, r
->name
);
188 pr_err("Could not request memory region: "
189 "start=%p, len=%d\n", (void *) r
->start
, len
);
194 regs_base
= ioremap(r2
->start
, len
);
197 pr_err("Could not ioremap: start=%p, len=%d\n",
198 (void *) r2
->start
, len
);
203 irq
= platform_get_irq_byname(pdev
, "secure_irq");
211 if (GET_IDR(regs_base
) == 0) {
212 pr_err("Invalid IDR value detected\n");
217 ret
= request_irq(irq
, msm_iommu_fault_handler
, 0,
218 "msm_iommu_secure_irpt_handler", drvdata
);
220 pr_err("Request IRQ %d failed with ret=%d\n", irq
, ret
);
224 msm_iommu_reset(regs_base
);
225 drvdata
->base
= regs_base
;
228 nm2v
= GET_NM2VCBMT((unsigned long) regs_base
);
229 ncb
= GET_NCB((unsigned long) regs_base
);
231 pr_info("device %s mapped at %p, irq %d with %d ctx banks\n",
232 iommu_dev
->name
, regs_base
, irq
, ncb
+1);
234 platform_set_drvdata(pdev
, drvdata
);
236 msm_iommu_root_dev
= pdev
;
243 release_mem_region(r
->start
, len
);
249 static int msm_iommu_remove(struct platform_device
*pdev
)
251 struct msm_iommu_drvdata
*drv
= NULL
;
253 drv
= platform_get_drvdata(pdev
);
255 memset(drv
, 0, sizeof(struct msm_iommu_drvdata
));
257 platform_set_drvdata(pdev
, NULL
);
262 static int msm_iommu_ctx_probe(struct platform_device
*pdev
)
264 struct msm_iommu_ctx_dev
*c
= pdev
->dev
.platform_data
;
265 struct msm_iommu_drvdata
*drvdata
;
266 struct msm_iommu_ctx_drvdata
*ctx_drvdata
= NULL
;
268 if (!c
|| !pdev
->dev
.parent
) {
273 drvdata
= dev_get_drvdata(pdev
->dev
.parent
);
280 ctx_drvdata
= kzalloc(sizeof(*ctx_drvdata
), GFP_KERNEL
);
285 ctx_drvdata
->num
= c
->num
;
286 ctx_drvdata
->pdev
= pdev
;
288 INIT_LIST_HEAD(&ctx_drvdata
->attached_elm
);
289 platform_set_drvdata(pdev
, ctx_drvdata
);
291 /* Program the M2V tables for this context */
292 for (i
= 0; i
< MAX_NUM_MIDS
; i
++) {
293 int mid
= c
->mids
[i
];
297 SET_M2VCBR_N(drvdata
->base
, mid
, 0);
298 SET_CBACR_N(drvdata
->base
, c
->num
, 0);
301 SET_VMID(drvdata
->base
, mid
, mid
);
303 /* Set the context number for that MID to this context */
304 SET_CBNDX(drvdata
->base
, mid
, c
->num
);
306 /* Set MID associated with this context bank */
307 SET_CBVMID(drvdata
->base
, c
->num
, mid
);
309 /* Set security bit override to be Non-secure */
310 SET_NSCFG(drvdata
->base
, mid
, 3);
313 pr_info("context device %s with bank index %d\n", c
->name
, c
->num
);
321 static int msm_iommu_ctx_remove(struct platform_device
*pdev
)
323 struct msm_iommu_ctx_drvdata
*drv
= NULL
;
324 drv
= platform_get_drvdata(pdev
);
326 memset(drv
, 0, sizeof(struct msm_iommu_ctx_drvdata
));
328 platform_set_drvdata(pdev
, NULL
);
333 static struct platform_driver msm_iommu_driver
= {
337 .probe
= msm_iommu_probe
,
338 .remove
= msm_iommu_remove
,
341 static struct platform_driver msm_iommu_ctx_driver
= {
343 .name
= "msm_iommu_ctx",
345 .probe
= msm_iommu_ctx_probe
,
346 .remove
= msm_iommu_ctx_remove
,
349 static int __init
msm_iommu_driver_init(void)
352 ret
= platform_driver_register(&msm_iommu_driver
);
354 pr_err("Failed to register IOMMU driver\n");
358 ret
= platform_driver_register(&msm_iommu_ctx_driver
);
360 pr_err("Failed to register IOMMU context driver\n");
368 static void __exit
msm_iommu_driver_exit(void)
370 platform_driver_unregister(&msm_iommu_ctx_driver
);
371 platform_driver_unregister(&msm_iommu_driver
);
374 subsys_initcall(msm_iommu_driver_init
);
375 module_exit(msm_iommu_driver_exit
);
377 MODULE_LICENSE("GPL v2");
378 MODULE_AUTHOR("Stepan Moskovchenko <stepanm@codeaurora.org>");