250cfe1fb51d2f5a5254b669241c013891ef486e
[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 static int load_iotlb_entry(struct iommu *obj, struct iotlb_entry *e)
241 {
242         int err = 0;
243         struct iotlb_lock l;
244         struct cr_regs *cr;
245
246         if (!obj || !obj->nr_tlb_entries || !e)
247                 return -EINVAL;
248
249         clk_enable(obj->clk);
250
251         iotlb_lock_get(obj, &l);
252         if (l.base == obj->nr_tlb_entries) {
253                 dev_warn(obj->dev, "%s: preserve entries full\n", __func__);
254                 err = -EBUSY;
255                 goto out;
256         }
257         if (!e->prsvd) {
258                 int i;
259                 struct cr_regs tmp;
260
261                 for_each_iotlb_cr(obj, obj->nr_tlb_entries, i, tmp)
262                         if (!iotlb_cr_valid(&tmp))
263                                 break;
264
265                 if (i == obj->nr_tlb_entries) {
266                         dev_dbg(obj->dev, "%s: full: no entry\n", __func__);
267                         err = -EBUSY;
268                         goto out;
269                 }
270
271                 iotlb_lock_get(obj, &l);
272         } else {
273                 l.vict = l.base;
274                 iotlb_lock_set(obj, &l);
275         }
276
277         cr = iotlb_alloc_cr(obj, e);
278         if (IS_ERR(cr)) {
279                 clk_disable(obj->clk);
280                 return PTR_ERR(cr);
281         }
282
283         iotlb_load_cr(obj, cr);
284         kfree(cr);
285
286         if (e->prsvd)
287                 l.base++;
288         /* increment victim for next tlb load */
289         if (++l.vict == obj->nr_tlb_entries)
290                 l.vict = l.base;
291         iotlb_lock_set(obj, &l);
292 out:
293         clk_disable(obj->clk);
294         return err;
295 }
296
297 /**
298  * flush_iotlb_page - Clear an iommu tlb entry
299  * @obj:        target iommu
300  * @da:         iommu device virtual address
301  *
302  * Clear an iommu tlb entry which includes 'da' address.
303  **/
304 static void flush_iotlb_page(struct iommu *obj, u32 da)
305 {
306         int i;
307         struct cr_regs cr;
308
309         clk_enable(obj->clk);
310
311         for_each_iotlb_cr(obj, obj->nr_tlb_entries, i, cr) {
312                 u32 start;
313                 size_t bytes;
314
315                 if (!iotlb_cr_valid(&cr))
316                         continue;
317
318                 start = iotlb_cr_to_virt(&cr);
319                 bytes = iopgsz_to_bytes(cr.cam & 3);
320
321                 if ((start <= da) && (da < start + bytes)) {
322                         dev_dbg(obj->dev, "%s: %08x<=%08x(%x)\n",
323                                 __func__, start, da, bytes);
324                         iotlb_load_cr(obj, &cr);
325                         iommu_write_reg(obj, 1, MMU_FLUSH_ENTRY);
326                 }
327         }
328         clk_disable(obj->clk);
329
330         if (i == obj->nr_tlb_entries)
331                 dev_dbg(obj->dev, "%s: no page for %08x\n", __func__, da);
332 }
333
334 /**
335  * flush_iotlb_range - Clear an iommu tlb entries
336  * @obj:        target iommu
337  * @start:      iommu device virtual address(start)
338  * @end:        iommu device virtual address(end)
339  *
340  * Clear an iommu tlb entry which includes 'da' address.
341  **/
342 void flush_iotlb_range(struct iommu *obj, u32 start, u32 end)
343 {
344         u32 da = start;
345
346         while (da < end) {
347                 flush_iotlb_page(obj, da);
348                 /* FIXME: Optimize for multiple page size */
349                 da += IOPTE_SIZE;
350         }
351 }
352 EXPORT_SYMBOL_GPL(flush_iotlb_range);
353
354 /**
355  * flush_iotlb_all - Clear all iommu tlb entries
356  * @obj:        target iommu
357  **/
358 static void flush_iotlb_all(struct iommu *obj)
359 {
360         struct iotlb_lock l;
361
362         clk_enable(obj->clk);
363
364         l.base = 0;
365         l.vict = 0;
366         iotlb_lock_set(obj, &l);
367
368         iommu_write_reg(obj, 1, MMU_GFLUSH);
369
370         clk_disable(obj->clk);
371 }
372
373 /**
374  * iommu_set_twl - enable/disable table walking logic
375  * @obj:        target iommu
376  * @on:         enable/disable
377  *
378  * Function used to enable/disable TWL. If one wants to work
379  * exclusively with locked TLB entries and receive notifications
380  * for TLB miss then call this function to disable TWL.
381  */
382 void iommu_set_twl(struct iommu *obj, bool on)
383 {
384         clk_enable(obj->clk);
385         arch_iommu->set_twl(obj, on);
386         clk_disable(obj->clk);
387 }
388 EXPORT_SYMBOL_GPL(iommu_set_twl);
389
390 #if defined(CONFIG_OMAP_IOMMU_DEBUG_MODULE)
391
392 ssize_t iommu_dump_ctx(struct iommu *obj, char *buf, ssize_t bytes)
393 {
394         if (!obj || !buf)
395                 return -EINVAL;
396
397         clk_enable(obj->clk);
398
399         bytes = arch_iommu->dump_ctx(obj, buf, bytes);
400
401         clk_disable(obj->clk);
402
403         return bytes;
404 }
405 EXPORT_SYMBOL_GPL(iommu_dump_ctx);
406
407 static int __dump_tlb_entries(struct iommu *obj, struct cr_regs *crs, int num)
408 {
409         int i;
410         struct iotlb_lock saved;
411         struct cr_regs tmp;
412         struct cr_regs *p = crs;
413
414         clk_enable(obj->clk);
415         iotlb_lock_get(obj, &saved);
416
417         for_each_iotlb_cr(obj, num, i, tmp) {
418                 if (!iotlb_cr_valid(&tmp))
419                         continue;
420                 *p++ = tmp;
421         }
422
423         iotlb_lock_set(obj, &saved);
424         clk_disable(obj->clk);
425
426         return  p - crs;
427 }
428
429 /**
430  * dump_tlb_entries - dump cr arrays to given buffer
431  * @obj:        target iommu
432  * @buf:        output buffer
433  **/
434 size_t dump_tlb_entries(struct iommu *obj, char *buf, ssize_t bytes)
435 {
436         int i, num;
437         struct cr_regs *cr;
438         char *p = buf;
439
440         num = bytes / sizeof(*cr);
441         num = min(obj->nr_tlb_entries, num);
442
443         cr = kcalloc(num, sizeof(*cr), GFP_KERNEL);
444         if (!cr)
445                 return 0;
446
447         num = __dump_tlb_entries(obj, cr, num);
448         for (i = 0; i < num; i++)
449                 p += iotlb_dump_cr(obj, cr + i, p);
450         kfree(cr);
451
452         return p - buf;
453 }
454 EXPORT_SYMBOL_GPL(dump_tlb_entries);
455
456 int foreach_iommu_device(void *data, int (*fn)(struct device *, void *))
457 {
458         return driver_for_each_device(&omap_iommu_driver.driver,
459                                       NULL, data, fn);
460 }
461 EXPORT_SYMBOL_GPL(foreach_iommu_device);
462
463 #endif /* CONFIG_OMAP_IOMMU_DEBUG_MODULE */
464
465 /*
466  *      H/W pagetable operations
467  */
468 static void flush_iopgd_range(u32 *first, u32 *last)
469 {
470         /* FIXME: L2 cache should be taken care of if it exists */
471         do {
472                 asm("mcr        p15, 0, %0, c7, c10, 1 @ flush_pgd"
473                     : : "r" (first));
474                 first += L1_CACHE_BYTES / sizeof(*first);
475         } while (first <= last);
476 }
477
478 static void flush_iopte_range(u32 *first, u32 *last)
479 {
480         /* FIXME: L2 cache should be taken care of if it exists */
481         do {
482                 asm("mcr        p15, 0, %0, c7, c10, 1 @ flush_pte"
483                     : : "r" (first));
484                 first += L1_CACHE_BYTES / sizeof(*first);
485         } while (first <= last);
486 }
487
488 static void iopte_free(u32 *iopte)
489 {
490         /* Note: freed iopte's must be clean ready for re-use */
491         kmem_cache_free(iopte_cachep, iopte);
492 }
493
494 static u32 *iopte_alloc(struct iommu *obj, u32 *iopgd, u32 da)
495 {
496         u32 *iopte;
497
498         /* a table has already existed */
499         if (*iopgd)
500                 goto pte_ready;
501
502         /*
503          * do the allocation outside the page table lock
504          */
505         spin_unlock(&obj->page_table_lock);
506         iopte = kmem_cache_zalloc(iopte_cachep, GFP_KERNEL);
507         spin_lock(&obj->page_table_lock);
508
509         if (!*iopgd) {
510                 if (!iopte)
511                         return ERR_PTR(-ENOMEM);
512
513                 *iopgd = virt_to_phys(iopte) | IOPGD_TABLE;
514                 flush_iopgd_range(iopgd, iopgd);
515
516                 dev_vdbg(obj->dev, "%s: a new pte:%p\n", __func__, iopte);
517         } else {
518                 /* We raced, free the reduniovant table */
519                 iopte_free(iopte);
520         }
521
522 pte_ready:
523         iopte = iopte_offset(iopgd, da);
524
525         dev_vdbg(obj->dev,
526                  "%s: da:%08x pgd:%p *pgd:%08x pte:%p *pte:%08x\n",
527                  __func__, da, iopgd, *iopgd, iopte, *iopte);
528
529         return iopte;
530 }
531
532 static int iopgd_alloc_section(struct iommu *obj, u32 da, u32 pa, u32 prot)
533 {
534         u32 *iopgd = iopgd_offset(obj, da);
535
536         if ((da | pa) & ~IOSECTION_MASK) {
537                 dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
538                         __func__, da, pa, IOSECTION_SIZE);
539                 return -EINVAL;
540         }
541
542         *iopgd = (pa & IOSECTION_MASK) | prot | IOPGD_SECTION;
543         flush_iopgd_range(iopgd, iopgd);
544         return 0;
545 }
546
547 static int iopgd_alloc_super(struct iommu *obj, u32 da, u32 pa, u32 prot)
548 {
549         u32 *iopgd = iopgd_offset(obj, da);
550         int i;
551
552         if ((da | pa) & ~IOSUPER_MASK) {
553                 dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
554                         __func__, da, pa, IOSUPER_SIZE);
555                 return -EINVAL;
556         }
557
558         for (i = 0; i < 16; i++)
559                 *(iopgd + i) = (pa & IOSUPER_MASK) | prot | IOPGD_SUPER;
560         flush_iopgd_range(iopgd, iopgd + 15);
561         return 0;
562 }
563
564 static int iopte_alloc_page(struct iommu *obj, u32 da, u32 pa, u32 prot)
565 {
566         u32 *iopgd = iopgd_offset(obj, da);
567         u32 *iopte = iopte_alloc(obj, iopgd, da);
568
569         if (IS_ERR(iopte))
570                 return PTR_ERR(iopte);
571
572         *iopte = (pa & IOPAGE_MASK) | prot | IOPTE_SMALL;
573         flush_iopte_range(iopte, iopte);
574
575         dev_vdbg(obj->dev, "%s: da:%08x pa:%08x pte:%p *pte:%08x\n",
576                  __func__, da, pa, iopte, *iopte);
577
578         return 0;
579 }
580
581 static int iopte_alloc_large(struct iommu *obj, u32 da, u32 pa, u32 prot)
582 {
583         u32 *iopgd = iopgd_offset(obj, da);
584         u32 *iopte = iopte_alloc(obj, iopgd, da);
585         int i;
586
587         if ((da | pa) & ~IOLARGE_MASK) {
588                 dev_err(obj->dev, "%s: %08x:%08x should aligned on %08lx\n",
589                         __func__, da, pa, IOLARGE_SIZE);
590                 return -EINVAL;
591         }
592
593         if (IS_ERR(iopte))
594                 return PTR_ERR(iopte);
595
596         for (i = 0; i < 16; i++)
597                 *(iopte + i) = (pa & IOLARGE_MASK) | prot | IOPTE_LARGE;
598         flush_iopte_range(iopte, iopte + 15);
599         return 0;
600 }
601
602 static int iopgtable_store_entry_core(struct iommu *obj, struct iotlb_entry *e)
603 {
604         int (*fn)(struct iommu *, u32, u32, u32);
605         u32 prot;
606         int err;
607
608         if (!obj || !e)
609                 return -EINVAL;
610
611         switch (e->pgsz) {
612         case MMU_CAM_PGSZ_16M:
613                 fn = iopgd_alloc_super;
614                 break;
615         case MMU_CAM_PGSZ_1M:
616                 fn = iopgd_alloc_section;
617                 break;
618         case MMU_CAM_PGSZ_64K:
619                 fn = iopte_alloc_large;
620                 break;
621         case MMU_CAM_PGSZ_4K:
622                 fn = iopte_alloc_page;
623                 break;
624         default:
625                 fn = NULL;
626                 BUG();
627                 break;
628         }
629
630         prot = get_iopte_attr(e);
631
632         spin_lock(&obj->page_table_lock);
633         err = fn(obj, e->da, e->pa, prot);
634         spin_unlock(&obj->page_table_lock);
635
636         return err;
637 }
638
639 /**
640  * iopgtable_store_entry - Make an iommu pte entry
641  * @obj:        target iommu
642  * @e:          an iommu tlb entry info
643  **/
644 int iopgtable_store_entry(struct iommu *obj, struct iotlb_entry *e)
645 {
646         int err;
647
648         flush_iotlb_page(obj, e->da);
649         err = iopgtable_store_entry_core(obj, e);
650 #ifdef PREFETCH_IOTLB
651         if (!err)
652                 load_iotlb_entry(obj, e);
653 #endif
654         return err;
655 }
656 EXPORT_SYMBOL_GPL(iopgtable_store_entry);
657
658 /**
659  * iopgtable_lookup_entry - Lookup an iommu pte entry
660  * @obj:        target iommu
661  * @da:         iommu device virtual address
662  * @ppgd:       iommu pgd entry pointer to be returned
663  * @ppte:       iommu pte entry pointer to be returned
664  **/
665 static void
666 iopgtable_lookup_entry(struct omap_iommu *obj, u32 da, u32 **ppgd, u32 **ppte)
667 {
668         u32 *iopgd, *iopte = NULL;
669
670         iopgd = iopgd_offset(obj, da);
671         if (!*iopgd)
672                 goto out;
673
674         if (iopgd_is_table(*iopgd))
675                 iopte = iopte_offset(iopgd, da);
676 out:
677         *ppgd = iopgd;
678         *ppte = iopte;
679 }
680
681 static size_t iopgtable_clear_entry_core(struct iommu *obj, u32 da)
682 {
683         size_t bytes;
684         u32 *iopgd = iopgd_offset(obj, da);
685         int nent = 1;
686
687         if (!*iopgd)
688                 return 0;
689
690         if (iopgd_is_table(*iopgd)) {
691                 int i;
692                 u32 *iopte = iopte_offset(iopgd, da);
693
694                 bytes = IOPTE_SIZE;
695                 if (*iopte & IOPTE_LARGE) {
696                         nent *= 16;
697                         /* rewind to the 1st entry */
698                         iopte = iopte_offset(iopgd, (da & IOLARGE_MASK));
699                 }
700                 bytes *= nent;
701                 memset(iopte, 0, nent * sizeof(*iopte));
702                 flush_iopte_range(iopte, iopte + (nent - 1) * sizeof(*iopte));
703
704                 /*
705                  * do table walk to check if this table is necessary or not
706                  */
707                 iopte = iopte_offset(iopgd, 0);
708                 for (i = 0; i < PTRS_PER_IOPTE; i++)
709                         if (iopte[i])
710                                 goto out;
711
712                 iopte_free(iopte);
713                 nent = 1; /* for the next L1 entry */
714         } else {
715                 bytes = IOPGD_SIZE;
716                 if ((*iopgd & IOPGD_SUPER) == IOPGD_SUPER) {
717                         nent *= 16;
718                         /* rewind to the 1st entry */
719                         iopgd = iopgd_offset(obj, (da & IOSUPER_MASK));
720                 }
721                 bytes *= nent;
722         }
723         memset(iopgd, 0, nent * sizeof(*iopgd));
724         flush_iopgd_range(iopgd, iopgd + (nent - 1) * sizeof(*iopgd));
725 out:
726         return bytes;
727 }
728
729 /**
730  * iopgtable_clear_entry - Remove an iommu pte entry
731  * @obj:        target iommu
732  * @da:         iommu device virtual address
733  **/
734 static size_t iopgtable_clear_entry(struct iommu *obj, u32 da)
735 {
736         size_t bytes;
737
738         spin_lock(&obj->page_table_lock);
739
740         bytes = iopgtable_clear_entry_core(obj, da);
741         flush_iotlb_page(obj, da);
742
743         spin_unlock(&obj->page_table_lock);
744
745         return bytes;
746 }
747
748 static void iopgtable_clear_entry_all(struct iommu *obj)
749 {
750         int i;
751
752         spin_lock(&obj->page_table_lock);
753
754         for (i = 0; i < PTRS_PER_IOPGD; i++) {
755                 u32 da;
756                 u32 *iopgd;
757
758                 da = i << IOPGD_SHIFT;
759                 iopgd = iopgd_offset(obj, da);
760
761                 if (!*iopgd)
762                         continue;
763
764                 if (iopgd_is_table(*iopgd))
765                         iopte_free(iopte_offset(iopgd, 0));
766
767                 *iopgd = 0;
768                 flush_iopgd_range(iopgd, iopgd);
769         }
770
771         flush_iotlb_all(obj);
772
773         spin_unlock(&obj->page_table_lock);
774 }
775
776 /*
777  *      Device IOMMU generic operations
778  */
779 static irqreturn_t iommu_fault_handler(int irq, void *data)
780 {
781         u32 da, errs;
782         u32 *iopgd, *iopte;
783         struct iommu *obj = data;
784
785         if (!obj->refcount)
786                 return IRQ_NONE;
787
788         clk_enable(obj->clk);
789         errs = iommu_report_fault(obj, &da);
790         clk_disable(obj->clk);
791         if (errs == 0)
792                 return IRQ_HANDLED;
793
794         /* Fault callback or TLB/PTE Dynamic loading */
795         if (obj->isr && !obj->isr(obj, da, errs, obj->isr_priv))
796                 return IRQ_HANDLED;
797
798         iommu_disable(obj);
799
800         iopgd = iopgd_offset(obj, da);
801
802         if (!iopgd_is_table(*iopgd)) {
803                 dev_err(obj->dev, "%s: errs:0x%08x da:0x%08x pgd:0x%p "
804                         "*pgd:px%08x\n", obj->name, errs, da, iopgd, *iopgd);
805                 return IRQ_NONE;
806         }
807
808         iopte = iopte_offset(iopgd, da);
809
810         dev_err(obj->dev, "%s: errs:0x%08x da:0x%08x pgd:0x%p *pgd:0x%08x "
811                 "pte:0x%p *pte:0x%08x\n", obj->name, errs, da, iopgd, *iopgd,
812                 iopte, *iopte);
813
814         return IRQ_NONE;
815 }
816
817 static int device_match_by_alias(struct device *dev, void *data)
818 {
819         struct iommu *obj = to_iommu(dev);
820         const char *name = data;
821
822         pr_debug("%s: %s %s\n", __func__, obj->name, name);
823
824         return strcmp(obj->name, name) == 0;
825 }
826
827 /**
828  * iommu_set_da_range - Set a valid device address range
829  * @obj:                target iommu
830  * @start               Start of valid range
831  * @end                 End of valid range
832  **/
833 int iommu_set_da_range(struct iommu *obj, u32 start, u32 end)
834 {
835
836         if (!obj)
837                 return -EFAULT;
838
839         if (end < start || !PAGE_ALIGN(start | end))
840                 return -EINVAL;
841
842         obj->da_start = start;
843         obj->da_end = end;
844
845         return 0;
846 }
847 EXPORT_SYMBOL_GPL(iommu_set_da_range);
848
849 /**
850  * iommu_get - Get iommu handler
851  * @name:       target iommu name
852  **/
853 struct iommu *iommu_get(const char *name)
854 {
855         int err = -ENOMEM;
856         struct device *dev;
857         struct iommu *obj;
858
859         dev = driver_find_device(&omap_iommu_driver.driver, NULL, (void *)name,
860                                  device_match_by_alias);
861         if (!dev)
862                 return ERR_PTR(-ENODEV);
863
864         obj = to_iommu(dev);
865
866         mutex_lock(&obj->iommu_lock);
867
868         if (obj->refcount++ == 0) {
869                 err = iommu_enable(obj);
870                 if (err)
871                         goto err_enable;
872                 flush_iotlb_all(obj);
873         }
874
875         if (!try_module_get(obj->owner))
876                 goto err_module;
877
878         mutex_unlock(&obj->iommu_lock);
879
880         dev_dbg(obj->dev, "%s: %s\n", __func__, obj->name);
881         return obj;
882
883 err_module:
884         if (obj->refcount == 1)
885                 iommu_disable(obj);
886 err_enable:
887         obj->refcount--;
888         mutex_unlock(&obj->iommu_lock);
889         return ERR_PTR(err);
890 }
891 EXPORT_SYMBOL_GPL(iommu_get);
892
893 /**
894  * iommu_put - Put back iommu handler
895  * @obj:        target iommu
896  **/
897 void iommu_put(struct iommu *obj)
898 {
899         if (!obj || IS_ERR(obj))
900                 return;
901
902         mutex_lock(&obj->iommu_lock);
903
904         if (--obj->refcount == 0)
905                 iommu_disable(obj);
906
907         module_put(obj->owner);
908
909         mutex_unlock(&obj->iommu_lock);
910
911         dev_dbg(obj->dev, "%s: %s\n", __func__, obj->name);
912 }
913 EXPORT_SYMBOL_GPL(iommu_put);
914
915 int iommu_set_isr(const char *name,
916                   int (*isr)(struct iommu *obj, u32 da, u32 iommu_errs,
917                              void *priv),
918                   void *isr_priv)
919 {
920         struct device *dev;
921         struct iommu *obj;
922
923         dev = driver_find_device(&omap_iommu_driver.driver, NULL, (void *)name,
924                                  device_match_by_alias);
925         if (!dev)
926                 return -ENODEV;
927
928         obj = to_iommu(dev);
929         mutex_lock(&obj->iommu_lock);
930         if (obj->refcount != 0) {
931                 mutex_unlock(&obj->iommu_lock);
932                 return -EBUSY;
933         }
934         obj->isr = isr;
935         obj->isr_priv = isr_priv;
936         mutex_unlock(&obj->iommu_lock);
937
938         return 0;
939 }
940 EXPORT_SYMBOL_GPL(iommu_set_isr);
941
942 /*
943  *      OMAP Device MMU(IOMMU) detection
944  */
945 static int __devinit omap_iommu_probe(struct platform_device *pdev)
946 {
947         int err = -ENODEV;
948         void *p;
949         int irq;
950         struct iommu *obj;
951         struct resource *res;
952         struct iommu_platform_data *pdata = pdev->dev.platform_data;
953
954         if (pdev->num_resources != 2)
955                 return -EINVAL;
956
957         obj = kzalloc(sizeof(*obj) + MMU_REG_SIZE, GFP_KERNEL);
958         if (!obj)
959                 return -ENOMEM;
960
961         obj->clk = clk_get(&pdev->dev, pdata->clk_name);
962         if (IS_ERR(obj->clk))
963                 goto err_clk;
964
965         obj->nr_tlb_entries = pdata->nr_tlb_entries;
966         obj->name = pdata->name;
967         obj->dev = &pdev->dev;
968         obj->ctx = (void *)obj + sizeof(*obj);
969         obj->da_start = pdata->da_start;
970         obj->da_end = pdata->da_end;
971
972         mutex_init(&obj->iommu_lock);
973         mutex_init(&obj->mmap_lock);
974         spin_lock_init(&obj->page_table_lock);
975         INIT_LIST_HEAD(&obj->mmap);
976
977         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
978         if (!res) {
979                 err = -ENODEV;
980                 goto err_mem;
981         }
982
983         res = request_mem_region(res->start, resource_size(res),
984                                  dev_name(&pdev->dev));
985         if (!res) {
986                 err = -EIO;
987                 goto err_mem;
988         }
989
990         obj->regbase = ioremap(res->start, resource_size(res));
991         if (!obj->regbase) {
992                 err = -ENOMEM;
993                 goto err_ioremap;
994         }
995
996         irq = platform_get_irq(pdev, 0);
997         if (irq < 0) {
998                 err = -ENODEV;
999                 goto err_irq;
1000         }
1001         err = request_irq(irq, iommu_fault_handler, IRQF_SHARED,
1002                           dev_name(&pdev->dev), obj);
1003         if (err < 0)
1004                 goto err_irq;
1005         platform_set_drvdata(pdev, obj);
1006
1007         p = (void *)__get_free_pages(GFP_KERNEL, get_order(IOPGD_TABLE_SIZE));
1008         if (!p) {
1009                 err = -ENOMEM;
1010                 goto err_pgd;
1011         }
1012         memset(p, 0, IOPGD_TABLE_SIZE);
1013         clean_dcache_area(p, IOPGD_TABLE_SIZE);
1014         obj->iopgd = p;
1015
1016         BUG_ON(!IS_ALIGNED((unsigned long)obj->iopgd, IOPGD_TABLE_SIZE));
1017
1018         dev_info(&pdev->dev, "%s registered\n", obj->name);
1019         return 0;
1020
1021 err_pgd:
1022         free_irq(irq, obj);
1023 err_irq:
1024         iounmap(obj->regbase);
1025 err_ioremap:
1026         release_mem_region(res->start, resource_size(res));
1027 err_mem:
1028         clk_put(obj->clk);
1029 err_clk:
1030         kfree(obj);
1031         return err;
1032 }
1033
1034 static int __devexit omap_iommu_remove(struct platform_device *pdev)
1035 {
1036         int irq;
1037         struct resource *res;
1038         struct iommu *obj = platform_get_drvdata(pdev);
1039
1040         platform_set_drvdata(pdev, NULL);
1041
1042         iopgtable_clear_entry_all(obj);
1043         free_pages((unsigned long)obj->iopgd, get_order(IOPGD_TABLE_SIZE));
1044
1045         irq = platform_get_irq(pdev, 0);
1046         free_irq(irq, obj);
1047         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1048         release_mem_region(res->start, resource_size(res));
1049         iounmap(obj->regbase);
1050
1051         clk_put(obj->clk);
1052         dev_info(&pdev->dev, "%s removed\n", obj->name);
1053         kfree(obj);
1054         return 0;
1055 }
1056
1057 static struct platform_driver omap_iommu_driver = {
1058         .probe  = omap_iommu_probe,
1059         .remove = __devexit_p(omap_iommu_remove),
1060         .driver = {
1061                 .name   = "omap-iommu",
1062         },
1063 };
1064
1065 static void iopte_cachep_ctor(void *iopte)
1066 {
1067         clean_dcache_area(iopte, IOPTE_TABLE_SIZE);
1068 }
1069
1070 static int __init omap_iommu_init(void)
1071 {
1072         struct kmem_cache *p;
1073         const unsigned long flags = SLAB_HWCACHE_ALIGN;
1074         size_t align = 1 << 10; /* L2 pagetable alignement */
1075
1076         p = kmem_cache_create("iopte_cache", IOPTE_TABLE_SIZE, align, flags,
1077                               iopte_cachep_ctor);
1078         if (!p)
1079                 return -ENOMEM;
1080         iopte_cachep = p;
1081
1082         return platform_driver_register(&omap_iommu_driver);
1083 }
1084 module_init(omap_iommu_init);
1085
1086 static void __exit omap_iommu_exit(void)
1087 {
1088         kmem_cache_destroy(iopte_cachep);
1089
1090         platform_driver_unregister(&omap_iommu_driver);
1091 }
1092 module_exit(omap_iommu_exit);
1093
1094 MODULE_DESCRIPTION("omap iommu: tlb and pagetable primitives");
1095 MODULE_ALIAS("platform:omap-iommu");
1096 MODULE_AUTHOR("Hiroshi DOYU, Paul Mundt and Toshihiro Kobayashi");
1097 MODULE_LICENSE("GPL v2");