drivers/gpu/host1x/dev.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Tegra host1x driver
   4  *
   5  * Copyright (c) 2010-2013, NVIDIA Corporation.
   6  */
   7
   8 #include <linux/clk.h>
   9 #include <linux/dma-mapping.h>
  10 #include <linux/io.h>
  11 #include <linux/list.h>
  12 #include <linux/module.h>
  13 #include <linux/of_device.h>
  14 #include <linux/of.h>
  15 #include <linux/slab.h>
  16
  17 #define CREATE_TRACE_POINTS
  18 #include <trace/events/host1x.h>
  19 #undef CREATE_TRACE_POINTS
  20
  21 #include "bus.h"
  22 #include "channel.h"
  23 #include "debug.h"
  24 #include "dev.h"
  25 #include "intr.h"
  26
  27 #include "hw/host1x01.h"
  28 #include "hw/host1x02.h"
  29 #include "hw/host1x04.h"
  30 #include "hw/host1x05.h"
  31 #include "hw/host1x06.h"
  32 #include "hw/host1x07.h"
  33
  34 void host1x_hypervisor_writel(struct host1x *host1x, u32 v, u32 r)
  35 {
  36         writel(v, host1x->hv_regs + r);
  37 }
  38
  39 u32 host1x_hypervisor_readl(struct host1x *host1x, u32 r)
  40 {
  41         return readl(host1x->hv_regs + r);
  42 }
  43
  44 void host1x_sync_writel(struct host1x *host1x, u32 v, u32 r)
  45 {
  46         void __iomem *sync_regs = host1x->regs + host1x->info->sync_offset;
  47
  48         writel(v, sync_regs + r);
  49 }
  50
  51 u32 host1x_sync_readl(struct host1x *host1x, u32 r)
  52 {
  53         void __iomem *sync_regs = host1x->regs + host1x->info->sync_offset;
  54
  55         return readl(sync_regs + r);
  56 }
  57
  58 void host1x_ch_writel(struct host1x_channel *ch, u32 v, u32 r)
  59 {
  60         writel(v, ch->regs + r);
  61 }
  62
  63 u32 host1x_ch_readl(struct host1x_channel *ch, u32 r)
  64 {
  65         return readl(ch->regs + r);
  66 }
  67
  68 static const struct host1x_info host1x01_info = {
  69         .nb_channels = 8,
  70         .nb_pts = 32,
  71         .nb_mlocks = 16,
  72         .nb_bases = 8,
  73         .init = host1x01_init,
  74         .sync_offset = 0x3000,
  75         .dma_mask = DMA_BIT_MASK(32),
  76         .has_wide_gather = false,
  77         .has_hypervisor = false,
  78         .num_sid_entries = 0,
  79         .sid_table = NULL,
  80 };
  81
  82 static const struct host1x_info host1x02_info = {
  83         .nb_channels = 9,
  84         .nb_pts = 32,
  85         .nb_mlocks = 16,
  86         .nb_bases = 12,
  87         .init = host1x02_init,
  88         .sync_offset = 0x3000,
  89         .dma_mask = DMA_BIT_MASK(32),
  90         .has_wide_gather = false,
  91         .has_hypervisor = false,
  92         .num_sid_entries = 0,
  93         .sid_table = NULL,
  94 };
  95
  96 static const struct host1x_info host1x04_info = {
  97         .nb_channels = 12,
  98         .nb_pts = 192,
  99         .nb_mlocks = 16,
 100         .nb_bases = 64,
 101         .init = host1x04_init,
 102         .sync_offset = 0x2100,
 103         .dma_mask = DMA_BIT_MASK(34),
 104         .has_wide_gather = false,
 105         .has_hypervisor = false,
 106         .num_sid_entries = 0,
 107         .sid_table = NULL,
 108 };
 109
 110 static const struct host1x_info host1x05_info = {
 111         .nb_channels = 14,
 112         .nb_pts = 192,
 113         .nb_mlocks = 16,
 114         .nb_bases = 64,
 115         .init = host1x05_init,
 116         .sync_offset = 0x2100,
 117         .dma_mask = DMA_BIT_MASK(34),
 118         .has_wide_gather = false,
 119         .has_hypervisor = false,
 120         .num_sid_entries = 0,
 121         .sid_table = NULL,
 122 };
 123
 124 static const struct host1x_sid_entry tegra186_sid_table[] = {
 125         {
 126                 /* VIC */
 127                 .base = 0x1af0,
 128                 .offset = 0x30,
 129                 .limit = 0x34
 130         },
 131 };
 132
 133 static const struct host1x_info host1x06_info = {
 134         .nb_channels = 63,
 135         .nb_pts = 576,
 136         .nb_mlocks = 24,
 137         .nb_bases = 16,
 138         .init = host1x06_init,
 139         .sync_offset = 0x0,
 140         .dma_mask = DMA_BIT_MASK(40),
 141         .has_wide_gather = true,
 142         .has_hypervisor = true,
 143         .num_sid_entries = ARRAY_SIZE(tegra186_sid_table),
 144         .sid_table = tegra186_sid_table,
 145 };
 146
 147 static const struct host1x_sid_entry tegra194_sid_table[] = {
 148         {
 149                 /* VIC */
 150                 .base = 0x1af0,
 151                 .offset = 0x30,
 152                 .limit = 0x34
 153         },
 154 };
 155
 156 static const struct host1x_info host1x07_info = {
 157         .nb_channels = 63,
 158         .nb_pts = 704,
 159         .nb_mlocks = 32,
 160         .nb_bases = 0,
 161         .init = host1x07_init,
 162         .sync_offset = 0x0,
 163         .dma_mask = DMA_BIT_MASK(40),
 164         .has_wide_gather = true,
 165         .has_hypervisor = true,
 166         .num_sid_entries = ARRAY_SIZE(tegra194_sid_table),
 167         .sid_table = tegra194_sid_table,
 168 };
 169
 170 static const struct of_device_id host1x_of_match[] = {
 171         { .compatible = "nvidia,tegra194-host1x", .data = &host1x07_info, },
 172         { .compatible = "nvidia,tegra186-host1x", .data = &host1x06_info, },
 173         { .compatible = "nvidia,tegra210-host1x", .data = &host1x05_info, },
 174         { .compatible = "nvidia,tegra124-host1x", .data = &host1x04_info, },
 175         { .compatible = "nvidia,tegra114-host1x", .data = &host1x02_info, },
 176         { .compatible = "nvidia,tegra30-host1x", .data = &host1x01_info, },
 177         { .compatible = "nvidia,tegra20-host1x", .data = &host1x01_info, },
 178         { },
 179 };
 180 MODULE_DEVICE_TABLE(of, host1x_of_match);
 181
 182 static void host1x_setup_sid_table(struct host1x *host)
 183 {
 184         const struct host1x_info *info = host->info;
 185         unsigned int i;
 186
 187         for (i = 0; i < info->num_sid_entries; i++) {
 188                 const struct host1x_sid_entry *entry = &info->sid_table[i];
 189
 190                 host1x_hypervisor_writel(host, entry->offset, entry->base);
 191                 host1x_hypervisor_writel(host, entry->limit, entry->base + 4);
 192         }
 193 }
 194
 195 static struct iommu_domain *host1x_iommu_attach(struct host1x *host)
 196 {
 197         struct iommu_domain *domain = iommu_get_domain_for_dev(host->dev);
 198         int err;
 199
 200         /*
 201          * If the host1x firewall is enabled, there's no need to enable IOMMU
 202          * support. Similarly, if host1x is already attached to an IOMMU (via
 203          * the DMA API), don't try to attach again.
 204          */
 205         if (IS_ENABLED(CONFIG_TEGRA_HOST1X_FIREWALL) || domain)
 206                 return domain;
 207
 208         host->group = iommu_group_get(host->dev);
 209         if (host->group) {
 210                 struct iommu_domain_geometry *geometry;
 211                 dma_addr_t start, end;
 212                 unsigned long order;
 213
 214                 err = iova_cache_get();
 215                 if (err < 0)
 216                         goto put_group;
 217
 218                 host->domain = iommu_domain_alloc(&platform_bus_type);
 219                 if (!host->domain) {
 220                         err = -ENOMEM;
 221                         goto put_cache;
 222                 }
 223
 224                 err = iommu_attach_group(host->domain, host->group);
 225                 if (err) {
 226                         if (err == -ENODEV)
 227                                 err = 0;
 228
 229                         goto free_domain;
 230                 }
 231
 232                 geometry = &host->domain->geometry;
 233                 start = geometry->aperture_start & host->info->dma_mask;
 234                 end = geometry->aperture_end & host->info->dma_mask;
 235
 236                 order = __ffs(host->domain->pgsize_bitmap);
 237                 init_iova_domain(&host->iova, 1UL << order, start >> order);
 238                 host->iova_end = end;
 239
 240                 domain = host->domain;
 241         }
 242
 243         return domain;
 244
 245 free_domain:
 246         iommu_domain_free(host->domain);
 247         host->domain = NULL;
 248 put_cache:
 249         iova_cache_put();
 250 put_group:
 251         iommu_group_put(host->group);
 252         host->group = NULL;
 253
 254         return ERR_PTR(err);
 255 }
 256
 257 static int host1x_iommu_init(struct host1x *host)
 258 {
 259         u64 mask = host->info->dma_mask;
 260         struct iommu_domain *domain;
 261         int err;
 262
 263         domain = host1x_iommu_attach(host);
 264         if (IS_ERR(domain)) {
 265                 err = PTR_ERR(domain);
 266                 dev_err(host->dev, "failed to attach to IOMMU: %d\n", err);
 267                 return err;
 268         }
 269
 270         /*
 271          * If we're not behind an IOMMU make sure we don't get push buffers
 272          * that are allocated outside of the range addressable by the GATHER
 273          * opcode.
 274          *
 275          * Newer generations of Tegra (Tegra186 and later) support a wide
 276          * variant of the GATHER opcode that allows addressing more bits.
 277          */
 278         if (!domain && !host->info->has_wide_gather)
 279                 mask = DMA_BIT_MASK(32);
 280
 281         err = dma_coerce_mask_and_coherent(host->dev, mask);
 282         if (err < 0) {
 283                 dev_err(host->dev, "failed to set DMA mask: %d\n", err);
 284                 return err;
 285         }
 286
 287         return 0;
 288 }
 289
 290 static void host1x_iommu_exit(struct host1x *host)
 291 {
 292         if (host->domain) {
 293                 put_iova_domain(&host->iova);
 294                 iommu_detach_group(host->domain, host->group);
 295
 296                 iommu_domain_free(host->domain);
 297                 host->domain = NULL;
 298
 299                 iova_cache_put();
 300
 301                 iommu_group_put(host->group);
 302                 host->group = NULL;
 303         }
 304 }
 305
 306 static int host1x_probe(struct platform_device *pdev)
 307 {
 308         struct host1x *host;
 309         struct resource *regs, *hv_regs = NULL;
 310         int syncpt_irq;
 311         int err;
 312
 313         host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL);
 314         if (!host)
 315                 return -ENOMEM;
 316
 317         host->info = of_device_get_match_data(&pdev->dev);
 318
 319         if (host->info->has_hypervisor) {
 320                 regs = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vm");
 321                 if (!regs) {
 322                         dev_err(&pdev->dev, "failed to get vm registers\n");
 323                         return -ENXIO;
 324                 }
 325
 326                 hv_regs = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 327                                                        "hypervisor");
 328                 if (!hv_regs) {
 329                         dev_err(&pdev->dev,
 330                                 "failed to get hypervisor registers\n");
 331                         return -ENXIO;
 332                 }
 333         } else {
 334                 regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 335                 if (!regs) {
 336                         dev_err(&pdev->dev, "failed to get registers\n");
 337                         return -ENXIO;
 338                 }
 339         }
 340
 341         syncpt_irq = platform_get_irq(pdev, 0);
 342         if (syncpt_irq < 0) {
 343                 dev_err(&pdev->dev, "failed to get IRQ: %d\n", syncpt_irq);
 344                 return syncpt_irq;
 345         }
 346
 347         mutex_init(&host->devices_lock);
 348         INIT_LIST_HEAD(&host->devices);
 349         INIT_LIST_HEAD(&host->list);
 350         host->dev = &pdev->dev;
 351
 352         /* set common host1x device data */
 353         platform_set_drvdata(pdev, host);
 354
 355         host->regs = devm_ioremap_resource(&pdev->dev, regs);
 356         if (IS_ERR(host->regs))
 357                 return PTR_ERR(host->regs);
 358
 359         if (host->info->has_hypervisor) {
 360                 host->hv_regs = devm_ioremap_resource(&pdev->dev, hv_regs);
 361                 if (IS_ERR(host->hv_regs))
 362                         return PTR_ERR(host->hv_regs);
 363         }
 364
 365         host->dev->dma_parms = &host->dma_parms;
 366         dma_set_max_seg_size(host->dev, UINT_MAX);
 367
 368         if (host->info->init) {
 369                 err = host->info->init(host);
 370                 if (err)
 371                         return err;
 372         }
 373
 374         host->clk = devm_clk_get(&pdev->dev, NULL);
 375         if (IS_ERR(host->clk)) {
 376                 err = PTR_ERR(host->clk);
 377
 378                 if (err != -EPROBE_DEFER)
 379                         dev_err(&pdev->dev, "failed to get clock: %d\n", err);
 380
 381                 return err;
 382         }
 383
 384         host->rst = devm_reset_control_get(&pdev->dev, "host1x");
 385         if (IS_ERR(host->rst)) {
 386                 err = PTR_ERR(host->rst);
 387                 dev_err(&pdev->dev, "failed to get reset: %d\n", err);
 388                 return err;
 389         }
 390
 391         err = host1x_iommu_init(host);
 392         if (err < 0) {
 393                 dev_err(&pdev->dev, "failed to setup IOMMU: %d\n", err);
 394                 return err;
 395         }
 396
 397         err = host1x_channel_list_init(&host->channel_list,
 398                                        host->info->nb_channels);
 399         if (err) {
 400                 dev_err(&pdev->dev, "failed to initialize channel list\n");
 401                 goto iommu_exit;
 402         }
 403
 404         err = clk_prepare_enable(host->clk);
 405         if (err < 0) {
 406                 dev_err(&pdev->dev, "failed to enable clock\n");
 407                 goto free_channels;
 408         }
 409
 410         err = reset_control_deassert(host->rst);
 411         if (err < 0) {
 412                 dev_err(&pdev->dev, "failed to deassert reset: %d\n", err);
 413                 goto unprepare_disable;
 414         }
 415
 416         err = host1x_syncpt_init(host);
 417         if (err) {
 418                 dev_err(&pdev->dev, "failed to initialize syncpts\n");
 419                 goto reset_assert;
 420         }
 421
 422         err = host1x_intr_init(host, syncpt_irq);
 423         if (err) {
 424                 dev_err(&pdev->dev, "failed to initialize interrupts\n");
 425                 goto deinit_syncpt;
 426         }
 427
 428         host1x_debug_init(host);
 429
 430         if (host->info->has_hypervisor)
 431                 host1x_setup_sid_table(host);
 432
 433         err = host1x_register(host);
 434         if (err < 0)
 435                 goto deinit_intr;
 436
 437         return 0;
 438
 439 deinit_intr:
 440         host1x_intr_deinit(host);
 441 deinit_syncpt:
 442         host1x_syncpt_deinit(host);
 443 reset_assert:
 444         reset_control_assert(host->rst);
 445 unprepare_disable:
 446         clk_disable_unprepare(host->clk);
 447 free_channels:
 448         host1x_channel_list_free(&host->channel_list);
 449 iommu_exit:
 450         host1x_iommu_exit(host);
 451
 452         return err;
 453 }
 454
 455 static int host1x_remove(struct platform_device *pdev)
 456 {
 457         struct host1x *host = platform_get_drvdata(pdev);
 458
 459         host1x_unregister(host);
 460         host1x_debug_deinit(host);
 461         host1x_intr_deinit(host);
 462         host1x_syncpt_deinit(host);
 463         reset_control_assert(host->rst);
 464         clk_disable_unprepare(host->clk);
 465         host1x_iommu_exit(host);
 466
 467         return 0;
 468 }
 469
 470 static struct platform_driver tegra_host1x_driver = {
 471         .driver = {
 472                 .name = "tegra-host1x",
 473                 .of_match_table = host1x_of_match,
 474         },
 475         .probe = host1x_probe,
 476         .remove = host1x_remove,
 477 };
 478
 479 static struct platform_driver * const drivers[] = {
 480         &tegra_host1x_driver,
 481         &tegra_mipi_driver,
 482 };
 483
 484 static int __init tegra_host1x_init(void)
 485 {
 486         int err;
 487
 488         err = bus_register(&host1x_bus_type);
 489         if (err < 0)
 490                 return err;
 491
 492         err = platform_register_drivers(drivers, ARRAY_SIZE(drivers));
 493         if (err < 0)
 494                 bus_unregister(&host1x_bus_type);
 495
 496         return err;
 497 }
 498 module_init(tegra_host1x_init);
 499
 500 static void __exit tegra_host1x_exit(void)
 501 {
 502         platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
 503         bus_unregister(&host1x_bus_type);
 504 }
 505 module_exit(tegra_host1x_exit);
 506
 507 MODULE_AUTHOR("Thierry Reding <[email protected]>");
 508 MODULE_AUTHOR("Terje Bergstrom <[email protected]>");
 509 MODULE_DESCRIPTION("Host1x driver for Tegra products");
 510 MODULE_LICENSE("GPL");