1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Apple DART (Device Address Resolution Table) IOMMU driver 4 * 5 * Copyright (C) 2021 The Asahi Linux Contributors 6 * 7 * Based on arm/arm-smmu/arm-ssmu.c and arm/arm-smmu-v3/arm-smmu-v3.c 8 * Copyright (C) 2013 ARM Limited 9 * Copyright (C) 2015 ARM Limited 10 * and on exynos-iommu.c 11 * Copyright (c) 2011,2016 Samsung Electronics Co., Ltd. 12 */ 13 14 #include <linux/atomic.h> 15 #include <linux/bitfield.h> 16 #include <linux/clk.h> 17 #include <linux/dev_printk.h> 18 #include <linux/dma-mapping.h> 19 #include <linux/err.h> 20 #include <linux/interrupt.h> 21 #include <linux/io-pgtable.h> 22 #include <linux/iommu.h> 23 #include <linux/iopoll.h> 24 #include <linux/module.h> 25 #include <linux/of.h> 26 #include <linux/of_address.h> 27 #include <linux/of_iommu.h> 28 #include <linux/of_platform.h> 29 #include <linux/pci.h> 30 #include <linux/platform_device.h> 31 #include <linux/slab.h> 32 #include <linux/swab.h> 33 #include <linux/types.h> 34 35 #include "dma-iommu.h" 36 37 #define DART_MAX_STREAMS 16 38 #define DART_MAX_TTBR 4 39 #define MAX_DARTS_PER_DEVICE 2 40 41 #define DART_STREAM_ALL 0xffff 42 43 #define DART_PARAMS1 0x00 44 #define DART_PARAMS_PAGE_SHIFT GENMASK(27, 24) 45 46 #define DART_PARAMS2 0x04 47 #define DART_PARAMS_BYPASS_SUPPORT BIT(0) 48 49 #define DART_STREAM_COMMAND 0x20 50 #define DART_STREAM_COMMAND_BUSY BIT(2) 51 #define DART_STREAM_COMMAND_INVALIDATE BIT(20) 52 53 #define DART_STREAM_SELECT 0x34 54 55 #define DART_ERROR 0x40 56 #define DART_ERROR_STREAM GENMASK(27, 24) 57 #define DART_ERROR_CODE GENMASK(11, 0) 58 #define DART_ERROR_FLAG BIT(31) 59 60 #define DART_ERROR_READ_FAULT BIT(4) 61 #define DART_ERROR_WRITE_FAULT BIT(3) 62 #define DART_ERROR_NO_PTE BIT(2) 63 #define DART_ERROR_NO_PMD BIT(1) 64 #define DART_ERROR_NO_TTBR BIT(0) 65 66 #define DART_CONFIG 0x60 67 #define DART_CONFIG_LOCK BIT(15) 68 69 #define DART_STREAM_COMMAND_BUSY_TIMEOUT 100 70 71 #define DART_ERROR_ADDR_HI 0x54 72 #define DART_ERROR_ADDR_LO 0x50 73 74 #define DART_STREAMS_ENABLE 0xfc 75 76 #define DART_TCR(sid) (0x100 + 4 * (sid)) 77 #define DART_TCR_TRANSLATE_ENABLE BIT(7) 78 #define DART_TCR_BYPASS0_ENABLE BIT(8) 79 #define DART_TCR_BYPASS1_ENABLE BIT(12) 80 81 #define DART_TTBR(sid, idx) (0x200 + 16 * (sid) + 4 * (idx)) 82 #define DART_TTBR_VALID BIT(31) 83 #define DART_TTBR_SHIFT 12 84 85 /* 86 * Private structure associated with each DART device. 87 * 88 * @dev: device struct 89 * @regs: mapped MMIO region 90 * @irq: interrupt number, can be shared with other DARTs 91 * @clks: clocks associated with this DART 92 * @num_clks: number of @clks 93 * @lock: lock for hardware operations involving this dart 94 * @pgsize: pagesize supported by this DART 95 * @supports_bypass: indicates if this DART supports bypass mode 96 * @force_bypass: force bypass mode due to pagesize mismatch? 97 * @sid2group: maps stream ids to iommu_groups 98 * @iommu: iommu core device 99 */ 100 struct apple_dart { 101 struct device *dev; 102 103 void __iomem *regs; 104 105 int irq; 106 struct clk_bulk_data *clks; 107 int num_clks; 108 109 spinlock_t lock; 110 111 u32 pgsize; 112 u32 supports_bypass : 1; 113 u32 force_bypass : 1; 114 115 struct iommu_group *sid2group[DART_MAX_STREAMS]; 116 struct iommu_device iommu; 117 }; 118 119 /* 120 * Convenience struct to identify streams. 121 * 122 * The normal variant is used inside apple_dart_master_cfg which isn't written 123 * to concurrently. 124 * The atomic variant is used inside apple_dart_domain where we have to guard 125 * against races from potential parallel calls to attach/detach_device. 126 * Note that even inside the atomic variant the apple_dart pointer is not 127 * protected: This pointer is initialized once under the domain init mutex 128 * and never changed again afterwards. Devices with different dart pointers 129 * cannot be attached to the same domain. 130 * 131 * @dart dart pointer 132 * @sid stream id bitmap 133 */ 134 struct apple_dart_stream_map { 135 struct apple_dart *dart; 136 unsigned long sidmap; 137 }; 138 struct apple_dart_atomic_stream_map { 139 struct apple_dart *dart; 140 atomic64_t sidmap; 141 }; 142 143 /* 144 * This structure is attached to each iommu domain handled by a DART. 145 * 146 * @pgtbl_ops: pagetable ops allocated by io-pgtable 147 * @finalized: true if the domain has been completely initialized 148 * @init_lock: protects domain initialization 149 * @stream_maps: streams attached to this domain (valid for DMA/UNMANAGED only) 150 * @domain: core iommu domain pointer 151 */ 152 struct apple_dart_domain { 153 struct io_pgtable_ops *pgtbl_ops; 154 155 bool finalized; 156 struct mutex init_lock; 157 struct apple_dart_atomic_stream_map stream_maps[MAX_DARTS_PER_DEVICE]; 158 159 struct iommu_domain domain; 160 }; 161 162 /* 163 * This structure is attached to devices with dev_iommu_priv_set() on of_xlate 164 * and contains a list of streams bound to this device. 165 * So far the worst case seen is a single device with two streams 166 * from different darts, such that this simple static array is enough. 167 * 168 * @streams: streams for this device 169 */ 170 struct apple_dart_master_cfg { 171 struct apple_dart_stream_map stream_maps[MAX_DARTS_PER_DEVICE]; 172 }; 173 174 /* 175 * Helper macro to iterate over apple_dart_master_cfg.stream_maps and 176 * apple_dart_domain.stream_maps 177 * 178 * @i int used as loop variable 179 * @base pointer to base struct (apple_dart_master_cfg or apple_dart_domain) 180 * @stream pointer to the apple_dart_streams struct for each loop iteration 181 */ 182 #define for_each_stream_map(i, base, stream_map) \ 183 for (i = 0, stream_map = &(base)->stream_maps[0]; \ 184 i < MAX_DARTS_PER_DEVICE && stream_map->dart; \ 185 stream_map = &(base)->stream_maps[++i]) 186 187 static struct platform_driver apple_dart_driver; 188 static const struct iommu_ops apple_dart_iommu_ops; 189 190 static struct apple_dart_domain *to_dart_domain(struct iommu_domain *dom) 191 { 192 return container_of(dom, struct apple_dart_domain, domain); 193 } 194 195 static void 196 apple_dart_hw_enable_translation(struct apple_dart_stream_map *stream_map) 197 { 198 int sid; 199 200 for_each_set_bit(sid, &stream_map->sidmap, DART_MAX_STREAMS) 201 writel(DART_TCR_TRANSLATE_ENABLE, 202 stream_map->dart->regs + DART_TCR(sid)); 203 } 204 205 static void apple_dart_hw_disable_dma(struct apple_dart_stream_map *stream_map) 206 { 207 int sid; 208 209 for_each_set_bit(sid, &stream_map->sidmap, DART_MAX_STREAMS) 210 writel(0, stream_map->dart->regs + DART_TCR(sid)); 211 } 212 213 static void 214 apple_dart_hw_enable_bypass(struct apple_dart_stream_map *stream_map) 215 { 216 int sid; 217 218 WARN_ON(!stream_map->dart->supports_bypass); 219 for_each_set_bit(sid, &stream_map->sidmap, DART_MAX_STREAMS) 220 writel(DART_TCR_BYPASS0_ENABLE | DART_TCR_BYPASS1_ENABLE, 221 stream_map->dart->regs + DART_TCR(sid)); 222 } 223 224 static void apple_dart_hw_set_ttbr(struct apple_dart_stream_map *stream_map, 225 u8 idx, phys_addr_t paddr) 226 { 227 int sid; 228 229 WARN_ON(paddr & ((1 << DART_TTBR_SHIFT) - 1)); 230 for_each_set_bit(sid, &stream_map->sidmap, DART_MAX_STREAMS) 231 writel(DART_TTBR_VALID | (paddr >> DART_TTBR_SHIFT), 232 stream_map->dart->regs + DART_TTBR(sid, idx)); 233 } 234 235 static void apple_dart_hw_clear_ttbr(struct apple_dart_stream_map *stream_map, 236 u8 idx) 237 { 238 int sid; 239 240 for_each_set_bit(sid, &stream_map->sidmap, DART_MAX_STREAMS) 241 writel(0, stream_map->dart->regs + DART_TTBR(sid, idx)); 242 } 243 244 static void 245 apple_dart_hw_clear_all_ttbrs(struct apple_dart_stream_map *stream_map) 246 { 247 int i; 248 249 for (i = 0; i < DART_MAX_TTBR; ++i) 250 apple_dart_hw_clear_ttbr(stream_map, i); 251 } 252 253 static int 254 apple_dart_hw_stream_command(struct apple_dart_stream_map *stream_map, 255 u32 command) 256 { 257 unsigned long flags; 258 int ret; 259 u32 command_reg; 260 261 spin_lock_irqsave(&stream_map->dart->lock, flags); 262 263 writel(stream_map->sidmap, stream_map->dart->regs + DART_STREAM_SELECT); 264 writel(command, stream_map->dart->regs + DART_STREAM_COMMAND); 265 266 ret = readl_poll_timeout_atomic( 267 stream_map->dart->regs + DART_STREAM_COMMAND, command_reg, 268 !(command_reg & DART_STREAM_COMMAND_BUSY), 1, 269 DART_STREAM_COMMAND_BUSY_TIMEOUT); 270 271 spin_unlock_irqrestore(&stream_map->dart->lock, flags); 272 273 if (ret) { 274 dev_err(stream_map->dart->dev, 275 "busy bit did not clear after command %x for streams %lx\n", 276 command, stream_map->sidmap); 277 return ret; 278 } 279 280 return 0; 281 } 282 283 static int 284 apple_dart_hw_invalidate_tlb(struct apple_dart_stream_map *stream_map) 285 { 286 return apple_dart_hw_stream_command(stream_map, 287 DART_STREAM_COMMAND_INVALIDATE); 288 } 289 290 static int apple_dart_hw_reset(struct apple_dart *dart) 291 { 292 u32 config; 293 struct apple_dart_stream_map stream_map; 294 295 config = readl(dart->regs + DART_CONFIG); 296 if (config & DART_CONFIG_LOCK) { 297 dev_err(dart->dev, "DART is locked down until reboot: %08x\n", 298 config); 299 return -EINVAL; 300 } 301 302 stream_map.dart = dart; 303 stream_map.sidmap = DART_STREAM_ALL; 304 apple_dart_hw_disable_dma(&stream_map); 305 apple_dart_hw_clear_all_ttbrs(&stream_map); 306 307 /* enable all streams globally since TCR is used to control isolation */ 308 writel(DART_STREAM_ALL, dart->regs + DART_STREAMS_ENABLE); 309 310 /* clear any pending errors before the interrupt is unmasked */ 311 writel(readl(dart->regs + DART_ERROR), dart->regs + DART_ERROR); 312 313 return apple_dart_hw_invalidate_tlb(&stream_map); 314 } 315 316 static void apple_dart_domain_flush_tlb(struct apple_dart_domain *domain) 317 { 318 int i; 319 struct apple_dart_atomic_stream_map *domain_stream_map; 320 struct apple_dart_stream_map stream_map; 321 322 for_each_stream_map(i, domain, domain_stream_map) { 323 stream_map.dart = domain_stream_map->dart; 324 stream_map.sidmap = atomic64_read(&domain_stream_map->sidmap); 325 apple_dart_hw_invalidate_tlb(&stream_map); 326 } 327 } 328 329 static void apple_dart_flush_iotlb_all(struct iommu_domain *domain) 330 { 331 apple_dart_domain_flush_tlb(to_dart_domain(domain)); 332 } 333 334 static void apple_dart_iotlb_sync(struct iommu_domain *domain, 335 struct iommu_iotlb_gather *gather) 336 { 337 apple_dart_domain_flush_tlb(to_dart_domain(domain)); 338 } 339 340 static void apple_dart_iotlb_sync_map(struct iommu_domain *domain, 341 unsigned long iova, size_t size) 342 { 343 apple_dart_domain_flush_tlb(to_dart_domain(domain)); 344 } 345 346 static phys_addr_t apple_dart_iova_to_phys(struct iommu_domain *domain, 347 dma_addr_t iova) 348 { 349 struct apple_dart_domain *dart_domain = to_dart_domain(domain); 350 struct io_pgtable_ops *ops = dart_domain->pgtbl_ops; 351 352 if (!ops) 353 return 0; 354 355 return ops->iova_to_phys(ops, iova); 356 } 357 358 static int apple_dart_map_pages(struct iommu_domain *domain, unsigned long iova, 359 phys_addr_t paddr, size_t pgsize, 360 size_t pgcount, int prot, gfp_t gfp, 361 size_t *mapped) 362 { 363 struct apple_dart_domain *dart_domain = to_dart_domain(domain); 364 struct io_pgtable_ops *ops = dart_domain->pgtbl_ops; 365 366 if (!ops) 367 return -ENODEV; 368 369 return ops->map_pages(ops, iova, paddr, pgsize, pgcount, prot, gfp, 370 mapped); 371 } 372 373 static size_t apple_dart_unmap_pages(struct iommu_domain *domain, 374 unsigned long iova, size_t pgsize, 375 size_t pgcount, 376 struct iommu_iotlb_gather *gather) 377 { 378 struct apple_dart_domain *dart_domain = to_dart_domain(domain); 379 struct io_pgtable_ops *ops = dart_domain->pgtbl_ops; 380 381 return ops->unmap_pages(ops, iova, pgsize, pgcount, gather); 382 } 383 384 static void 385 apple_dart_setup_translation(struct apple_dart_domain *domain, 386 struct apple_dart_stream_map *stream_map) 387 { 388 int i; 389 struct io_pgtable_cfg *pgtbl_cfg = 390 &io_pgtable_ops_to_pgtable(domain->pgtbl_ops)->cfg; 391 392 for (i = 0; i < pgtbl_cfg->apple_dart_cfg.n_ttbrs; ++i) 393 apple_dart_hw_set_ttbr(stream_map, i, 394 pgtbl_cfg->apple_dart_cfg.ttbr[i]); 395 for (; i < DART_MAX_TTBR; ++i) 396 apple_dart_hw_clear_ttbr(stream_map, i); 397 398 apple_dart_hw_enable_translation(stream_map); 399 apple_dart_hw_invalidate_tlb(stream_map); 400 } 401 402 static int apple_dart_finalize_domain(struct iommu_domain *domain, 403 struct apple_dart_master_cfg *cfg) 404 { 405 struct apple_dart_domain *dart_domain = to_dart_domain(domain); 406 struct apple_dart *dart = cfg->stream_maps[0].dart; 407 struct io_pgtable_cfg pgtbl_cfg; 408 int ret = 0; 409 int i; 410 411 mutex_lock(&dart_domain->init_lock); 412 413 if (dart_domain->finalized) 414 goto done; 415 416 for (i = 0; i < MAX_DARTS_PER_DEVICE; ++i) { 417 dart_domain->stream_maps[i].dart = cfg->stream_maps[i].dart; 418 atomic64_set(&dart_domain->stream_maps[i].sidmap, 419 cfg->stream_maps[i].sidmap); 420 } 421 422 pgtbl_cfg = (struct io_pgtable_cfg){ 423 .pgsize_bitmap = dart->pgsize, 424 .ias = 32, 425 .oas = 36, 426 .coherent_walk = 1, 427 .iommu_dev = dart->dev, 428 }; 429 430 dart_domain->pgtbl_ops = 431 alloc_io_pgtable_ops(APPLE_DART, &pgtbl_cfg, domain); 432 if (!dart_domain->pgtbl_ops) { 433 ret = -ENOMEM; 434 goto done; 435 } 436 437 domain->pgsize_bitmap = pgtbl_cfg.pgsize_bitmap; 438 domain->geometry.aperture_start = 0; 439 domain->geometry.aperture_end = DMA_BIT_MASK(32); 440 domain->geometry.force_aperture = true; 441 442 dart_domain->finalized = true; 443 444 done: 445 mutex_unlock(&dart_domain->init_lock); 446 return ret; 447 } 448 449 static int 450 apple_dart_mod_streams(struct apple_dart_atomic_stream_map *domain_maps, 451 struct apple_dart_stream_map *master_maps, 452 bool add_streams) 453 { 454 int i; 455 456 for (i = 0; i < MAX_DARTS_PER_DEVICE; ++i) { 457 if (domain_maps[i].dart != master_maps[i].dart) 458 return -EINVAL; 459 } 460 461 for (i = 0; i < MAX_DARTS_PER_DEVICE; ++i) { 462 if (!domain_maps[i].dart) 463 break; 464 if (add_streams) 465 atomic64_or(master_maps[i].sidmap, 466 &domain_maps[i].sidmap); 467 else 468 atomic64_and(~master_maps[i].sidmap, 469 &domain_maps[i].sidmap); 470 } 471 472 return 0; 473 } 474 475 static int apple_dart_domain_add_streams(struct apple_dart_domain *domain, 476 struct apple_dart_master_cfg *cfg) 477 { 478 return apple_dart_mod_streams(domain->stream_maps, cfg->stream_maps, 479 true); 480 } 481 482 static int apple_dart_domain_remove_streams(struct apple_dart_domain *domain, 483 struct apple_dart_master_cfg *cfg) 484 { 485 return apple_dart_mod_streams(domain->stream_maps, cfg->stream_maps, 486 false); 487 } 488 489 static int apple_dart_attach_dev(struct iommu_domain *domain, 490 struct device *dev) 491 { 492 int ret, i; 493 struct apple_dart_stream_map *stream_map; 494 struct apple_dart_master_cfg *cfg = dev_iommu_priv_get(dev); 495 struct apple_dart_domain *dart_domain = to_dart_domain(domain); 496 497 if (cfg->stream_maps[0].dart->force_bypass && 498 domain->type != IOMMU_DOMAIN_IDENTITY) 499 return -EINVAL; 500 if (!cfg->stream_maps[0].dart->supports_bypass && 501 domain->type == IOMMU_DOMAIN_IDENTITY) 502 return -EINVAL; 503 504 ret = apple_dart_finalize_domain(domain, cfg); 505 if (ret) 506 return ret; 507 508 switch (domain->type) { 509 case IOMMU_DOMAIN_DMA: 510 case IOMMU_DOMAIN_UNMANAGED: 511 ret = apple_dart_domain_add_streams(dart_domain, cfg); 512 if (ret) 513 return ret; 514 515 for_each_stream_map(i, cfg, stream_map) 516 apple_dart_setup_translation(dart_domain, stream_map); 517 break; 518 case IOMMU_DOMAIN_BLOCKED: 519 for_each_stream_map(i, cfg, stream_map) 520 apple_dart_hw_disable_dma(stream_map); 521 break; 522 case IOMMU_DOMAIN_IDENTITY: 523 for_each_stream_map(i, cfg, stream_map) 524 apple_dart_hw_enable_bypass(stream_map); 525 break; 526 } 527 528 return ret; 529 } 530 531 static void apple_dart_detach_dev(struct iommu_domain *domain, 532 struct device *dev) 533 { 534 int i; 535 struct apple_dart_stream_map *stream_map; 536 struct apple_dart_master_cfg *cfg = dev_iommu_priv_get(dev); 537 struct apple_dart_domain *dart_domain = to_dart_domain(domain); 538 539 for_each_stream_map(i, cfg, stream_map) 540 apple_dart_hw_disable_dma(stream_map); 541 542 if (domain->type == IOMMU_DOMAIN_DMA || 543 domain->type == IOMMU_DOMAIN_UNMANAGED) 544 apple_dart_domain_remove_streams(dart_domain, cfg); 545 } 546 547 static struct iommu_device *apple_dart_probe_device(struct device *dev) 548 { 549 struct apple_dart_master_cfg *cfg = dev_iommu_priv_get(dev); 550 struct apple_dart_stream_map *stream_map; 551 int i; 552 553 if (!cfg) 554 return ERR_PTR(-ENODEV); 555 556 for_each_stream_map(i, cfg, stream_map) 557 device_link_add( 558 dev, stream_map->dart->dev, 559 DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_SUPPLIER); 560 561 return &cfg->stream_maps[0].dart->iommu; 562 } 563 564 static void apple_dart_release_device(struct device *dev) 565 { 566 struct apple_dart_master_cfg *cfg = dev_iommu_priv_get(dev); 567 568 dev_iommu_priv_set(dev, NULL); 569 kfree(cfg); 570 } 571 572 static struct iommu_domain *apple_dart_domain_alloc(unsigned int type) 573 { 574 struct apple_dart_domain *dart_domain; 575 576 if (type != IOMMU_DOMAIN_DMA && type != IOMMU_DOMAIN_UNMANAGED && 577 type != IOMMU_DOMAIN_IDENTITY && type != IOMMU_DOMAIN_BLOCKED) 578 return NULL; 579 580 dart_domain = kzalloc(sizeof(*dart_domain), GFP_KERNEL); 581 if (!dart_domain) 582 return NULL; 583 584 mutex_init(&dart_domain->init_lock); 585 586 /* no need to allocate pgtbl_ops or do any other finalization steps */ 587 if (type == IOMMU_DOMAIN_IDENTITY || type == IOMMU_DOMAIN_BLOCKED) 588 dart_domain->finalized = true; 589 590 return &dart_domain->domain; 591 } 592 593 static void apple_dart_domain_free(struct iommu_domain *domain) 594 { 595 struct apple_dart_domain *dart_domain = to_dart_domain(domain); 596 597 if (dart_domain->pgtbl_ops) 598 free_io_pgtable_ops(dart_domain->pgtbl_ops); 599 600 kfree(dart_domain); 601 } 602 603 static int apple_dart_of_xlate(struct device *dev, struct of_phandle_args *args) 604 { 605 struct apple_dart_master_cfg *cfg = dev_iommu_priv_get(dev); 606 struct platform_device *iommu_pdev = of_find_device_by_node(args->np); 607 struct apple_dart *dart = platform_get_drvdata(iommu_pdev); 608 struct apple_dart *cfg_dart; 609 int i, sid; 610 611 if (args->args_count != 1) 612 return -EINVAL; 613 sid = args->args[0]; 614 615 if (!cfg) 616 cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 617 if (!cfg) 618 return -ENOMEM; 619 dev_iommu_priv_set(dev, cfg); 620 621 cfg_dart = cfg->stream_maps[0].dart; 622 if (cfg_dart) { 623 if (cfg_dart->supports_bypass != dart->supports_bypass) 624 return -EINVAL; 625 if (cfg_dart->force_bypass != dart->force_bypass) 626 return -EINVAL; 627 if (cfg_dart->pgsize != dart->pgsize) 628 return -EINVAL; 629 } 630 631 for (i = 0; i < MAX_DARTS_PER_DEVICE; ++i) { 632 if (cfg->stream_maps[i].dart == dart) { 633 cfg->stream_maps[i].sidmap |= 1 << sid; 634 return 0; 635 } 636 } 637 for (i = 0; i < MAX_DARTS_PER_DEVICE; ++i) { 638 if (!cfg->stream_maps[i].dart) { 639 cfg->stream_maps[i].dart = dart; 640 cfg->stream_maps[i].sidmap = 1 << sid; 641 return 0; 642 } 643 } 644 645 return -EINVAL; 646 } 647 648 static DEFINE_MUTEX(apple_dart_groups_lock); 649 650 static void apple_dart_release_group(void *iommu_data) 651 { 652 int i, sid; 653 struct apple_dart_stream_map *stream_map; 654 struct apple_dart_master_cfg *group_master_cfg = iommu_data; 655 656 mutex_lock(&apple_dart_groups_lock); 657 658 for_each_stream_map(i, group_master_cfg, stream_map) 659 for_each_set_bit(sid, &stream_map->sidmap, DART_MAX_STREAMS) 660 stream_map->dart->sid2group[sid] = NULL; 661 662 kfree(iommu_data); 663 mutex_unlock(&apple_dart_groups_lock); 664 } 665 666 static struct iommu_group *apple_dart_device_group(struct device *dev) 667 { 668 int i, sid; 669 struct apple_dart_master_cfg *cfg = dev_iommu_priv_get(dev); 670 struct apple_dart_stream_map *stream_map; 671 struct apple_dart_master_cfg *group_master_cfg; 672 struct iommu_group *group = NULL; 673 struct iommu_group *res = ERR_PTR(-EINVAL); 674 675 mutex_lock(&apple_dart_groups_lock); 676 677 for_each_stream_map(i, cfg, stream_map) { 678 for_each_set_bit(sid, &stream_map->sidmap, DART_MAX_STREAMS) { 679 struct iommu_group *stream_group = 680 stream_map->dart->sid2group[sid]; 681 682 if (group && group != stream_group) { 683 res = ERR_PTR(-EINVAL); 684 goto out; 685 } 686 687 group = stream_group; 688 } 689 } 690 691 if (group) { 692 res = iommu_group_ref_get(group); 693 goto out; 694 } 695 696 #ifdef CONFIG_PCI 697 if (dev_is_pci(dev)) 698 group = pci_device_group(dev); 699 else 700 #endif 701 group = generic_device_group(dev); 702 703 res = ERR_PTR(-ENOMEM); 704 if (!group) 705 goto out; 706 707 group_master_cfg = kmemdup(cfg, sizeof(*group_master_cfg), GFP_KERNEL); 708 if (!group_master_cfg) { 709 iommu_group_put(group); 710 goto out; 711 } 712 713 iommu_group_set_iommudata(group, group_master_cfg, 714 apple_dart_release_group); 715 716 for_each_stream_map(i, cfg, stream_map) 717 for_each_set_bit(sid, &stream_map->sidmap, DART_MAX_STREAMS) 718 stream_map->dart->sid2group[sid] = group; 719 720 res = group; 721 722 out: 723 mutex_unlock(&apple_dart_groups_lock); 724 return res; 725 } 726 727 static int apple_dart_def_domain_type(struct device *dev) 728 { 729 struct apple_dart_master_cfg *cfg = dev_iommu_priv_get(dev); 730 731 if (cfg->stream_maps[0].dart->force_bypass) 732 return IOMMU_DOMAIN_IDENTITY; 733 if (!cfg->stream_maps[0].dart->supports_bypass) 734 return IOMMU_DOMAIN_DMA; 735 736 return 0; 737 } 738 739 #ifndef CONFIG_PCIE_APPLE_MSI_DOORBELL_ADDR 740 /* Keep things compiling when CONFIG_PCI_APPLE isn't selected */ 741 #define CONFIG_PCIE_APPLE_MSI_DOORBELL_ADDR 0 742 #endif 743 #define DOORBELL_ADDR (CONFIG_PCIE_APPLE_MSI_DOORBELL_ADDR & PAGE_MASK) 744 745 static void apple_dart_get_resv_regions(struct device *dev, 746 struct list_head *head) 747 { 748 if (IS_ENABLED(CONFIG_PCIE_APPLE) && dev_is_pci(dev)) { 749 struct iommu_resv_region *region; 750 int prot = IOMMU_WRITE | IOMMU_NOEXEC | IOMMU_MMIO; 751 752 region = iommu_alloc_resv_region(DOORBELL_ADDR, 753 PAGE_SIZE, prot, 754 IOMMU_RESV_MSI); 755 if (!region) 756 return; 757 758 list_add_tail(®ion->list, head); 759 } 760 761 iommu_dma_get_resv_regions(dev, head); 762 } 763 764 static const struct iommu_ops apple_dart_iommu_ops = { 765 .domain_alloc = apple_dart_domain_alloc, 766 .probe_device = apple_dart_probe_device, 767 .release_device = apple_dart_release_device, 768 .device_group = apple_dart_device_group, 769 .of_xlate = apple_dart_of_xlate, 770 .def_domain_type = apple_dart_def_domain_type, 771 .get_resv_regions = apple_dart_get_resv_regions, 772 .pgsize_bitmap = -1UL, /* Restricted during dart probe */ 773 .owner = THIS_MODULE, 774 .default_domain_ops = &(const struct iommu_domain_ops) { 775 .attach_dev = apple_dart_attach_dev, 776 .detach_dev = apple_dart_detach_dev, 777 .map_pages = apple_dart_map_pages, 778 .unmap_pages = apple_dart_unmap_pages, 779 .flush_iotlb_all = apple_dart_flush_iotlb_all, 780 .iotlb_sync = apple_dart_iotlb_sync, 781 .iotlb_sync_map = apple_dart_iotlb_sync_map, 782 .iova_to_phys = apple_dart_iova_to_phys, 783 .free = apple_dart_domain_free, 784 } 785 }; 786 787 static irqreturn_t apple_dart_irq(int irq, void *dev) 788 { 789 struct apple_dart *dart = dev; 790 const char *fault_name = NULL; 791 u32 error = readl(dart->regs + DART_ERROR); 792 u32 error_code = FIELD_GET(DART_ERROR_CODE, error); 793 u32 addr_lo = readl(dart->regs + DART_ERROR_ADDR_LO); 794 u32 addr_hi = readl(dart->regs + DART_ERROR_ADDR_HI); 795 u64 addr = addr_lo | (((u64)addr_hi) << 32); 796 u8 stream_idx = FIELD_GET(DART_ERROR_STREAM, error); 797 798 if (!(error & DART_ERROR_FLAG)) 799 return IRQ_NONE; 800 801 /* there should only be a single bit set but let's use == to be sure */ 802 if (error_code == DART_ERROR_READ_FAULT) 803 fault_name = "READ FAULT"; 804 else if (error_code == DART_ERROR_WRITE_FAULT) 805 fault_name = "WRITE FAULT"; 806 else if (error_code == DART_ERROR_NO_PTE) 807 fault_name = "NO PTE FOR IOVA"; 808 else if (error_code == DART_ERROR_NO_PMD) 809 fault_name = "NO PMD FOR IOVA"; 810 else if (error_code == DART_ERROR_NO_TTBR) 811 fault_name = "NO TTBR FOR IOVA"; 812 else 813 fault_name = "unknown"; 814 815 dev_err_ratelimited( 816 dart->dev, 817 "translation fault: status:0x%x stream:%d code:0x%x (%s) at 0x%llx", 818 error, stream_idx, error_code, fault_name, addr); 819 820 writel(error, dart->regs + DART_ERROR); 821 return IRQ_HANDLED; 822 } 823 824 static int apple_dart_probe(struct platform_device *pdev) 825 { 826 int ret; 827 u32 dart_params[2]; 828 struct resource *res; 829 struct apple_dart *dart; 830 struct device *dev = &pdev->dev; 831 832 dart = devm_kzalloc(dev, sizeof(*dart), GFP_KERNEL); 833 if (!dart) 834 return -ENOMEM; 835 836 dart->dev = dev; 837 spin_lock_init(&dart->lock); 838 839 dart->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res); 840 if (IS_ERR(dart->regs)) 841 return PTR_ERR(dart->regs); 842 843 if (resource_size(res) < 0x4000) { 844 dev_err(dev, "MMIO region too small (%pr)\n", res); 845 return -EINVAL; 846 } 847 848 dart->irq = platform_get_irq(pdev, 0); 849 if (dart->irq < 0) 850 return -ENODEV; 851 852 ret = devm_clk_bulk_get_all(dev, &dart->clks); 853 if (ret < 0) 854 return ret; 855 dart->num_clks = ret; 856 857 ret = clk_bulk_prepare_enable(dart->num_clks, dart->clks); 858 if (ret) 859 return ret; 860 861 ret = apple_dart_hw_reset(dart); 862 if (ret) 863 goto err_clk_disable; 864 865 dart_params[0] = readl(dart->regs + DART_PARAMS1); 866 dart_params[1] = readl(dart->regs + DART_PARAMS2); 867 dart->pgsize = 1 << FIELD_GET(DART_PARAMS_PAGE_SHIFT, dart_params[0]); 868 dart->supports_bypass = dart_params[1] & DART_PARAMS_BYPASS_SUPPORT; 869 dart->force_bypass = dart->pgsize > PAGE_SIZE; 870 871 ret = request_irq(dart->irq, apple_dart_irq, IRQF_SHARED, 872 "apple-dart fault handler", dart); 873 if (ret) 874 goto err_clk_disable; 875 876 platform_set_drvdata(pdev, dart); 877 878 ret = iommu_device_sysfs_add(&dart->iommu, dev, NULL, "apple-dart.%s", 879 dev_name(&pdev->dev)); 880 if (ret) 881 goto err_free_irq; 882 883 ret = iommu_device_register(&dart->iommu, &apple_dart_iommu_ops, dev); 884 if (ret) 885 goto err_sysfs_remove; 886 887 dev_info( 888 &pdev->dev, 889 "DART [pagesize %x, bypass support: %d, bypass forced: %d] initialized\n", 890 dart->pgsize, dart->supports_bypass, dart->force_bypass); 891 return 0; 892 893 err_sysfs_remove: 894 iommu_device_sysfs_remove(&dart->iommu); 895 err_free_irq: 896 free_irq(dart->irq, dart); 897 err_clk_disable: 898 clk_bulk_disable_unprepare(dart->num_clks, dart->clks); 899 900 return ret; 901 } 902 903 static int apple_dart_remove(struct platform_device *pdev) 904 { 905 struct apple_dart *dart = platform_get_drvdata(pdev); 906 907 apple_dart_hw_reset(dart); 908 free_irq(dart->irq, dart); 909 910 iommu_device_unregister(&dart->iommu); 911 iommu_device_sysfs_remove(&dart->iommu); 912 913 clk_bulk_disable_unprepare(dart->num_clks, dart->clks); 914 915 return 0; 916 } 917 918 static const struct of_device_id apple_dart_of_match[] = { 919 { .compatible = "apple,t8103-dart", .data = NULL }, 920 {}, 921 }; 922 MODULE_DEVICE_TABLE(of, apple_dart_of_match); 923 924 static struct platform_driver apple_dart_driver = { 925 .driver = { 926 .name = "apple-dart", 927 .of_match_table = apple_dart_of_match, 928 .suppress_bind_attrs = true, 929 }, 930 .probe = apple_dart_probe, 931 .remove = apple_dart_remove, 932 }; 933 934 module_platform_driver(apple_dart_driver); 935 936 MODULE_DESCRIPTION("IOMMU API for Apple's DART"); 937 MODULE_AUTHOR("Sven Peter <sven@svenpeter.dev>"); 938 MODULE_LICENSE("GPL v2"); 939