projects/linux·blob master · refs

279 lines · 7.8 KiB

1/* SPDX-License-Identifier: GPL-2.0-only
2 *
3 * Generic bit area filler and twister engine for packed pixel framebuffers
4 *
5 * Rewritten by:
6 * Copyright (C) 2025 Zsolt Kajtar ([email protected])
7 *
8 * Based on earlier work of:
9 * Copyright (C) 2000 James Simmons ([email protected])
10 * Michal Januszewski <[email protected]>
11 * Anton Vorontsov <[email protected]>
12 * Pavel Pisa <[email protected]>
13 * Antonino A. Daplas <[email protected]>
14 * Geert Uytterhoeven
15 * and others
16 *
17 * NOTES:
18 *
19 * Handles native and foreign byte order on both endians, standard and
20 * reverse pixel order in a byte (<8 BPP), word length of 32/64 bits,
21 * bits per pixel from 1 to the word length. Handles line lengths at byte
22 * granularity while maintaining aligned accesses.
23 *
24 * Optimized path for power of two bits per pixel modes.
25 */
26#include "fb_draw.h"
27
28/* inverts bits at a given offset */
29static inline void fb_invert_offset(unsigned long pat, int offset, const struct fb_address *dst)
30{
31 fb_write_offset(fb_read_offset(offset, dst) ^ pat, offset, dst);
32}
33
34/* state for pattern generator and whether swapping is necessary */
35struct fb_pattern {
36 unsigned long pixels;
37 int left, right;
38 struct fb_reverse reverse;
39};
40
41/* used to get the pattern in native order */
42static unsigned long fb_pattern_get(struct fb_pattern *pattern)
43{
44 return pattern->pixels;
45}
46
47/* used to get the pattern in reverse order */
48static unsigned long fb_pattern_get_reverse(struct fb_pattern *pattern)
49{
50 return swab_long(pattern->pixels);
51}
52
53/* next static pattern */
54static void fb_pattern_static(struct fb_pattern *pattern)
55{
56 /* nothing to do */
57}
58
59/* next rotating pattern */
60static void fb_pattern_rotate(struct fb_pattern *pattern)
61{
62 pattern->pixels = fb_left(pattern->pixels, pattern->left)
63 | fb_right(pattern->pixels, pattern->right);
64}
65
66#define FB_PAT(i) (((1UL<<(BITS_PER_LONG-1)/(i)*(i))/((1<<(i))-1)<<(i))|1)
67
68/* create the filling pattern from a given color */
69static unsigned long pixel_to_pat(int bpp, u32 color)
70{
71 static const unsigned long mulconst[BITS_PER_LONG/4] = {
72 0, ~0UL, FB_PAT(2), FB_PAT(3),
73 FB_PAT(4), FB_PAT(5), FB_PAT(6), FB_PAT(7),
74#if BITS_PER_LONG == 64
75 FB_PAT(8), FB_PAT(9), FB_PAT(10), FB_PAT(11),
76 FB_PAT(12), FB_PAT(13), FB_PAT(14), FB_PAT(15),
77#endif
78 };
79 unsigned long pattern;
80
81 switch (bpp) {
82 case 0 ... BITS_PER_LONG/4-1:
83 pattern = mulconst[bpp] * color;
84 break;
85 case BITS_PER_LONG/4 ... BITS_PER_LONG/2-1:
86 pattern = color;
87 pattern = pattern | pattern << bpp;
88 pattern = pattern | pattern << bpp*2;
89 break;
90 case BITS_PER_LONG/2 ... BITS_PER_LONG-1:
91 pattern = color;
92 pattern = pattern | pattern << bpp;
93 break;
94 default:
95 return color;
96 }
97#ifndef __LITTLE_ENDIAN
98 pattern <<= (BITS_PER_LONG % bpp);
99 pattern |= pattern >> bpp;
100#endif
101 return pattern;
102}
103
104/* overwrite bits according to a pattern in a line */
105static __always_inline void bitfill(const struct fb_address *dst,
106 struct fb_pattern *pattern,
107 unsigned long (*get)(struct fb_pattern *pattern),
108 void (*rotate)(struct fb_pattern *pattern),
109 int end)
110{
111 unsigned long first, last;
112
113 end += dst->bits;
114 first = fb_pixel_mask(dst->bits, pattern->reverse);
115 last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), pattern->reverse);
116
117 if (end <= BITS_PER_LONG) {
118 last = last ? (last & first) : first;
119 first = get(pattern);
120 if (last == ~0UL)
121 fb_write_offset(first, 0, dst);
122 else if (last)
123 fb_modify_offset(first, last, 0, dst);
124 } else {
125 int offset = first != ~0UL;
126
127 if (offset) {
128 fb_modify_offset(get(pattern), first, 0, dst);
129 rotate(pattern);
130 }
131 end /= BITS_PER_LONG;
132 for (; offset + 4 <= end; offset += 4) {
133 fb_write_offset(get(pattern), offset + 0, dst);
134 rotate(pattern);
135 fb_write_offset(get(pattern), offset + 1, dst);
136 rotate(pattern);
137 fb_write_offset(get(pattern), offset + 2, dst);
138 rotate(pattern);
139 fb_write_offset(get(pattern), offset + 3, dst);
140 rotate(pattern);
141 }
142 while (offset < end) {
143 fb_write_offset(get(pattern), offset++, dst);
144 rotate(pattern);
145 }
146
147 if (last)
148 fb_modify_offset(get(pattern), last, offset, dst);
149 }
150}
151
152/* inverts bits according to a pattern in a line */
153static __always_inline void bitinvert(const struct fb_address *dst,
154 struct fb_pattern *pattern,
155 unsigned long (*get)(struct fb_pattern *pattern),
156 void (*rotate)(struct fb_pattern *pattern),
157 int end)
158{
159 unsigned long first, last;
160 int offset;
161
162 end += dst->bits;
163 first = fb_pixel_mask(dst->bits, pattern->reverse);
164 last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), pattern->reverse);
165
166 if (end <= BITS_PER_LONG) {
167 offset = 0;
168 last = last ? (last & first) : first;
169 } else {
170 offset = first != ~0UL;
171
172 if (offset) {
173 first &= get(pattern);
174 if (first)
175 fb_invert_offset(first, 0, dst);
176 rotate(pattern);
177 }
178
179 end /= BITS_PER_LONG;
180 for (; offset + 4 <= end; offset += 4) {
181 fb_invert_offset(get(pattern), offset + 0, dst);
182 rotate(pattern);
183 fb_invert_offset(get(pattern), offset + 1, dst);
184 rotate(pattern);
185 fb_invert_offset(get(pattern), offset + 2, dst);
186 rotate(pattern);
187 fb_invert_offset(get(pattern), offset + 3, dst);
188 rotate(pattern);
189 }
190 while (offset < end) {
191 fb_invert_offset(get(pattern), offset++, dst);
192 rotate(pattern);
193 }
194 }
195
196 last &= get(pattern);
197 if (last)
198 fb_invert_offset(last, offset, dst);
199}
200
201/* pattern doesn't change. 1, 2, 4, 8, 16, 32, 64 bpp */
202static inline void fb_fillrect_static(const struct fb_fillrect *rect, int bpp,
203 struct fb_address *dst, struct fb_pattern *pattern,
204 unsigned int bits_per_line)
205{
206 u32 height = rect->height;
207 int width = rect->width * bpp;
208
209 if (bpp > 8 && pattern->reverse.byte)
210 pattern->pixels = swab_long(pattern->pixels);
211
212 if (rect->rop == ROP_XOR)
213 while (height--) {
214 bitinvert(dst, pattern, fb_pattern_get, fb_pattern_static, width);
215 fb_address_forward(dst, bits_per_line);
216 }
217 else
218 while (height--) {
219 bitfill(dst, pattern, fb_pattern_get, fb_pattern_static, width);
220 fb_address_forward(dst, bits_per_line);
221 }
222}
223
224/* rotate pattern to the correct position */
225static inline unsigned long fb_rotate(unsigned long pattern, int shift, int bpp)
226{
227 shift %= bpp;
228 return fb_right(pattern, shift) | fb_left(pattern, bpp - shift);
229}
230
231/* rotating pattern, for example 24 bpp */
232static __always_inline void fb_fillrect_rotating(const struct fb_fillrect *rect,
233 int bpp, struct fb_address *dst,
234 struct fb_pattern *pattern,
235 unsigned long (*get)(struct fb_pattern *pattern),
236 unsigned int bits_per_line)
237{
238 unsigned long pat = pattern->pixels;
239 u32 height = rect->height;
240 int width = rect->width * bpp;
241
242 if (rect->rop == ROP_XOR)
243 while (height--) {
244 pattern->pixels = fb_rotate(pat, dst->bits, bpp);
245 bitinvert(dst, pattern, get, fb_pattern_rotate, width);
246 fb_address_forward(dst, bits_per_line);
247 }
248 else
249 while (height--) {
250 pattern->pixels = fb_rotate(pat, dst->bits, bpp);
251 bitfill(dst, pattern, get, fb_pattern_rotate, width);
252 fb_address_forward(dst, bits_per_line);
253 }
254}
255
256static inline void fb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
257{
258 int bpp = p->var.bits_per_pixel;
259 unsigned int bits_per_line = BYTES_TO_BITS(p->fix.line_length);
260 const u32 *palette = fb_palette(p);
261 struct fb_address dst = fb_address_init(p);
262 struct fb_pattern pattern;
263
264 fb_address_forward(&dst, rect->dy * bits_per_line + rect->dx * bpp);
265
266 pattern.pixels = pixel_to_pat(bpp, palette ? palette[rect->color] : rect->color);
267 pattern.reverse = fb_reverse_init(p);
268 pattern.left = BITS_PER_LONG % bpp;
269 if (pattern.left) {
270 pattern.right = bpp - pattern.left;
271 if (pattern.reverse.byte)
272 fb_fillrect_rotating(rect, bpp, &dst, &pattern,
273 fb_pattern_get_reverse, bits_per_line);
274 else
275 fb_fillrect_rotating(rect, bpp, &dst, &pattern,
276 fb_pattern_get, bits_per_line);
277 } else
278 fb_fillrect_static(rect, bpp, &dst, &pattern, bits_per_line);
279}