// SPDX-License-Identifier: GPL-2.0-only /* * Copyright ( c ) 2014 The Linux Foundation . All rights reserved . * Copyright ( C ) 2013 Red Hat * Author : Rob Clark < robdclark @ gmail . com > #include <linux/clk.h>#include <linux/component.h>#include <linux/platform_device.h>#include <linux/pm_runtime.h>#include "vc4_drv.h" #include "vc4_regs.h" static const struct debugfs_reg32 v3d_regs[] = {0 )),0 )),1 )),1 )),2 )),2 )),3 )),3 )),4 )),4 )),5 )),5 )),6 )),6 )),7 )),7 )),8 )),8 )),9 )),9 )),10 )),10 )),11 )),11 )),12 )),12 )),13 )),13 )),14 )),14 )),15 )),15 )),static int vc4_v3d_debugfs_ident(struct seq_file *m, void *unused)struct drm_debugfs_entry *entry = m->private ;struct drm_device *dev = entry->dev;struct vc4_dev *vc4 = to_vc4_dev(dev);int ret = vc4_v3d_pm_get(vc4);if (ret == 0 ) {"Revision: %d\n" ,"Slices: %d\n" , nslc);"TMUs: %d\n" , nslc * tups);"QPUs: %d\n" , nslc * qups);"Semaphores: %d\n" ,return 0 ;/* * Wraps pm_runtime_get_sync ( ) in a refcount , so that we can reliably * get the pm_runtime refcount to 0 in vc4_reset ( ) . int struct vc4_dev *vc4)if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4))return -ENODEV;if (vc4->power_refcount++ == 0 ) {int ret = pm_runtime_get_sync(&vc4->v3d->pdev->dev);if (ret < 0 ) {return ret;return 0 ;void struct vc4_dev *vc4)if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4))return ;if (--vc4->power_refcount == 0 ) {static void vc4_v3d_init_hw(struct drm_device *dev)struct vc4_dev *vc4 = to_vc4_dev(dev);/* Take all the memory that would have been reserved for user * QPU programs , since we don ' t have an interface for running * them , anyway . 0 );int vc4_v3d_get_bin_slot(struct vc4_dev *vc4)struct drm_device *dev = &vc4->base;unsigned long irqflags;int slot;0 ;struct vc4_exec_info *exec;if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4))return -ENODEV;if (slot != 0 ) {/* Switch from ffs() bit index to a 0-based index. */ return slot;/* Couldn't find an open slot. Wait for render to complete * and try again . if (exec)if (seqno) {int ret = vc4_wait_for_seqno(dev, seqno, ~0 ull, true );if (ret == 0 )goto try_again;return ret;return -ENOMEM;/* * bin_bo_alloc ( ) - allocates the memory that will be used for * tile binning . * * The binner has a limitation that the addresses in the tile state * buffer that point into the tile alloc buffer or binner overflow * memory only have 28 bits ( 256 MB ) , and the top 4 on the bus for * tile alloc references end up coming from the tile state buffer ' s * address . * * To work around this , we allocate a single large buffer while V3D is * in use , make sure that it has the top 4 bits constant across its * entire extent , and then put the tile state , tile alloc , and binner * overflow memory inside that buffer . * * This creates a limitation where we may not be able to execute a job * if it doesn ' t fit within the buffer that we allocated up front . * However , it turns out that 16 MB is " enough for anybody " , and * real - world applications run into allocation failures from the * overall DMA pool before they make scenes complicated enough to run * out of bin space . static int bin_bo_alloc(struct vc4_dev *vc4)struct vc4_v3d *v3d = vc4->v3d;16 * 1024 * 1024 ;int ret = 0 ;struct list_head list;if (!v3d)return -ENODEV;/* We may need to try allocating more than once to get a BO * that doesn ' t cross 256 MB . Track the ones we ' ve allocated * that failed so far , so that we can free them when we ' ve got * one that succeeded ( if we freed them right away , our next * allocation would probably be the same chunk of memory ) . while (true ) {struct vc4_bo *bo = vc4_bo_create(&vc4->base, size, true ,if (IS_ERR(bo)) {"Failed to allocate memory for tile binning: " "%d. You may need to enable DMA or give it " "more memory." ,break ;/* Check if this BO won't trigger the addressing bug. */ if ((bo->base.dma_addr & 0 xf0000000) ==1 ) & 0 xf0000000)) {/* Set up for allocating 512KB chunks of * binner memory . The biggest allocation we * need to do is for the initial tile alloc + * tile state buffer . We can render to a * maximum of ( ( 2048 * 2048 ) / ( 32 * 32 ) = 4096 * tiles in a frame ( until we do floating * point rendering , at which point it would be * 8192 ) . Tile state is 48 b / tile ( rounded to * a page ) , and tile alloc is 32 b / tile * ( rounded to a page ) , plus a page of extra , * for a total of 320 kb for our worst - case . * We choose 512 kb so that it divides evenly * into our 16 MB , and the rest of the 512 kb * will be used as storage for the overflow * from the initial 32 b CL per bin . 512 * 1024 ;0 ;0 ;sizeof (vc4->bin_alloc_used) * 8 !=/* Enable the out-of-memory interrupt to set our * newly - allocated binner BO , potentially from an * already - pending - but - masked interrupt . break ;/* Put it on the list to free later, and try again. */ /* Free all the BOs we allocated but didn't choose. */ while (!list_empty(&list)) {struct vc4_bo *bo = list_last_entry(&list,struct vc4_bo, unref_head);return ret;int vc4_v3d_bin_bo_get(struct vc4_dev *vc4, bool *used)int ret = 0 ;if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4))return -ENODEV;if (used && *used)goto complete;if (vc4->bin_bo)else if (ret == 0 && used)true ;return ret;static void bin_bo_release(struct kref *ref)struct vc4_dev *vc4 = container_of(ref, struct vc4_dev, bin_bo_kref);if (WARN_ON_ONCE(!vc4->bin_bo))return ;void vc4_v3d_bin_bo_put(struct vc4_dev *vc4)if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4))return ;#ifdef CONFIG_PMstatic int vc4_v3d_runtime_suspend(struct device *dev)struct vc4_v3d *v3d = dev_get_drvdata(dev);struct vc4_dev *vc4 = v3d->vc4;return 0 ;static int vc4_v3d_runtime_resume(struct device *dev)struct vc4_v3d *v3d = dev_get_drvdata(dev);struct vc4_dev *vc4 = v3d->vc4;int ret;if (ret != 0 )return ret;return 0 ;#endif int vc4_v3d_debugfs_init(struct drm_minor *minor)struct drm_device *drm = minor->dev;struct vc4_dev *vc4 = to_vc4_dev(drm);struct vc4_v3d *v3d = vc4->v3d;if (!vc4->v3d)return -ENODEV;"v3d_ident" , vc4_v3d_debugfs_ident, NULL);"v3d_regs" , &v3d->regset);return 0 ;static int vc4_v3d_bind(struct device *dev, struct device *master, void *data)struct platform_device *pdev = to_platform_device(dev);struct drm_device *drm = dev_get_drvdata(master);struct vc4_dev *vc4 = to_vc4_dev(drm);struct vc4_v3d *v3d = NULL;int ret;sizeof (*v3d), GFP_KERNEL);if (!v3d)return -ENOMEM;0 );if (IS_ERR(v3d->regs))return PTR_ERR(v3d->regs);if (IS_ERR(v3d->clk))return dev_err_probe(dev, PTR_ERR(v3d->clk), "Failed to get V3D clock\n" );0 );if (ret < 0 )return ret;if (ret)return ret;if (ret)return ret;if (V3D_READ(V3D_IDENT0) != V3D_EXPECTED_IDENT0) {"V3D_IDENT0 read 0x%08x instead of 0x%08x\n" ,goto err_put_runtime_pm;/* Reset the binner overflow address/size at setup, to be sure * we don ' t reuse an old one . 0 );0 );if (ret) {"Failed to install IRQ handler\n" );goto err_put_runtime_pm;40 ); /* a little over 2 frames. */ return 0 ;return ret;static void vc4_v3d_unbind(struct device *dev, struct device *master,void *data)struct drm_device *drm = dev_get_drvdata(master);struct vc4_dev *vc4 = to_vc4_dev(drm);/* Disable the binner's overflow memory address, so the next * driver probe ( if any ) doesn ' t try to reuse our old * allocation . 0 );0 );static const struct dev_pm_ops vc4_v3d_pm_ops = {static const struct component_ops vc4_v3d_ops = {static int vc4_v3d_dev_probe(struct platform_device *pdev)return component_add(&pdev->dev, &vc4_v3d_ops);static void vc4_v3d_dev_remove(struct platform_device *pdev)const struct of_device_id vc4_v3d_dt_match[] = {"brcm,bcm2835-v3d" },"brcm,cygnus-v3d" },"brcm,vc4-v3d" },struct platform_driver vc4_v3d_driver = {"vc4_v3d" ,
Messung V0.5 in Prozent C=95 H=90 G=92
¤ Dauer der Verarbeitung: 0.13 Sekunden
(vorverarbeitet am 2026-09-28)
¤ *© Formatika GbR, Deutschland
