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