omap: iommu: PREFETCH_IOTLB cleanup
[linux-2.6.git] / drivers / iommu / omap-iommu.c
1 /*
2  * omap iommu: tlb and pagetable primitives
3  *
4  * Copyright (C) 2008-2010 Nokia Corporation
5  *
6  * Written by Hiroshi DOYU <Hiroshi.DOYU@nokia.com>,
7  *              Paul Mundt and Toshihiro Kobayashi
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13
14 #include <linux/err.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/interrupt.h>
18 #include <linux/ioport.h>
19 #include <linux/clk.h>
20 #include <linux/platform_device.h>
21
22 #include <asm/cacheflush.h>
23
24 #include <plat/iommu.h>
25
26 #include <plat/iopgtable.h>
27
28 #define for_each_iotlb_cr(obj, n, __i, cr)                              \
29         for (__i = 0;                                                   \
30              (__i < (n)) && (cr = __iotlb_read_cr((obj), __i), true);   \
31              __i++)
32
33 /* accommodate the difference between omap1 and omap2/3 */
34 static const struct iommu_functions *arch_iommu;
35
36 static struct platform_driver omap_iommu_driver;
37 static struct kmem_cache *iopte_cachep;
38
39 /**
40  * install_iommu_arch - Install archtecure specific iommu functions
41  * @ops:        a pointer to architecture specific iommu functions
42  *
43  * There are several kind of iommu algorithm(tlb, pagetable) among
44  * omap series. This interface installs such an iommu algorighm.
45  **/
46 int install_iommu_arch(const struct iommu_functions *ops)
47 {
48         if (arch_iommu)
49                 return -EBUSY;
50
51         arch_iommu = ops;
52         return 0;
53 }
54 EXPORT_SYMBOL_GPL(install_iommu_arch);
55
56 /**
57  * uninstall_iommu_arch - Uninstall archtecure specific iommu functions
58  * @ops:        a pointer to architecture specific iommu functions
59  *
60  * This interface uninstalls the iommu algorighm installed previously.
61  **/
62 void uninstall_iommu_arch(const struct iommu_functions *ops)
63 {
64         if (arch_iommu != ops)
65                 pr_err("%s: not your arch\n", __func__);
66
67         arch_iommu = NULL;
68 }
69 EXPORT_SYMBOL_GPL(uninstall_iommu_arch);
70
71 /**
72  * iommu_save_ctx - Save registers for pm off-mode support
73  * @obj:        target iommu
74  **/
75 void iommu_save_ctx(struct iommu *obj)
76 {
77         arch_iommu->save_ctx(obj);
78 }
79 EXPORT_SYMBOL_GPL(iommu_save_ctx);
80
81 /**
82  * iommu_restore_ctx - Restore registers for pm off-mode support
83  * @obj:        target iommu
84  **/
85 void iommu_restore_ctx(struct iommu *obj)
86 {
87         arch_iommu->restore_ctx(obj);
88 }
89 EXPORT_SYMBOL_GPL(iommu_restore_ctx);
90
91 /**
92  * iommu_arch_version - Return running iommu arch version
93  **/
94 u32 iommu_arch_version(void)
95 {
96         return arch_iommu->version;
97 }
98 EXPORT_SYMBOL_GPL(iommu_arch_version);
99
100 static int iommu_enable(struct iommu *obj)
101 {
102         int err;
103
104         if (!obj)
105                 return -EINVAL;
106
107         if (!arch_iommu)
108                 return -ENODEV;
109
110         clk_enable(obj->clk);
111
112         err = arch_iommu->enable(obj);
113
114         clk_disable(obj->clk);
115         return err;
116 }
117
118 static void iommu_disable(struct iommu *obj)
119 {
120         if (!obj)
121                 return;
122
123         clk_enable(obj->clk);
124
125         arch_iommu->disable(obj);
126
127         clk_disable(obj->clk);
128 }
129
130 /*
131  *      TLB operations
132  */
133 void iotlb_cr_to_e(struct cr_regs *cr, struct iotlb_entry *e)
134 {
135         BUG_ON(!cr || !e);
136
137         arch_iommu->cr_to_e(cr, e);
138 }
139 EXPORT_SYMBOL_GPL(iotlb_cr_to_e);
140
141 static inline int iotlb_cr_valid(struct cr_regs *cr)
142 {
143         if (!cr)
144                 return -EINVAL;
145
146         return arch_iommu->cr_valid(cr);
147 }
148
149 static inline struct cr_regs *iotlb_alloc_cr(struct iommu *obj,
150                                              struct iotlb_entry *e)
151 {
152         if (!e)
153                 return NULL;
154
155         return arch_iommu->alloc_cr(obj, e);
156 }
157
158 static u32 iotlb_cr_to_virt(struct cr_regs *cr)
159 {
160         return arch_iommu->cr_to_virt(cr);
161 }
162
163 static u32 get_iopte_attr(struct iotlb_entry *e)
164 {
165         return arch_iommu->get_pte_attr(e);
166 }
167
168 static u32 iommu_report_fault(struct iommu *obj, u32 *da)
169 {
170         return arch_iommu->fault_isr(obj, da);
171 }
172
173 static void iotlb_lock_get(struct iommu *obj, struct iotlb_lock *l)
174 {
175         u32 val;
176
177         val = iommu_read_reg(obj, MMU_LOCK);
178
179         l->base = MMU_LOCK_BASE(val);
180         l->vict = MMU_LOCK_VICT(val);
181
182 }
183
184 static void iotlb_lock_set(struct iommu *obj, struct iotlb_lock *l)
185 {
186         u32 val;
187
188         val = (l->base << MMU_LOCK_BASE_SHIFT);
189         val |= (l->vict << MMU_LOCK_VICT_SHIFT);
190
191         iommu_write_reg(obj, val, MMU_LOCK);
192 }
193
194 static void iotlb_read_cr(struct iommu *obj, struct cr_regs *cr)
195 {
196         arch_iommu->tlb_read_cr(obj, cr);
197 }
198
199 static void iotlb_load_cr(struct iommu *obj, struct cr_regs *cr)
200 {
201         arch_iommu->tlb_load_cr(obj, cr);
202
203         iommu_write_reg(obj, 1, MMU_FLUSH_ENTRY);
204         iommu_write_reg(obj, 1, MMU_LD_TLB);
205 }
206
207 /**
208  * iotlb_dump_cr - Dump an iommu tlb entry into buf
209  * @obj:        target iommu
210  * @cr:         contents of cam and ram register
211  * @buf:        output buffer
212  **/
213 static inline ssize_t iotlb_dump_cr(struct iommu *obj, struct cr_regs *cr,
214                                     char *buf)
215 {
216         BUG_ON(!cr || !buf);
217
218         return arch_iommu->dump_cr(obj, cr, buf);
219 }
220
221 /* only used in iotlb iteration for-loop */
222 static struct cr_regs __iotlb_read_cr(struct iommu *obj, int n)
223 {
224         struct cr_regs cr;
225         struct iotlb_lock l;
226
227         iotlb_lock_get(obj, &l);
228         l.vict = n;
229         iotlb_lock_set(obj, &l);
230         iotlb_read_cr(obj, &cr);
231
232         return cr;
233 }
234
235 /**
236  * load_iotlb_entry - Set an iommu tlb entry
237  * @obj:        target iommu
238  * @e:          an iommu tlb entry info
239  **/
240 #ifdef PREFETCH_IOTLB
241 static int load_iotlb_entry(struct iommu *obj, struct iotlb_entry *e)
242 {
243         int err = 0;
244         struct iotlb_lock l;
245         struct cr_regs *cr;
246
247         if (!obj || !obj->nr_tlb_entries || !e)
248                 return -EINVAL;
249
250         clk_enable(obj->clk);
251
252         iotlb_lock_get(obj, &l);
253         if (l.base == obj->nr_tlb_entries) {
254                 dev_warn(obj->dev, "%s: preserve entries full\n", __func__);
255                 err = -EBUSY;
256                 goto out;
257         }
258         if (!e->prsvd) {
259                 int i;
260                 struct cr_regs tmp;
261
262                 for_each_iotlb_cr(obj, obj->nr_tlb_entries, i, tmp)
263                         if (!iotlb_cr_valid(&tmp))
264                                 break;
265
266                 if (i == obj->nr_tlb_entries) {
267                         dev_dbg(obj->dev, "%s: full: no entry\n", __func__);
268                         err = -EBUSY;
269                         goto out;
270                 }
271
272                 iotlb_lock_get(obj, &l);
273         } else {
274                 l.vict = l.base;
275                 iotlb_lock_set(obj, &l);
276         }
277
278         cr = iotlb_alloc_cr(obj, e);
279         if (IS_ERR(cr)) {
280                 clk_disable(obj->clk);
281                 return PTR_ERR(cr);
282         }
283
284         iotlb_load_cr(obj, cr);
285         kfree(cr);
286
287         if (e->prsvd)
288                 l.base++;
289         /* increment victim for next tlb load */
290         if (++l.vict == obj->nr_tlb_entries)
291                 l.vict = l.base;
292         iotlb_lock_set(obj, &l);
293 out:
294         clk_disable(obj->clk);
295         return err;
296 }
297
298 #else /* !PREFETCH_IOTLB */
299
300 static int load_iotlb_entry(struct iommu *obj, struct iotlb_entry *e)
301 {
302         return 0;
303 }
304
305 #endif /* !PREFETCH_IOTLB */
306
307 static int prefetch_iotlb_entry(struct iommu *obj, struct iotlb_entry *e)
308 {
309         return load_iotlb_entry(obj, e);
310 }
311
312 /**
313  * flush_iotlb_page - Clear an iommu tlb entry
314  * @obj:        target iommu
315  * @da:         iommu device virtual address
316  *
317  * Clear an iommu tlb entry which includes 'da' address.
318  **/
319 static void flush_iotlb_page(struct iommu *obj, u32 da)
320 {
321         int i;
322         struct cr_regs cr;
323
324         clk_enable(obj->clk);
325
326         for_each_iotlb_cr(obj, obj->nr_tlb_entries, i, cr) {
327                 u32 start;
328                 size_t bytes;
329
330                 if (!iotlb_cr_valid(&cr))
331                         continue;
332
333                 start = iotlb_cr_to_virt(&cr);
334                 bytes = iopgsz_to_bytes(cr.cam & 3);
335
336                 if ((start <= da) && (da < start + bytes)) {
337                         dev_dbg(obj->dev, "%s: %08x<=%08x(%x)\n",
338                                 __func__, start, da, bytes);
339                         iotlb_load_cr(obj, &cr);
340                         iommu_write_reg(obj, 1, MMU_FLUSH_ENTRY);
341                 }
342         }
343         clk_disable(obj->clk);
344
345         if (i == obj->nr_tlb_entries)
346                 dev_dbg(obj->dev, "%s: no page for %08x\n", __func__, da);
347 }
348
349 /**
350  * flush_iotlb_range - Clear an iommu tlb entries
351  * @obj:        target iommu
352  * @start:      iommu device virtual address(start)
353  * @end:        iommu device virtual address(end)
354  *
355  * Clear an iommu tlb entry which includes 'da' address.
356  **/
357 void flush_iotlb_range(struct iommu *obj, u32 start, u32 end)
358 {
359         u32 da = start;
360
361         while (da < end) {
362                 flush_iotlb_page(obj, da);
363                 /* FIXME: Optimize for multiple page size */
364                 da += IOPTE_SIZE;
365         }
366 }
367 EXPORT_SYMBOL_GPL(flush_iotlb_range);
368
369 /**
370  * flush_iotlb_all - Clear all iommu tlb entries
371  * @obj:        target iommu
372  **/
373 static void flush_iotlb_all(struct iommu *obj)
374 {
375         struct iotlb_lock l;
376
377         clk_enable(obj->clk);
378
379         l.base = 0;
380         l.vict = 0;
381         iotlb_lock_set(obj, &l);
382
383         iommu_write_reg(obj, 1, MMU_GFLUSH);
384
385         clk_disable(obj->clk);
386 }
387
388 /**
389  * iommu_set_twl - enable/disable table walking logic
390  * @obj:        target iommu
391  * @on:         enable/disable
392  *
393  * Function used to enable/disable TWL. If one wants to work
394  * exclusively with locked TLB entries and receive notifications
395  * for TLB miss then call this function to disable TWL.
396  */
397 void iommu_set_twl(struct iommu *obj, bool on)
398 {
399         clk_enable(obj->clk);
400         arch_iommu->set_twl(obj, on);
401         clk_disable(obj->clk);
402 }
403 EXPORT_SYMBOL_GPL(iommu_set_twl);
404
405 #if defined(CONFIG_OMAP_IOMMU_DEBUG_MODULE)
406
407 ssize_t iommu_dump_ctx(struct iommu *obj, char *buf, ssize_t bytes)
408 {
409         if (!obj || !buf)
410                 return -EINVAL;
411
412         clk_enable(obj->clk);
413
414         bytes = arch_iommu->dump_ctx(obj, buf, bytes);
415
416         clk_disable(obj->clk);
417
418         return bytes;
419 }
420 EXPORT_SYMBOL_GPL(iommu_dump_ctx);
421
422 static int __dump_tlb_entries(struct iommu *obj, struct cr_regs *crs, int num)
423 {
424         int i;
425         struct iotlb_lock saved;
426         struct cr_regs tmp;
427         struct cr_regs *p = crs;
428
429         clk_enable(obj->clk);
430         iotlb_lock_get(obj, &saved);
431
432         for_each_iotlb_cr(obj, num, i, tmp) {
433                 if (!iotlb_cr_valid(&tmp))
434                         continue;
435                 *p++ = tmp;
436         }
437
438         iotlb_lock_set(obj, &saved);
439         clk_disable(obj->clk);
440
441         return  p - crs;
442 }
443
444 /**
445  * dump_tlb_entries - dump cr arrays to given buffer
446  * @obj:        target iommu
447  * @buf:        output buffer
448  **/
449 size_t dump_tlb_entries(struct iommu *obj, char *buf, ssize_t bytes)
450 {
451         int i, num;
452         struct cr_regs *cr;
453         char *p = buf;
454
455         num = bytes / sizeof(*cr);
456         num = min(obj->nr_tlb_entries, num);
457
458         cr = kcalloc(num, sizeof(*cr), GFP_KERNEL);
459         if (!cr)
460                 return 0;
461
462         num = __dump_tlb_entries(obj, cr, num);
463         for (i = 0; i < num; i++)
464                 p += iotlb_dump_cr(obj, cr + i, p);
465         kfree(cr);
466
467         return p - buf;
468 }
469 EXPORT_SYMBOL_GPL(dump_tlb_entries);
470
471 int foreach_iommu_device(void *data, int (*fn)(struct device *, void *))
472 {
473         return driver_for_each_device(&omap_iommu_driver.driver,
474                                       NULL, data, fn);
475 }
476 EXPORT_SYMBOL_GPL(foreach_iommu_device);
477
478 #endif /* CONFIG_OMAP_IOMMU_DEBUG_MODULE */
479
480 /*
481  *      H/W pagetable operations
482  */
483 static void flush_iopgd_range(u32 *first, u32 *last)
484 {
485         /* FIXME: L2 cache should be taken care of if it exists */
486         do {
487                 asm("mcr        p15, 0, %0, c7, c10, 1 @ flush_pgd"
488                     : : "r" (first));
489                 first += L1_CACHE_BYTES / sizeof(*first);
490         } while (first <= last);
491 }
492
493 static void flush_iopte_range(u32 *first, u32 *last)
494 {
495         /* FIXME: L2 cache should be taken care of if it exists */
496         do {
497                 asm("mcr        p15, 0, %0, c7, c10, 1 @ flush_pte"
498                     : : "r" (first));
499                 first += L1_CACHE_BYTES / sizeof(*first);
500         } while (first <= last);
501 }
502
503 static void iopte_free(u32 *iopte)
504 {
505         /* Note: freed iopte's must be clean ready for re-use */
506         kmem_cache_free(iopte_cachep, iopte);
507 }
508
509 static u32 *iopte_alloc(struct iommu *obj, u32 *iopgd, u32 da)
510 {
511         u32 *iopte;
512
513         /* a table has already existed */
514         if (*iopgd)
515                 goto pte_ready;
516
517         /*
518          * do the allocation outside the page table lock
519          */
520         spin_unlock(&obj->page_table_lock);
521         iopte = kmem_cache_zalloc(iopte_cachep, GFP_KERNEL);
522         spin_lock(&obj->page_table_lock);
523
524         if (!*iopgd) {
525                 if (!iopte)
526                         return ERR_PTR(-ENOMEM);
527
528                 *iopgd = virt_to_phys(iopte) | IOPGD_TABLE;
529                 flush_iopgd_range(iopgd, iopgd);
530
531                 dev_vdbg(obj->dev, "%s: a new pte:%p\n", __func__, iopte);
532         } else {
533                 /* We raced, free the reduniovant table */
534                 iopte_free(iopte);
535         }
536
537 pte_ready:
538         iopte = iopte_offset(iopgd, da);
539
540         dev_vdbg(obj->dev,
541                  "%s: da:%08x pgd:%p *pgd:%08x pte:%p *pte:%08x\n",
542                  __func__, da, iopgd, *iopgd, iopte, *iopte);
543
544         return iopte;
545 }
546
547 static int iopgd_alloc_section(struct iommu *obj, u32 da, u32 pa, u32 prot)
548 {
549         u32 *iopgd = iopgd_offset(obj, da);
550
551         if ((da | pa) & ~IOSECTION_MASK) {
552                 dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
553                         __func__, da, pa, IOSECTION_SIZE);
554                 return -EINVAL;
555         }
556
557         *iopgd = (pa & IOSECTION_MASK) | prot | IOPGD_SECTION;
558         flush_iopgd_range(iopgd, iopgd);
559         return 0;
560 }
561
562 static int iopgd_alloc_super(struct iommu *obj, u32 da, u32 pa, u32 prot)
563 {
564         u32 *iopgd = iopgd_offset(obj, da);
565         int i;
566
567         if ((da | pa) & ~IOSUPER_MASK) {
568                 dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
569                         __func__, da, pa, IOSUPER_SIZE);
570                 return -EINVAL;
571         }
572
573         for (i = 0; i < 16; i++)
574                 *(iopgd + i) = (pa & IOSUPER_MASK) | prot | IOPGD_SUPER;
575         flush_iopgd_range(iopgd, iopgd + 15);
576         return 0;
577 }
578
579 static int iopte_alloc_page(struct iommu *obj, u32 da, u32 pa, u32 prot)
580 {
581         u32 *iopgd = iopgd_offset(obj, da);
582         u32 *iopte = iopte_alloc(obj, iopgd, da);
583
584         if (IS_ERR(iopte))
585                 return PTR_ERR(iopte);
586
587         *iopte = (pa & IOPAGE_MASK) | prot | IOPTE_SMALL;
588         flush_iopte_range(iopte, iopte);
589
590         dev_vdbg(obj->dev, "%s: da:%08x pa:%08x pte:%p *pte:%08x\n",
591                  __func__, da, pa, iopte, *iopte);
592
593         return 0;
594 }
595
596 static int iopte_alloc_large(struct iommu *obj, u32 da, u32 pa, u32 prot)
597 {
598         u32 *iopgd = iopgd_offset(obj, da);
599         u32 *iopte = iopte_alloc(obj, iopgd, da);
600         int i;
601
602         if ((da | pa) & ~IOLARGE_MASK) {
603                 dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
604                         __func__, da, pa, IOLARGE_SIZE);
605                 return -EINVAL;
606         }
607
608         if (IS_ERR(iopte))
609                 return PTR_ERR(iopte);
610
611         for (i = 0; i < 16; i++)
612                 *(iopte + i) = (pa & IOLARGE_MASK) | prot | IOPTE_LARGE;
613         flush_iopte_range(iopte, iopte + 15);
614         return 0;
615 }
616
617 static int iopgtable_store_entry_core(struct iommu *obj, struct iotlb_entry *e)
618 {
619         int (*fn)(struct iommu *, u32, u32, u32);
620         u32 prot;
621         int err;
622
623         if (!obj || !e)
624                 return -EINVAL;
625
626         switch (e->pgsz) {
627         case MMU_CAM_PGSZ_16M:
628                 fn = iopgd_alloc_super;
629                 break;
630         case MMU_CAM_PGSZ_1M:
631                 fn = iopgd_alloc_section;
632                 break;
633         case MMU_CAM_PGSZ_64K:
634                 fn = iopte_alloc_large;
635                 break;
636         case MMU_CAM_PGSZ_4K:
637                 fn = iopte_alloc_page;
638                 break;
639         default:
640                 fn = NULL;
641                 BUG();
642                 break;
643         }
644
645         prot = get_iopte_attr(e);
646
647         spin_lock(&obj->page_table_lock);
648         err = fn(obj, e->da, e->pa, prot);
649         spin_unlock(&obj->page_table_lock);
650
651         return err;
652 }
653
654 /**
655  * iopgtable_store_entry - Make an iommu pte entry
656  * @obj:        target iommu
657  * @e:          an iommu tlb entry info
658  **/
659 int iopgtable_store_entry(struct iommu *obj, struct iotlb_entry *e)
660 {
661         int err;
662
663         flush_iotlb_page(obj, e->da);
664         err = iopgtable_store_entry_core(obj, e);
665         if (!err)
666                 prefetch_iotlb_entry(obj, e);
667         return err;
668 }
669 EXPORT_SYMBOL_GPL(iopgtable_store_entry);
670
671 /**
672  * iopgtable_lookup_entry - Lookup an iommu pte entry
673  * @obj:        target iommu
674  * @da:         iommu device virtual address
675  * @ppgd:       iommu pgd entry pointer to be returned
676  * @ppte:       iommu pte entry pointer to be returned
677  **/
678 static void
679 iopgtable_lookup_entry(struct omap_iommu *obj, u32 da, u32 **ppgd, u32 **ppte)
680 {
681         u32 *iopgd, *iopte = NULL;
682
683         iopgd = iopgd_offset(obj, da);
684         if (!*iopgd)
685                 goto out;
686
687         if (iopgd_is_table(*iopgd))
688                 iopte = iopte_offset(iopgd, da);
689 out:
690         *ppgd = iopgd;
691         *ppte = iopte;
692 }
693
694 static size_t iopgtable_clear_entry_core(struct iommu *obj, u32 da)
695 {
696         size_t bytes;
697         u32 *iopgd = iopgd_offset(obj, da);
698         int nent = 1;
699
700         if (!*iopgd)
701                 return 0;
702
703         if (iopgd_is_table(*iopgd)) {
704                 int i;
705                 u32 *iopte = iopte_offset(iopgd, da);
706
707                 bytes = IOPTE_SIZE;
708                 if (*iopte & IOPTE_LARGE) {
709                         nent *= 16;
710                         /* rewind to the 1st entry */
711                         iopte = iopte_offset(iopgd, (da & IOLARGE_MASK));
712                 }
713                 bytes *= nent;
714                 memset(iopte, 0, nent * sizeof(*iopte));
715                 flush_iopte_range(iopte, iopte + (nent - 1) * sizeof(*iopte));
716
717                 /*
718                  * do table walk to check if this table is necessary or not
719                  */
720                 iopte = iopte_offset(iopgd, 0);
721                 for (i = 0; i < PTRS_PER_IOPTE; i++)
722                         if (iopte[i])
723                                 goto out;
724
725                 iopte_free(iopte);
726                 nent = 1; /* for the next L1 entry */
727         } else {
728                 bytes = IOPGD_SIZE;
729                 if ((*iopgd & IOPGD_SUPER) == IOPGD_SUPER) {
730                         nent *= 16;
731                         /* rewind to the 1st entry */
732                         iopgd = iopgd_offset(obj, (da & IOSUPER_MASK));
733                 }
734                 bytes *= nent;
735         }
736         memset(iopgd, 0, nent * sizeof(*iopgd));
737         flush_iopgd_range(iopgd, iopgd + (nent - 1) * sizeof(*iopgd));
738 out:
739         return bytes;
740 }
741
742 /**
743  * iopgtable_clear_entry - Remove an iommu pte entry
744  * @obj:        target iommu
745  * @da:         iommu device virtual address
746  **/
747 static size_t iopgtable_clear_entry(struct iommu *obj, u32 da)
748 {
749         size_t bytes;
750
751         spin_lock(&obj->page_table_lock);
752
753         bytes = iopgtable_clear_entry_core(obj, da);
754         flush_iotlb_page(obj, da);
755
756         spin_unlock(&obj->page_table_lock);
757
758         return bytes;
759 }
760
761 static void iopgtable_clear_entry_all(struct iommu *obj)
762 {
763         int i;
764
765         spin_lock(&obj->page_table_lock);
766
767         for (i = 0; i < PTRS_PER_IOPGD; i++) {
768                 u32 da;
769                 u32 *iopgd;
770
771                 da = i << IOPGD_SHIFT;
772                 iopgd = iopgd_offset(obj, da);
773
774                 if (!*iopgd)
775                         continue;
776
777                 if (iopgd_is_table(*iopgd))
778                         iopte_free(iopte_offset(iopgd, 0));
779
780                 *iopgd = 0;
781                 flush_iopgd_range(iopgd, iopgd);
782         }
783
784         flush_iotlb_all(obj);
785
786         spin_unlock(&obj->page_table_lock);
787 }
788
789 /*
790  *      Device IOMMU generic operations
791  */
792 static irqreturn_t iommu_fault_handler(int irq, void *data)
793 {
794         u32 da, errs;
795         u32 *iopgd, *iopte;
796         struct iommu *obj = data;
797
798         if (!obj->refcount)
799                 return IRQ_NONE;
800
801         clk_enable(obj->clk);
802         errs = iommu_report_fault(obj, &da);
803         clk_disable(obj->clk);
804         if (errs == 0)
805                 return IRQ_HANDLED;
806
807         /* Fault callback or TLB/PTE Dynamic loading */
808         if (obj->isr && !obj->isr(obj, da, errs, obj->isr_priv))
809                 return IRQ_HANDLED;
810
811         iommu_disable(obj);
812
813         iopgd = iopgd_offset(obj, da);
814
815         if (!iopgd_is_table(*iopgd)) {
816                 dev_err(obj->dev, "%s: errs:0x%08x da:0x%08x pgd:0x%p "
817                         "*pgd:px%08x\n", obj->name, errs, da, iopgd, *iopgd);
818                 return IRQ_NONE;
819         }
820
821         iopte = iopte_offset(iopgd, da);
822
823         dev_err(obj->dev, "%s: errs:0x%08x da:0x%08x pgd:0x%p *pgd:0x%08x "
824                 "pte:0x%p *pte:0x%08x\n", obj->name, errs, da, iopgd, *iopgd,
825                 iopte, *iopte);
826
827         return IRQ_NONE;
828 }
829
830 static int device_match_by_alias(struct device *dev, void *data)
831 {
832         struct iommu *obj = to_iommu(dev);
833         const char *name = data;
834
835         pr_debug("%s: %s %s\n", __func__, obj->name, name);
836
837         return strcmp(obj->name, name) == 0;
838 }
839
840 /**
841  * iommu_set_da_range - Set a valid device address range
842  * @obj:                target iommu
843  * @start               Start of valid range
844  * @end                 End of valid range
845  **/
846 int iommu_set_da_range(struct iommu *obj, u32 start, u32 end)
847 {
848
849         if (!obj)
850                 return -EFAULT;
851
852         if (end < start || !PAGE_ALIGN(start | end))
853                 return -EINVAL;
854
855         obj->da_start = start;
856         obj->da_end = end;
857
858         return 0;
859 }
860 EXPORT_SYMBOL_GPL(iommu_set_da_range);
861
862 /**
863  * iommu_get - Get iommu handler
864  * @name:       target iommu name
865  **/
866 struct iommu *iommu_get(const char *name)
867 {
868         int err = -ENOMEM;
869         struct device *dev;
870         struct iommu *obj;
871
872         dev = driver_find_device(&omap_iommu_driver.driver, NULL, (void *)name,
873                                  device_match_by_alias);
874         if (!dev)
875                 return ERR_PTR(-ENODEV);
876
877         obj = to_iommu(dev);
878
879         mutex_lock(&obj->iommu_lock);
880
881         if (obj->refcount++ == 0) {
882                 err = iommu_enable(obj);
883                 if (err)
884                         goto err_enable;
885                 flush_iotlb_all(obj);
886         }
887
888         if (!try_module_get(obj->owner))
889                 goto err_module;
890
891         mutex_unlock(&obj->iommu_lock);
892
893         dev_dbg(obj->dev, "%s: %s\n", __func__, obj->name);
894         return obj;
895
896 err_module:
897         if (obj->refcount == 1)
898                 iommu_disable(obj);
899 err_enable:
900         obj->refcount--;
901         mutex_unlock(&obj->iommu_lock);
902         return ERR_PTR(err);
903 }
904 EXPORT_SYMBOL_GPL(iommu_get);
905
906 /**
907  * iommu_put - Put back iommu handler
908  * @obj:        target iommu
909  **/
910 void iommu_put(struct iommu *obj)
911 {
912         if (!obj || IS_ERR(obj))
913                 return;
914
915         mutex_lock(&obj->iommu_lock);
916
917         if (--obj->refcount == 0)
918                 iommu_disable(obj);
919
920         module_put(obj->owner);
921
922         mutex_unlock(&obj->iommu_lock);
923
924         dev_dbg(obj->dev, "%s: %s\n", __func__, obj->name);
925 }
926 EXPORT_SYMBOL_GPL(iommu_put);
927
928 int iommu_set_isr(const char *name,
929                   int (*isr)(struct iommu *obj, u32 da, u32 iommu_errs,
930                              void *priv),
931                   void *isr_priv)
932 {
933         struct device *dev;
934         struct iommu *obj;
935
936         dev = driver_find_device(&omap_iommu_driver.driver, NULL, (void *)name,
937                                  device_match_by_alias);
938         if (!dev)
939                 return -ENODEV;
940
941         obj = to_iommu(dev);
942         mutex_lock(&obj->iommu_lock);
943         if (obj->refcount != 0) {
944                 mutex_unlock(&obj->iommu_lock);
945                 return -EBUSY;
946         }
947         obj->isr = isr;
948         obj->isr_priv = isr_priv;
949         mutex_unlock(&obj->iommu_lock);
950
951         return 0;
952 }
953 EXPORT_SYMBOL_GPL(iommu_set_isr);
954
955 /*
956  *      OMAP Device MMU(IOMMU) detection
957  */
958 static int __devinit omap_iommu_probe(struct platform_device *pdev)
959 {
960         int err = -ENODEV;
961         void *p;
962         int irq;
963         struct iommu *obj;
964         struct resource *res;
965         struct iommu_platform_data *pdata = pdev->dev.platform_data;
966
967         if (pdev->num_resources != 2)
968                 return -EINVAL;
969
970         obj = kzalloc(sizeof(*obj) + MMU_REG_SIZE, GFP_KERNEL);
971         if (!obj)
972                 return -ENOMEM;
973
974         obj->clk = clk_get(&pdev->dev, pdata->clk_name);
975         if (IS_ERR(obj->clk))
976                 goto err_clk;
977
978         obj->nr_tlb_entries = pdata->nr_tlb_entries;
979         obj->name = pdata->name;
980         obj->dev = &pdev->dev;
981         obj->ctx = (void *)obj + sizeof(*obj);
982         obj->da_start = pdata->da_start;
983         obj->da_end = pdata->da_end;
984
985         mutex_init(&obj->iommu_lock);
986         mutex_init(&obj->mmap_lock);
987         spin_lock_init(&obj->page_table_lock);
988         INIT_LIST_HEAD(&obj->mmap);
989
990         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
991         if (!res) {
992                 err = -ENODEV;
993                 goto err_mem;
994         }
995
996         res = request_mem_region(res->start, resource_size(res),
997                                  dev_name(&pdev->dev));
998         if (!res) {
999                 err = -EIO;
1000                 goto err_mem;
1001         }
1002
1003         obj->regbase = ioremap(res->start, resource_size(res));
1004         if (!obj->regbase) {
1005                 err = -ENOMEM;
1006                 goto err_ioremap;
1007         }
1008
1009         irq = platform_get_irq(pdev, 0);
1010         if (irq < 0) {
1011                 err = -ENODEV;
1012                 goto err_irq;
1013         }
1014         err = request_irq(irq, iommu_fault_handler, IRQF_SHARED,
1015                           dev_name(&pdev->dev), obj);
1016         if (err < 0)
1017                 goto err_irq;
1018         platform_set_drvdata(pdev, obj);
1019
1020         p = (void *)__get_free_pages(GFP_KERNEL, get_order(IOPGD_TABLE_SIZE));
1021         if (!p) {
1022                 err = -ENOMEM;
1023                 goto err_pgd;
1024         }
1025         memset(p, 0, IOPGD_TABLE_SIZE);
1026         clean_dcache_area(p, IOPGD_TABLE_SIZE);
1027         obj->iopgd = p;
1028
1029         BUG_ON(!IS_ALIGNED((unsigned long)obj->iopgd, IOPGD_TABLE_SIZE));
1030
1031         dev_info(&pdev->dev, "%s registered\n", obj->name);
1032         return 0;
1033
1034 err_pgd:
1035         free_irq(irq, obj);
1036 err_irq:
1037         iounmap(obj->regbase);
1038 err_ioremap:
1039         release_mem_region(res->start, resource_size(res));
1040 err_mem:
1041         clk_put(obj->clk);
1042 err_clk:
1043         kfree(obj);
1044         return err;
1045 }
1046
1047 static int __devexit omap_iommu_remove(struct platform_device *pdev)
1048 {
1049         int irq;
1050         struct resource *res;
1051         struct iommu *obj = platform_get_drvdata(pdev);
1052
1053         platform_set_drvdata(pdev, NULL);
1054
1055         iopgtable_clear_entry_all(obj);
1056         free_pages((unsigned long)obj->iopgd, get_order(IOPGD_TABLE_SIZE));
1057
1058         irq = platform_get_irq(pdev, 0);
1059         free_irq(irq, obj);
1060         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1061         release_mem_region(res->start, resource_size(res));
1062         iounmap(obj->regbase);
1063
1064         clk_put(obj->clk);
1065         dev_info(&pdev->dev, "%s removed\n", obj->name);
1066         kfree(obj);
1067         return 0;
1068 }
1069
1070 static struct platform_driver omap_iommu_driver = {
1071         .probe  = omap_iommu_probe,
1072         .remove = __devexit_p(omap_iommu_remove),
1073         .driver = {
1074                 .name   = "omap-iommu",
1075         },
1076 };
1077
1078 static void iopte_cachep_ctor(void *iopte)
1079 {
1080         clean_dcache_area(iopte, IOPTE_TABLE_SIZE);
1081 }
1082
1083 static int __init omap_iommu_init(void)
1084 {
1085         struct kmem_cache *p;
1086         const unsigned long flags = SLAB_HWCACHE_ALIGN;
1087         size_t align = 1 << 10; /* L2 pagetable alignement */
1088
1089         p = kmem_cache_create("iopte_cache", IOPTE_TABLE_SIZE, align, flags,
1090                               iopte_cachep_ctor);
1091         if (!p)
1092                 return -ENOMEM;
1093         iopte_cachep = p;
1094
1095         return platform_driver_register(&omap_iommu_driver);
1096 }
1097 module_init(omap_iommu_init);
1098
1099 static void __exit omap_iommu_exit(void)
1100 {
1101         kmem_cache_destroy(iopte_cachep);
1102
1103         platform_driver_unregister(&omap_iommu_driver);
1104 }
1105 module_exit(omap_iommu_exit);
1106
1107 MODULE_DESCRIPTION("omap iommu: tlb and pagetable primitives");
1108 MODULE_ALIAS("platform:omap-iommu");
1109 MODULE_AUTHOR("Hiroshi DOYU, Paul Mundt and Toshihiro Kobayashi");
1110 MODULE_LICENSE("GPL v2");