]> git.kernelconcepts.de Git - karo-tx-linux.git/blob - drivers/gpu/drm/vc4/vc4_hvs.c
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid
[karo-tx-linux.git] / drivers / gpu / drm / vc4 / vc4_hvs.c
1 /*
2  * Copyright (C) 2015 Broadcom
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 /**
10  * DOC: VC4 HVS module.
11  *
12  * The HVS is the piece of hardware that does translation, scaling,
13  * colorspace conversion, and compositing of pixels stored in
14  * framebuffers into a FIFO of pixels going out to the Pixel Valve
15  * (CRTC).  It operates at the system clock rate (the system audio
16  * clock gate, specifically), which is much higher than the pixel
17  * clock rate.
18  *
19  * There is a single global HVS, with multiple output FIFOs that can
20  * be consumed by the PVs.  This file just manages the resources for
21  * the HVS, while the vc4_crtc.c code actually drives HVS setup for
22  * each CRTC.
23  */
24
25 #include "linux/component.h"
26 #include "vc4_drv.h"
27 #include "vc4_regs.h"
28
29 #define HVS_REG(reg) { reg, #reg }
30 static const struct {
31         u32 reg;
32         const char *name;
33 } hvs_regs[] = {
34         HVS_REG(SCALER_DISPCTRL),
35         HVS_REG(SCALER_DISPSTAT),
36         HVS_REG(SCALER_DISPID),
37         HVS_REG(SCALER_DISPECTRL),
38         HVS_REG(SCALER_DISPPROF),
39         HVS_REG(SCALER_DISPDITHER),
40         HVS_REG(SCALER_DISPEOLN),
41         HVS_REG(SCALER_DISPLIST0),
42         HVS_REG(SCALER_DISPLIST1),
43         HVS_REG(SCALER_DISPLIST2),
44         HVS_REG(SCALER_DISPLSTAT),
45         HVS_REG(SCALER_DISPLACT0),
46         HVS_REG(SCALER_DISPLACT1),
47         HVS_REG(SCALER_DISPLACT2),
48         HVS_REG(SCALER_DISPCTRL0),
49         HVS_REG(SCALER_DISPBKGND0),
50         HVS_REG(SCALER_DISPSTAT0),
51         HVS_REG(SCALER_DISPBASE0),
52         HVS_REG(SCALER_DISPCTRL1),
53         HVS_REG(SCALER_DISPBKGND1),
54         HVS_REG(SCALER_DISPSTAT1),
55         HVS_REG(SCALER_DISPBASE1),
56         HVS_REG(SCALER_DISPCTRL2),
57         HVS_REG(SCALER_DISPBKGND2),
58         HVS_REG(SCALER_DISPSTAT2),
59         HVS_REG(SCALER_DISPBASE2),
60         HVS_REG(SCALER_DISPALPHA2),
61 };
62
63 void vc4_hvs_dump_state(struct drm_device *dev)
64 {
65         struct vc4_dev *vc4 = to_vc4_dev(dev);
66         int i;
67
68         for (i = 0; i < ARRAY_SIZE(hvs_regs); i++) {
69                 DRM_INFO("0x%04x (%s): 0x%08x\n",
70                          hvs_regs[i].reg, hvs_regs[i].name,
71                          HVS_READ(hvs_regs[i].reg));
72         }
73
74         DRM_INFO("HVS ctx:\n");
75         for (i = 0; i < 64; i += 4) {
76                 DRM_INFO("0x%08x (%s): 0x%08x 0x%08x 0x%08x 0x%08x\n",
77                          i * 4, i < HVS_BOOTLOADER_DLIST_END ? "B" : "D",
78                          readl((u32 __iomem *)vc4->hvs->dlist + i + 0),
79                          readl((u32 __iomem *)vc4->hvs->dlist + i + 1),
80                          readl((u32 __iomem *)vc4->hvs->dlist + i + 2),
81                          readl((u32 __iomem *)vc4->hvs->dlist + i + 3));
82         }
83 }
84
85 #ifdef CONFIG_DEBUG_FS
86 int vc4_hvs_debugfs_regs(struct seq_file *m, void *unused)
87 {
88         struct drm_info_node *node = (struct drm_info_node *)m->private;
89         struct drm_device *dev = node->minor->dev;
90         struct vc4_dev *vc4 = to_vc4_dev(dev);
91         int i;
92
93         for (i = 0; i < ARRAY_SIZE(hvs_regs); i++) {
94                 seq_printf(m, "%s (0x%04x): 0x%08x\n",
95                            hvs_regs[i].name, hvs_regs[i].reg,
96                            HVS_READ(hvs_regs[i].reg));
97         }
98
99         return 0;
100 }
101 #endif
102
103 static int vc4_hvs_bind(struct device *dev, struct device *master, void *data)
104 {
105         struct platform_device *pdev = to_platform_device(dev);
106         struct drm_device *drm = dev_get_drvdata(master);
107         struct vc4_dev *vc4 = drm->dev_private;
108         struct vc4_hvs *hvs = NULL;
109
110         hvs = devm_kzalloc(&pdev->dev, sizeof(*hvs), GFP_KERNEL);
111         if (!hvs)
112                 return -ENOMEM;
113
114         hvs->pdev = pdev;
115
116         hvs->regs = vc4_ioremap_regs(pdev, 0);
117         if (IS_ERR(hvs->regs))
118                 return PTR_ERR(hvs->regs);
119
120         hvs->dlist = hvs->regs + SCALER_DLIST_START;
121
122         vc4->hvs = hvs;
123         return 0;
124 }
125
126 static void vc4_hvs_unbind(struct device *dev, struct device *master,
127                            void *data)
128 {
129         struct drm_device *drm = dev_get_drvdata(master);
130         struct vc4_dev *vc4 = drm->dev_private;
131
132         vc4->hvs = NULL;
133 }
134
135 static const struct component_ops vc4_hvs_ops = {
136         .bind   = vc4_hvs_bind,
137         .unbind = vc4_hvs_unbind,
138 };
139
140 static int vc4_hvs_dev_probe(struct platform_device *pdev)
141 {
142         return component_add(&pdev->dev, &vc4_hvs_ops);
143 }
144
145 static int vc4_hvs_dev_remove(struct platform_device *pdev)
146 {
147         component_del(&pdev->dev, &vc4_hvs_ops);
148         return 0;
149 }
150
151 static const struct of_device_id vc4_hvs_dt_match[] = {
152         { .compatible = "brcm,bcm2835-hvs" },
153         {}
154 };
155
156 struct platform_driver vc4_hvs_driver = {
157         .probe = vc4_hvs_dev_probe,
158         .remove = vc4_hvs_dev_remove,
159         .driver = {
160                 .name = "vc4_hvs",
161                 .of_match_table = vc4_hvs_dt_match,
162         },
163 };