Commit | Line | Data |
---|---|---|
9026e0d1 MR |
1 | /* |
2 | * Copyright (C) 2015 Free Electrons | |
3 | * Copyright (C) 2015 NextThing Co | |
4 | * | |
5 | * Maxime Ripard <maxime.ripard@free-electrons.com> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License as | |
9 | * published by the Free Software Foundation; either version 2 of | |
10 | * the License, or (at your option) any later version. | |
11 | */ | |
12 | ||
13 | #include <drm/drm_atomic_helper.h> | |
14 | #include <drm/drm_crtc.h> | |
15 | #include <drm/drm_plane_helper.h> | |
16 | #include <drm/drmP.h> | |
17 | ||
18 | #include "sun4i_backend.h" | |
19 | #include "sun4i_drv.h" | |
20 | #include "sun4i_layer.h" | |
21 | ||
22 | #define SUN4I_NUM_LAYERS 2 | |
23 | ||
24 | static int sun4i_backend_layer_atomic_check(struct drm_plane *plane, | |
25 | struct drm_plane_state *state) | |
26 | { | |
27 | return 0; | |
28 | } | |
29 | ||
30 | static void sun4i_backend_layer_atomic_disable(struct drm_plane *plane, | |
31 | struct drm_plane_state *old_state) | |
32 | { | |
33 | struct sun4i_layer *layer = plane_to_sun4i_layer(plane); | |
34 | struct sun4i_drv *drv = layer->drv; | |
35 | struct sun4i_backend *backend = drv->backend; | |
36 | ||
37 | sun4i_backend_layer_enable(backend, layer->id, false); | |
38 | } | |
39 | ||
40 | static void sun4i_backend_layer_atomic_update(struct drm_plane *plane, | |
41 | struct drm_plane_state *old_state) | |
42 | { | |
43 | struct sun4i_layer *layer = plane_to_sun4i_layer(plane); | |
44 | struct sun4i_drv *drv = layer->drv; | |
45 | struct sun4i_backend *backend = drv->backend; | |
46 | ||
47 | sun4i_backend_update_layer_coord(backend, layer->id, plane); | |
48 | sun4i_backend_update_layer_formats(backend, layer->id, plane); | |
49 | sun4i_backend_update_layer_buffer(backend, layer->id, plane); | |
50 | sun4i_backend_layer_enable(backend, layer->id, true); | |
51 | } | |
52 | ||
53 | static struct drm_plane_helper_funcs sun4i_backend_layer_helper_funcs = { | |
54 | .atomic_check = sun4i_backend_layer_atomic_check, | |
55 | .atomic_disable = sun4i_backend_layer_atomic_disable, | |
56 | .atomic_update = sun4i_backend_layer_atomic_update, | |
57 | }; | |
58 | ||
59 | static const struct drm_plane_funcs sun4i_backend_layer_funcs = { | |
60 | .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, | |
61 | .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, | |
62 | .destroy = drm_plane_cleanup, | |
63 | .disable_plane = drm_atomic_helper_disable_plane, | |
64 | .reset = drm_atomic_helper_plane_reset, | |
65 | .update_plane = drm_atomic_helper_update_plane, | |
66 | }; | |
67 | ||
68 | static const uint32_t sun4i_backend_layer_formats[] = { | |
69 | DRM_FORMAT_ARGB8888, | |
70 | DRM_FORMAT_XRGB8888, | |
71 | DRM_FORMAT_RGB888, | |
72 | }; | |
73 | ||
74 | static struct sun4i_layer *sun4i_layer_init_one(struct drm_device *drm, | |
75 | enum drm_plane_type type) | |
76 | { | |
77 | struct sun4i_drv *drv = drm->dev_private; | |
78 | struct sun4i_layer *layer; | |
79 | int ret; | |
80 | ||
81 | layer = devm_kzalloc(drm->dev, sizeof(*layer), GFP_KERNEL); | |
82 | if (!layer) | |
83 | return ERR_PTR(-ENOMEM); | |
84 | ||
85 | ret = drm_universal_plane_init(drm, &layer->plane, BIT(0), | |
86 | &sun4i_backend_layer_funcs, | |
87 | sun4i_backend_layer_formats, | |
88 | ARRAY_SIZE(sun4i_backend_layer_formats), | |
89 | type, | |
90 | NULL); | |
91 | if (ret) { | |
92 | dev_err(drm->dev, "Couldn't initialize layer\n"); | |
93 | return ERR_PTR(ret); | |
94 | } | |
95 | ||
96 | drm_plane_helper_add(&layer->plane, | |
97 | &sun4i_backend_layer_helper_funcs); | |
98 | layer->drv = drv; | |
99 | ||
100 | if (type == DRM_PLANE_TYPE_PRIMARY) | |
101 | drv->primary = &layer->plane; | |
102 | ||
103 | return layer; | |
104 | } | |
105 | ||
106 | struct sun4i_layer **sun4i_layers_init(struct drm_device *drm) | |
107 | { | |
108 | struct sun4i_drv *drv = drm->dev_private; | |
109 | struct sun4i_layer **layers; | |
110 | int i; | |
111 | ||
112 | layers = devm_kcalloc(drm->dev, SUN4I_NUM_LAYERS, sizeof(**layers), | |
113 | GFP_KERNEL); | |
114 | if (!layers) | |
115 | return ERR_PTR(-ENOMEM); | |
116 | ||
117 | /* | |
118 | * The hardware is a bit unusual here. | |
119 | * | |
120 | * Even though it supports 4 layers, it does the composition | |
121 | * in two separate steps. | |
122 | * | |
123 | * The first one is assigning a layer to one of its two | |
124 | * pipes. If more that 1 layer is assigned to the same pipe, | |
125 | * and if pixels overlaps, the pipe will take the pixel from | |
126 | * the layer with the highest priority. | |
127 | * | |
128 | * The second step is the actual alpha blending, that takes | |
129 | * the two pipes as input, and uses the eventual alpha | |
130 | * component to do the transparency between the two. | |
131 | * | |
132 | * This two steps scenario makes us unable to guarantee a | |
133 | * robust alpha blending between the 4 layers in all | |
134 | * situations. So we just expose two layers, one per pipe. On | |
135 | * SoCs that support it, sprites could fill the need for more | |
136 | * layers. | |
137 | */ | |
138 | for (i = 0; i < SUN4I_NUM_LAYERS; i++) { | |
139 | enum drm_plane_type type = (i == 0) | |
140 | ? DRM_PLANE_TYPE_PRIMARY | |
141 | : DRM_PLANE_TYPE_OVERLAY; | |
142 | struct sun4i_layer *layer = layers[i]; | |
143 | ||
144 | layer = sun4i_layer_init_one(drm, type); | |
145 | if (IS_ERR(layer)) { | |
146 | dev_err(drm->dev, "Couldn't initialize %s plane\n", | |
147 | i ? "overlay" : "primary"); | |
148 | return ERR_CAST(layer); | |
149 | }; | |
150 | ||
151 | DRM_DEBUG_DRIVER("Assigning %s plane to pipe %d\n", | |
152 | i ? "overlay" : "primary", i); | |
153 | regmap_update_bits(drv->backend->regs, SUN4I_BACKEND_ATTCTL_REG0(i), | |
154 | SUN4I_BACKEND_ATTCTL_REG0_LAY_PIPESEL_MASK, | |
155 | SUN4I_BACKEND_ATTCTL_REG0_LAY_PIPESEL(i)); | |
156 | ||
157 | layer->id = i; | |
158 | }; | |
159 | ||
160 | return layers; | |
161 | } |