drivers/iommu/tegra-smmu.c

   1 /*
   2  * Copyright (C) 2011-2014 NVIDIA CORPORATION.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  */
   8
   9 #include <linux/bitops.h>
  10 #include <linux/debugfs.h>
  11 #include <linux/err.h>
  12 #include <linux/iommu.h>
  13 #include <linux/kernel.h>
  14 #include <linux/of.h>
  15 #include <linux/of_device.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/slab.h>
  18
  19 #include <soc/tegra/ahb.h>
  20 #include <soc/tegra/mc.h>
  21
  22 struct tegra_smmu {
  23         void __iomem *regs;
  24         struct device *dev;
  25
  26         struct tegra_mc *mc;
  27         const struct tegra_smmu_soc *soc;
  28
  29         unsigned long pfn_mask;
  30
  31         unsigned long *asids;
  32         struct mutex lock;
  33
  34         struct list_head list;
  35
  36         struct dentry *debugfs;
  37 };
  38
  39 struct tegra_smmu_as {
  40         struct iommu_domain domain;
  41         struct tegra_smmu *smmu;
  42         unsigned int use_count;
  43         struct page *count;
  44         struct page *pd;
  45         unsigned id;
  46         u32 attr;
  47 };
  48
  49 static struct tegra_smmu_as *to_smmu_as(struct iommu_domain *dom)
  50 {
  51         return container_of(dom, struct tegra_smmu_as, domain);
  52 }
  53
  54 static inline void smmu_writel(struct tegra_smmu *smmu, u32 value,
  55                                unsigned long offset)
  56 {
  57         writel(value, smmu->regs + offset);
  58 }
  59
  60 static inline u32 smmu_readl(struct tegra_smmu *smmu, unsigned long offset)
  61 {
  62         return readl(smmu->regs + offset);
  63 }
  64
  65 #define SMMU_CONFIG 0x010
  66 #define  SMMU_CONFIG_ENABLE (1 << 0)
  67
  68 #define SMMU_TLB_CONFIG 0x14
  69 #define  SMMU_TLB_CONFIG_HIT_UNDER_MISS (1 << 29)
  70 #define  SMMU_TLB_CONFIG_ROUND_ROBIN_ARBITRATION (1 << 28)
  71 #define  SMMU_TLB_CONFIG_ACTIVE_LINES(x) ((x) & 0x3f)
  72
  73 #define SMMU_PTC_CONFIG 0x18
  74 #define  SMMU_PTC_CONFIG_ENABLE (1 << 29)
  75 #define  SMMU_PTC_CONFIG_REQ_LIMIT(x) (((x) & 0x0f) << 24)
  76 #define  SMMU_PTC_CONFIG_INDEX_MAP(x) ((x) & 0x3f)
  77
  78 #define SMMU_PTB_ASID 0x01c
  79 #define  SMMU_PTB_ASID_VALUE(x) ((x) & 0x7f)
  80
  81 #define SMMU_PTB_DATA 0x020
  82 #define  SMMU_PTB_DATA_VALUE(page, attr) (page_to_phys(page) >> 12 | (attr))
  83
  84 #define SMMU_MK_PDE(page, attr) (page_to_phys(page) >> SMMU_PTE_SHIFT | (attr))
  85
  86 #define SMMU_TLB_FLUSH 0x030
  87 #define  SMMU_TLB_FLUSH_VA_MATCH_ALL     (0 << 0)
  88 #define  SMMU_TLB_FLUSH_VA_MATCH_SECTION (2 << 0)
  89 #define  SMMU_TLB_FLUSH_VA_MATCH_GROUP   (3 << 0)
  90 #define  SMMU_TLB_FLUSH_ASID(x)          (((x) & 0x7f) << 24)
  91 #define  SMMU_TLB_FLUSH_VA_SECTION(addr) ((((addr) & 0xffc00000) >> 12) | \
  92                                           SMMU_TLB_FLUSH_VA_MATCH_SECTION)
  93 #define  SMMU_TLB_FLUSH_VA_GROUP(addr)   ((((addr) & 0xffffc000) >> 12) | \
  94                                           SMMU_TLB_FLUSH_VA_MATCH_GROUP)
  95 #define  SMMU_TLB_FLUSH_ASID_MATCH       (1 << 31)
  96
  97 #define SMMU_PTC_FLUSH 0x034
  98 #define  SMMU_PTC_FLUSH_TYPE_ALL (0 << 0)
  99 #define  SMMU_PTC_FLUSH_TYPE_ADR (1 << 0)
 100
 101 #define SMMU_PTC_FLUSH_HI 0x9b8
 102 #define  SMMU_PTC_FLUSH_HI_MASK 0x3
 103
 104 /* per-SWGROUP SMMU_*_ASID register */
 105 #define SMMU_ASID_ENABLE (1 << 31)
 106 #define SMMU_ASID_MASK 0x7f
 107 #define SMMU_ASID_VALUE(x) ((x) & SMMU_ASID_MASK)
 108
 109 /* page table definitions */
 110 #define SMMU_NUM_PDE 1024
 111 #define SMMU_NUM_PTE 1024
 112
 113 #define SMMU_SIZE_PD (SMMU_NUM_PDE * 4)
 114 #define SMMU_SIZE_PT (SMMU_NUM_PTE * 4)
 115
 116 #define SMMU_PDE_SHIFT 22
 117 #define SMMU_PTE_SHIFT 12
 118
 119 #define SMMU_PD_READABLE        (1 << 31)
 120 #define SMMU_PD_WRITABLE        (1 << 30)
 121 #define SMMU_PD_NONSECURE       (1 << 29)
 122
 123 #define SMMU_PDE_READABLE       (1 << 31)
 124 #define SMMU_PDE_WRITABLE       (1 << 30)
 125 #define SMMU_PDE_NONSECURE      (1 << 29)
 126 #define SMMU_PDE_NEXT           (1 << 28)
 127
 128 #define SMMU_PTE_READABLE       (1 << 31)
 129 #define SMMU_PTE_WRITABLE       (1 << 30)
 130 #define SMMU_PTE_NONSECURE      (1 << 29)
 131
 132 #define SMMU_PDE_ATTR           (SMMU_PDE_READABLE | SMMU_PDE_WRITABLE | \
 133                                  SMMU_PDE_NONSECURE)
 134 #define SMMU_PTE_ATTR           (SMMU_PTE_READABLE | SMMU_PTE_WRITABLE | \
 135                                  SMMU_PTE_NONSECURE)
 136
 137 static unsigned int iova_pd_index(unsigned long iova)
 138 {
 139         return (iova >> SMMU_PDE_SHIFT) & (SMMU_NUM_PDE - 1);
 140 }
 141
 142 static unsigned int iova_pt_index(unsigned long iova)
 143 {
 144         return (iova >> SMMU_PTE_SHIFT) & (SMMU_NUM_PTE - 1);
 145 }
 146
 147 static inline void smmu_flush_ptc(struct tegra_smmu *smmu, struct page *page,
 148                                   unsigned long offset)
 149 {
 150         phys_addr_t phys = page ? page_to_phys(page) : 0;
 151         u32 value;
 152
 153         if (page) {
 154                 offset &= ~(smmu->mc->soc->atom_size - 1);
 155
 156                 if (smmu->mc->soc->num_address_bits > 32) {
 157 #ifdef CONFIG_PHYS_ADDR_T_64BIT
 158                         value = (phys >> 32) & SMMU_PTC_FLUSH_HI_MASK;
 159 #else
 160                         value = 0;
 161 #endif
 162                         smmu_writel(smmu, value, SMMU_PTC_FLUSH_HI);
 163                 }
 164
 165                 value = (phys + offset) | SMMU_PTC_FLUSH_TYPE_ADR;
 166         } else {
 167                 value = SMMU_PTC_FLUSH_TYPE_ALL;
 168         }
 169
 170         smmu_writel(smmu, value, SMMU_PTC_FLUSH);
 171 }
 172
 173 static inline void smmu_flush_tlb(struct tegra_smmu *smmu)
 174 {
 175         smmu_writel(smmu, SMMU_TLB_FLUSH_VA_MATCH_ALL, SMMU_TLB_FLUSH);
 176 }
 177
 178 static inline void smmu_flush_tlb_asid(struct tegra_smmu *smmu,
 179                                        unsigned long asid)
 180 {
 181         u32 value;
 182
 183         value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
 184                 SMMU_TLB_FLUSH_VA_MATCH_ALL;
 185         smmu_writel(smmu, value, SMMU_TLB_FLUSH);
 186 }
 187
 188 static inline void smmu_flush_tlb_section(struct tegra_smmu *smmu,
 189                                           unsigned long asid,
 190                                           unsigned long iova)
 191 {
 192         u32 value;
 193
 194         value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
 195                 SMMU_TLB_FLUSH_VA_SECTION(iova);
 196         smmu_writel(smmu, value, SMMU_TLB_FLUSH);
 197 }
 198
 199 static inline void smmu_flush_tlb_group(struct tegra_smmu *smmu,
 200                                         unsigned long asid,
 201                                         unsigned long iova)
 202 {
 203         u32 value;
 204
 205         value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
 206                 SMMU_TLB_FLUSH_VA_GROUP(iova);
 207         smmu_writel(smmu, value, SMMU_TLB_FLUSH);
 208 }
 209
 210 static inline void smmu_flush(struct tegra_smmu *smmu)
 211 {
 212         smmu_readl(smmu, SMMU_CONFIG);
 213 }
 214
 215 static int tegra_smmu_alloc_asid(struct tegra_smmu *smmu, unsigned int *idp)
 216 {
 217         unsigned long id;
 218
 219         mutex_lock(&smmu->lock);
 220
 221         id = find_first_zero_bit(smmu->asids, smmu->soc->num_asids);
 222         if (id >= smmu->soc->num_asids) {
 223                 mutex_unlock(&smmu->lock);
 224                 return -ENOSPC;
 225         }
 226
 227         set_bit(id, smmu->asids);
 228         *idp = id;
 229
 230         mutex_unlock(&smmu->lock);
 231         return 0;
 232 }
 233
 234 static void tegra_smmu_free_asid(struct tegra_smmu *smmu, unsigned int id)
 235 {
 236         mutex_lock(&smmu->lock);
 237         clear_bit(id, smmu->asids);
 238         mutex_unlock(&smmu->lock);
 239 }
 240
 241 static bool tegra_smmu_capable(enum iommu_cap cap)
 242 {
 243         return false;
 244 }
 245
 246 static struct iommu_domain *tegra_smmu_domain_alloc(unsigned type)
 247 {
 248         struct tegra_smmu_as *as;
 249         unsigned int i;
 250         uint32_t *pd;
 251
 252         if (type != IOMMU_DOMAIN_UNMANAGED)
 253                 return NULL;
 254
 255         as = kzalloc(sizeof(*as), GFP_KERNEL);
 256         if (!as)
 257                 return NULL;
 258
 259         as->attr = SMMU_PD_READABLE | SMMU_PD_WRITABLE | SMMU_PD_NONSECURE;
 260
 261         as->pd = alloc_page(GFP_KERNEL | __GFP_DMA);
 262         if (!as->pd) {
 263                 kfree(as);
 264                 return NULL;
 265         }
 266
 267         as->count = alloc_page(GFP_KERNEL);
 268         if (!as->count) {
 269                 __free_page(as->pd);
 270                 kfree(as);
 271                 return NULL;
 272         }
 273
 274         /* clear PDEs */
 275         pd = page_address(as->pd);
 276         SetPageReserved(as->pd);
 277
 278         for (i = 0; i < SMMU_NUM_PDE; i++)
 279                 pd[i] = 0;
 280
 281         /* clear PDE usage counters */
 282         pd = page_address(as->count);
 283         SetPageReserved(as->count);
 284
 285         for (i = 0; i < SMMU_NUM_PDE; i++)
 286                 pd[i] = 0;
 287
 288         /* setup aperture */
 289         as->domain.geometry.aperture_start = 0;
 290         as->domain.geometry.aperture_end = 0xffffffff;
 291         as->domain.geometry.force_aperture = true;
 292
 293         return &as->domain;
 294 }
 295
 296 static void tegra_smmu_domain_free(struct iommu_domain *domain)
 297 {
 298         struct tegra_smmu_as *as = to_smmu_as(domain);
 299
 300         /* TODO: free page directory and page tables */
 301         ClearPageReserved(as->pd);
 302
 303         kfree(as);
 304 }
 305
 306 static const struct tegra_smmu_swgroup *
 307 tegra_smmu_find_swgroup(struct tegra_smmu *smmu, unsigned int swgroup)
 308 {
 309         const struct tegra_smmu_swgroup *group = NULL;
 310         unsigned int i;
 311
 312         for (i = 0; i < smmu->soc->num_swgroups; i++) {
 313                 if (smmu->soc->swgroups[i].swgroup == swgroup) {
 314                         group = &smmu->soc->swgroups[i];
 315                         break;
 316                 }
 317         }
 318
 319         return group;
 320 }
 321
 322 static void tegra_smmu_enable(struct tegra_smmu *smmu, unsigned int swgroup,
 323                               unsigned int asid)
 324 {
 325         const struct tegra_smmu_swgroup *group;
 326         unsigned int i;
 327         u32 value;
 328
 329         for (i = 0; i < smmu->soc->num_clients; i++) {
 330                 const struct tegra_mc_client *client = &smmu->soc->clients[i];
 331
 332                 if (client->swgroup != swgroup)
 333                         continue;
 334
 335                 value = smmu_readl(smmu, client->smmu.reg);
 336                 value |= BIT(client->smmu.bit);
 337                 smmu_writel(smmu, value, client->smmu.reg);
 338         }
 339
 340         group = tegra_smmu_find_swgroup(smmu, swgroup);
 341         if (group) {
 342                 value = smmu_readl(smmu, group->reg);
 343                 value &= ~SMMU_ASID_MASK;
 344                 value |= SMMU_ASID_VALUE(asid);
 345                 value |= SMMU_ASID_ENABLE;
 346                 smmu_writel(smmu, value, group->reg);
 347         }
 348 }
 349
 350 static void tegra_smmu_disable(struct tegra_smmu *smmu, unsigned int swgroup,
 351                                unsigned int asid)
 352 {
 353         const struct tegra_smmu_swgroup *group;
 354         unsigned int i;
 355         u32 value;
 356
 357         group = tegra_smmu_find_swgroup(smmu, swgroup);
 358         if (group) {
 359                 value = smmu_readl(smmu, group->reg);
 360                 value &= ~SMMU_ASID_MASK;
 361                 value |= SMMU_ASID_VALUE(asid);
 362                 value &= ~SMMU_ASID_ENABLE;
 363                 smmu_writel(smmu, value, group->reg);
 364         }
 365
 366         for (i = 0; i < smmu->soc->num_clients; i++) {
 367                 const struct tegra_mc_client *client = &smmu->soc->clients[i];
 368
 369                 if (client->swgroup != swgroup)
 370                         continue;
 371
 372                 value = smmu_readl(smmu, client->smmu.reg);
 373                 value &= ~BIT(client->smmu.bit);
 374                 smmu_writel(smmu, value, client->smmu.reg);
 375         }
 376 }
 377
 378 static int tegra_smmu_as_prepare(struct tegra_smmu *smmu,
 379                                  struct tegra_smmu_as *as)
 380 {
 381         u32 value;
 382         int err;
 383
 384         if (as->use_count > 0) {
 385                 as->use_count++;
 386                 return 0;
 387         }
 388
 389         err = tegra_smmu_alloc_asid(smmu, &as->id);
 390         if (err < 0)
 391                 return err;
 392
 393         smmu->soc->ops->flush_dcache(as->pd, 0, SMMU_SIZE_PD);
 394         smmu_flush_ptc(smmu, as->pd, 0);
 395         smmu_flush_tlb_asid(smmu, as->id);
 396
 397         smmu_writel(smmu, as->id & 0x7f, SMMU_PTB_ASID);
 398         value = SMMU_PTB_DATA_VALUE(as->pd, as->attr);
 399         smmu_writel(smmu, value, SMMU_PTB_DATA);
 400         smmu_flush(smmu);
 401
 402         as->smmu = smmu;
 403         as->use_count++;
 404
 405         return 0;
 406 }
 407
 408 static void tegra_smmu_as_unprepare(struct tegra_smmu *smmu,
 409                                     struct tegra_smmu_as *as)
 410 {
 411         if (--as->use_count > 0)
 412                 return;
 413
 414         tegra_smmu_free_asid(smmu, as->id);
 415         as->smmu = NULL;
 416 }
 417
 418 static int tegra_smmu_attach_dev(struct iommu_domain *domain,
 419                                  struct device *dev)
 420 {
 421         struct tegra_smmu *smmu = dev->archdata.iommu;
 422         struct tegra_smmu_as *as = to_smmu_as(domain);
 423         struct device_node *np = dev->of_node;
 424         struct of_phandle_args args;
 425         unsigned int index = 0;
 426         int err = 0;
 427
 428         while (!of_parse_phandle_with_args(np, "iommus", "#iommu-cells", index,
 429                                            &args)) {
 430                 unsigned int swgroup = args.args[0];
 431
 432                 if (args.np != smmu->dev->of_node) {
 433                         of_node_put(args.np);
 434                         continue;
 435                 }
 436
 437                 of_node_put(args.np);
 438
 439                 err = tegra_smmu_as_prepare(smmu, as);
 440                 if (err < 0)
 441                         return err;
 442
 443                 tegra_smmu_enable(smmu, swgroup, as->id);
 444                 index++;
 445         }
 446
 447         if (index == 0)
 448                 return -ENODEV;
 449
 450         return 0;
 451 }
 452
 453 static void tegra_smmu_detach_dev(struct iommu_domain *domain, struct device *dev)
 454 {
 455         struct tegra_smmu_as *as = to_smmu_as(domain);
 456         struct device_node *np = dev->of_node;
 457         struct tegra_smmu *smmu = as->smmu;
 458         struct of_phandle_args args;
 459         unsigned int index = 0;
 460
 461         while (!of_parse_phandle_with_args(np, "iommus", "#iommu-cells", index,
 462                                            &args)) {
 463                 unsigned int swgroup = args.args[0];
 464
 465                 if (args.np != smmu->dev->of_node) {
 466                         of_node_put(args.np);
 467                         continue;
 468                 }
 469
 470                 of_node_put(args.np);
 471
 472                 tegra_smmu_disable(smmu, swgroup, as->id);
 473                 tegra_smmu_as_unprepare(smmu, as);
 474                 index++;
 475         }
 476 }
 477
 478 static u32 *tegra_smmu_pte_offset(struct page *pt_page, unsigned long iova)
 479 {
 480         u32 *pt = page_address(pt_page);
 481
 482         return pt + iova_pt_index(iova);
 483 }
 484
 485 static u32 *tegra_smmu_pte_lookup(struct tegra_smmu_as *as, unsigned long iova,
 486                                   struct page **pagep)
 487 {
 488         unsigned int pd_index = iova_pd_index(iova);
 489         struct page *pt_page;
 490         u32 *pd;
 491
 492         pd = page_address(as->pd);
 493
 494         if (!pd[pd_index])
 495                 return NULL;
 496
 497         pt_page = pfn_to_page(pd[pd_index] & as->smmu->pfn_mask);
 498         *pagep = pt_page;
 499
 500         return tegra_smmu_pte_offset(pt_page, iova);
 501 }
 502
 503 static u32 *as_get_pte(struct tegra_smmu_as *as, dma_addr_t iova,
 504                        struct page **pagep)
 505 {
 506         u32 *pd = page_address(as->pd), *pt, *count;
 507         unsigned int pde = iova_pd_index(iova);
 508         struct tegra_smmu *smmu = as->smmu;
 509         struct page *page;
 510         unsigned int i;
 511
 512         if (pd[pde] == 0) {
 513                 page = alloc_page(GFP_KERNEL | __GFP_DMA);
 514                 if (!page)
 515                         return NULL;
 516
 517                 pt = page_address(page);
 518                 SetPageReserved(page);
 519
 520                 for (i = 0; i < SMMU_NUM_PTE; i++)
 521                         pt[i] = 0;
 522
 523                 smmu->soc->ops->flush_dcache(page, 0, SMMU_SIZE_PT);
 524
 525                 pd[pde] = SMMU_MK_PDE(page, SMMU_PDE_ATTR | SMMU_PDE_NEXT);
 526
 527                 smmu->soc->ops->flush_dcache(as->pd, pde << 2, 4);
 528                 smmu_flush_ptc(smmu, as->pd, pde << 2);
 529                 smmu_flush_tlb_section(smmu, as->id, iova);
 530                 smmu_flush(smmu);
 531         } else {
 532                 page = pfn_to_page(pd[pde] & smmu->pfn_mask);
 533         }
 534
 535         *pagep = page;
 536
 537         pt = page_address(page);
 538
 539         /* Keep track of entries in this page table. */
 540         count = page_address(as->count);
 541         if (pt[iova_pt_index(iova)] == 0)
 542                 count[pde]++;
 543
 544         return tegra_smmu_pte_offset(page, iova);
 545 }
 546
 547 static void tegra_smmu_pte_put_use(struct tegra_smmu_as *as, unsigned long iova)
 548 {
 549         struct tegra_smmu *smmu = as->smmu;
 550         unsigned int pde = iova_pd_index(iova);
 551         u32 *count = page_address(as->count);
 552         u32 *pd = page_address(as->pd);
 553         struct page *page;
 554
 555         page = pfn_to_page(pd[pde] & smmu->pfn_mask);
 556
 557         /*
 558          * When no entries in this page table are used anymore, return the
 559          * memory page to the system.
 560          */
 561         if (--count[pde] == 0) {
 562                 unsigned int offset = pde * sizeof(*pd);
 563
 564                 /* Clear the page directory entry first */
 565                 pd[pde] = 0;
 566
 567                 /* Flush the page directory entry */
 568                 smmu->soc->ops->flush_dcache(as->pd, offset, sizeof(*pd));
 569                 smmu_flush_ptc(smmu, as->pd, offset);
 570                 smmu_flush_tlb_section(smmu, as->id, iova);
 571                 smmu_flush(smmu);
 572
 573                 /* Finally, free the page */
 574                 ClearPageReserved(page);
 575                 __free_page(page);
 576         }
 577 }
 578
 579 static void tegra_smmu_set_pte(struct tegra_smmu_as *as, unsigned long iova,
 580                                u32 *pte, struct page *pte_page, u32 val)
 581 {
 582         struct tegra_smmu *smmu = as->smmu;
 583         unsigned long offset = offset_in_page(pte);
 584
 585         *pte = val;
 586
 587         smmu->soc->ops->flush_dcache(pte_page, offset, 4);
 588         smmu_flush_ptc(smmu, pte_page, offset);
 589         smmu_flush_tlb_group(smmu, as->id, iova);
 590         smmu_flush(smmu);
 591 }
 592
 593 static int tegra_smmu_map(struct iommu_domain *domain, unsigned long iova,
 594                           phys_addr_t paddr, size_t size, int prot)
 595 {
 596         struct tegra_smmu_as *as = to_smmu_as(domain);
 597         struct page *page;
 598         u32 *pte;
 599
 600         pte = as_get_pte(as, iova, &page);
 601         if (!pte)
 602                 return -ENOMEM;
 603
 604         tegra_smmu_set_pte(as, iova, pte, page,
 605                            __phys_to_pfn(paddr) | SMMU_PTE_ATTR);
 606
 607         return 0;
 608 }
 609
 610 static size_t tegra_smmu_unmap(struct iommu_domain *domain, unsigned long iova,
 611                                size_t size)
 612 {
 613         struct tegra_smmu_as *as = to_smmu_as(domain);
 614         struct page *pte_page;
 615         u32 *pte;
 616
 617         pte = tegra_smmu_pte_lookup(as, iova, &pte_page);
 618         if (!pte || !*pte)
 619                 return 0;
 620
 621         tegra_smmu_set_pte(as, iova, pte, pte_page, 0);
 622         tegra_smmu_pte_put_use(as, iova);
 623
 624         return size;
 625 }
 626
 627 static phys_addr_t tegra_smmu_iova_to_phys(struct iommu_domain *domain,
 628                                            dma_addr_t iova)
 629 {
 630         struct tegra_smmu_as *as = to_smmu_as(domain);
 631         struct page *pte_page;
 632         unsigned long pfn;
 633         u32 *pte;
 634
 635         pte = tegra_smmu_pte_lookup(as, iova, &pte_page);
 636         if (!pte || !*pte)
 637                 return 0;
 638
 639         pfn = *pte & as->smmu->pfn_mask;
 640
 641         return PFN_PHYS(pfn);
 642 }
 643
 644 static struct tegra_smmu *tegra_smmu_find(struct device_node *np)
 645 {
 646         struct platform_device *pdev;
 647         struct tegra_mc *mc;
 648
 649         pdev = of_find_device_by_node(np);
 650         if (!pdev)
 651                 return NULL;
 652
 653         mc = platform_get_drvdata(pdev);
 654         if (!mc)
 655                 return NULL;
 656
 657         return mc->smmu;
 658 }
 659
 660 static int tegra_smmu_add_device(struct device *dev)
 661 {
 662         struct device_node *np = dev->of_node;
 663         struct of_phandle_args args;
 664         unsigned int index = 0;
 665
 666         while (of_parse_phandle_with_args(np, "iommus", "#iommu-cells", index,
 667                                           &args) == 0) {
 668                 struct tegra_smmu *smmu;
 669
 670                 smmu = tegra_smmu_find(args.np);
 671                 if (smmu) {
 672                         /*
 673                          * Only a single IOMMU master interface is currently
 674                          * supported by the Linux kernel, so abort after the
 675                          * first match.
 676                          */
 677                         dev->archdata.iommu = smmu;
 678                         break;
 679                 }
 680
 681                 index++;
 682         }
 683
 684         return 0;
 685 }
 686
 687 static void tegra_smmu_remove_device(struct device *dev)
 688 {
 689         dev->archdata.iommu = NULL;
 690 }
 691
 692 static const struct iommu_ops tegra_smmu_ops = {
 693         .capable = tegra_smmu_capable,
 694         .domain_alloc = tegra_smmu_domain_alloc,
 695         .domain_free = tegra_smmu_domain_free,
 696         .attach_dev = tegra_smmu_attach_dev,
 697         .detach_dev = tegra_smmu_detach_dev,
 698         .add_device = tegra_smmu_add_device,
 699         .remove_device = tegra_smmu_remove_device,
 700         .map = tegra_smmu_map,
 701         .unmap = tegra_smmu_unmap,
 702         .map_sg = default_iommu_map_sg,
 703         .iova_to_phys = tegra_smmu_iova_to_phys,
 704
 705         .pgsize_bitmap = SZ_4K,
 706 };
 707
 708 static void tegra_smmu_ahb_enable(void)
 709 {
 710         static const struct of_device_id ahb_match[] = {
 711                 { .compatible = "nvidia,tegra30-ahb", },
 712                 { }
 713         };
 714         struct device_node *ahb;
 715
 716         ahb = of_find_matching_node(NULL, ahb_match);
 717         if (ahb) {
 718                 tegra_ahb_enable_smmu(ahb);
 719                 of_node_put(ahb);
 720         }
 721 }
 722
 723 static int tegra_smmu_swgroups_show(struct seq_file *s, void *data)
 724 {
 725         struct tegra_smmu *smmu = s->private;
 726         unsigned int i;
 727         u32 value;
 728
 729         seq_printf(s, "swgroup    enabled  ASID\n");
 730         seq_printf(s, "------------------------\n");
 731
 732         for (i = 0; i < smmu->soc->num_swgroups; i++) {
 733                 const struct tegra_smmu_swgroup *group = &smmu->soc->swgroups[i];
 734                 const char *status;
 735                 unsigned int asid;
 736
 737                 value = smmu_readl(smmu, group->reg);
 738
 739                 if (value & SMMU_ASID_ENABLE)
 740                         status = "yes";
 741                 else
 742                         status = "no";
 743
 744                 asid = value & SMMU_ASID_MASK;
 745
 746                 seq_printf(s, "%-9s  %-7s  %#04x\n", group->name, status,
 747                            asid);
 748         }
 749
 750         return 0;
 751 }
 752
 753 static int tegra_smmu_swgroups_open(struct inode *inode, struct file *file)
 754 {
 755         return single_open(file, tegra_smmu_swgroups_show, inode->i_private);
 756 }
 757
 758 static const struct file_operations tegra_smmu_swgroups_fops = {
 759         .open = tegra_smmu_swgroups_open,
 760         .read = seq_read,
 761         .llseek = seq_lseek,
 762         .release = single_release,
 763 };
 764
 765 static int tegra_smmu_clients_show(struct seq_file *s, void *data)
 766 {
 767         struct tegra_smmu *smmu = s->private;
 768         unsigned int i;
 769         u32 value;
 770
 771         seq_printf(s, "client       enabled\n");
 772         seq_printf(s, "--------------------\n");
 773
 774         for (i = 0; i < smmu->soc->num_clients; i++) {
 775                 const struct tegra_mc_client *client = &smmu->soc->clients[i];
 776                 const char *status;
 777
 778                 value = smmu_readl(smmu, client->smmu.reg);
 779
 780                 if (value & BIT(client->smmu.bit))
 781                         status = "yes";
 782                 else
 783                         status = "no";
 784
 785                 seq_printf(s, "%-12s %s\n", client->name, status);
 786         }
 787
 788         return 0;
 789 }
 790
 791 static int tegra_smmu_clients_open(struct inode *inode, struct file *file)
 792 {
 793         return single_open(file, tegra_smmu_clients_show, inode->i_private);
 794 }
 795
 796 static const struct file_operations tegra_smmu_clients_fops = {
 797         .open = tegra_smmu_clients_open,
 798         .read = seq_read,
 799         .llseek = seq_lseek,
 800         .release = single_release,
 801 };
 802
 803 static void tegra_smmu_debugfs_init(struct tegra_smmu *smmu)
 804 {
 805         smmu->debugfs = debugfs_create_dir("smmu", NULL);
 806         if (!smmu->debugfs)
 807                 return;
 808
 809         debugfs_create_file("swgroups", S_IRUGO, smmu->debugfs, smmu,
 810                             &tegra_smmu_swgroups_fops);
 811         debugfs_create_file("clients", S_IRUGO, smmu->debugfs, smmu,
 812                             &tegra_smmu_clients_fops);
 813 }
 814
 815 static void tegra_smmu_debugfs_exit(struct tegra_smmu *smmu)
 816 {
 817         debugfs_remove_recursive(smmu->debugfs);
 818 }
 819
 820 struct tegra_smmu *tegra_smmu_probe(struct device *dev,
 821                                     const struct tegra_smmu_soc *soc,
 822                                     struct tegra_mc *mc)
 823 {
 824         struct tegra_smmu *smmu;
 825         size_t size;
 826         u32 value;
 827         int err;
 828
 829         /* This can happen on Tegra20 which doesn't have an SMMU */
 830         if (!soc)
 831                 return NULL;
 832
 833         smmu = devm_kzalloc(dev, sizeof(*smmu), GFP_KERNEL);
 834         if (!smmu)
 835                 return ERR_PTR(-ENOMEM);
 836
 837         /*
 838          * This is a bit of a hack. Ideally we'd want to simply return this
 839          * value. However the IOMMU registration process will attempt to add
 840          * all devices to the IOMMU when bus_set_iommu() is called. In order
 841          * not to rely on global variables to track the IOMMU instance, we
 842          * set it here so that it can be looked up from the .add_device()
 843          * callback via the IOMMU device's .drvdata field.
 844          */
 845         mc->smmu = smmu;
 846
 847         size = BITS_TO_LONGS(soc->num_asids) * sizeof(long);
 848
 849         smmu->asids = devm_kzalloc(dev, size, GFP_KERNEL);
 850         if (!smmu->asids)
 851                 return ERR_PTR(-ENOMEM);
 852
 853         mutex_init(&smmu->lock);
 854
 855         smmu->regs = mc->regs;
 856         smmu->soc = soc;
 857         smmu->dev = dev;
 858         smmu->mc = mc;
 859
 860         smmu->pfn_mask = BIT_MASK(mc->soc->num_address_bits - PAGE_SHIFT) - 1;
 861         dev_dbg(dev, "address bits: %u, PFN mask: %#lx\n",
 862                 mc->soc->num_address_bits, smmu->pfn_mask);
 863
 864         value = SMMU_PTC_CONFIG_ENABLE | SMMU_PTC_CONFIG_INDEX_MAP(0x3f);
 865
 866         if (soc->supports_request_limit)
 867                 value |= SMMU_PTC_CONFIG_REQ_LIMIT(8);
 868
 869         smmu_writel(smmu, value, SMMU_PTC_CONFIG);
 870
 871         value = SMMU_TLB_CONFIG_HIT_UNDER_MISS |
 872                 SMMU_TLB_CONFIG_ACTIVE_LINES(0x20);
 873
 874         if (soc->supports_round_robin_arbitration)
 875                 value |= SMMU_TLB_CONFIG_ROUND_ROBIN_ARBITRATION;
 876
 877         smmu_writel(smmu, value, SMMU_TLB_CONFIG);
 878
 879         smmu_flush_ptc(smmu, NULL, 0);
 880         smmu_flush_tlb(smmu);
 881         smmu_writel(smmu, SMMU_CONFIG_ENABLE, SMMU_CONFIG);
 882         smmu_flush(smmu);
 883
 884         tegra_smmu_ahb_enable();
 885
 886         err = bus_set_iommu(&platform_bus_type, &tegra_smmu_ops);
 887         if (err < 0)
 888                 return ERR_PTR(err);
 889
 890         if (IS_ENABLED(CONFIG_DEBUG_FS))
 891                 tegra_smmu_debugfs_init(smmu);
 892
 893         return smmu;
 894 }
 895
 896 void tegra_smmu_remove(struct tegra_smmu *smmu)
 897 {
 898         if (IS_ENABLED(CONFIG_DEBUG_FS))
 899                 tegra_smmu_debugfs_exit(smmu);
 900 }