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