/* SPDX-License-Identifier: GPL-2.0-only * *  Generic bit area filler and twister engine for packed pixel framebuffers * *	Rewritten by: *	Copyright (C)  2025 Zsolt Kajtar (soci@c64.rulez.org) * *	Based on earlier work of: *	Copyright (C)  2000 James Simmons (jsimmons@linux-fbdev.org) *	Michal Januszewski <spock@gentoo.org> *	Anton Vorontsov <avorontsov@ru.mvista.com> *	Pavel Pisa <pisa@cmp.felk.cvut.cz> *	Antonino A. Daplas <adaplas@gmail.com> *	Geert Uytterhoeven *	and others * * NOTES: * * Handles native and foreign byte order on both endians, standard and * reverse pixel order in a byte (<8 BPP), word length of 32/64 bits, * bits per pixel from 1 to the word length. Handles line lengths at byte * granularity while maintaining aligned accesses. * * Optimized path for power of two bits per pixel modes. */#include "fb_draw.h" /* inverts bits at a given offset */static inline void fb_invert_offset(unsigned long pat, int offset, const struct fb_address *dst){	fb_write_offset(fb_read_offset(offset, dst) ^ pat, offset, dst);} /* state for pattern generator and whether swapping is necessary */struct fb_pattern {	unsigned long pixels;	int left, right;	struct fb_reverse reverse;}; /* used to get the pattern in native order */static unsigned long fb_pattern_get(struct fb_pattern *pattern){	return pattern->pixels;} /* used to get the pattern in reverse order */static unsigned long fb_pattern_get_reverse(struct fb_pattern *pattern){	return swab_long(pattern->pixels);} /* next static pattern */static void fb_pattern_static(struct fb_pattern *pattern){	/* nothing to do */} /* next rotating pattern */static void fb_pattern_rotate(struct fb_pattern *pattern){	pattern->pixels = fb_left(pattern->pixels, pattern->left)		| fb_right(pattern->pixels, pattern->right);} #define FB_PAT(i) (((1UL<<(BITS_PER_LONG-1)/(i)*(i))/((1<<(i))-1)<<(i))|1) /* create the filling pattern from a given color */static unsigned long pixel_to_pat(int bpp, u32 color){	static const unsigned long mulconst[BITS_PER_LONG/4] = {		0, ~0UL, FB_PAT(2), FB_PAT(3),		FB_PAT(4), FB_PAT(5), FB_PAT(6), FB_PAT(7),#if BITS_PER_LONG == 64		FB_PAT(8), FB_PAT(9), FB_PAT(10), FB_PAT(11),		FB_PAT(12), FB_PAT(13), FB_PAT(14), FB_PAT(15),#endif	};	unsigned long pattern; 	switch (bpp) {	case 0 ... BITS_PER_LONG/4-1:		pattern = mulconst[bpp] * color;		break;	case BITS_PER_LONG/4 ... BITS_PER_LONG/2-1:		pattern = color;		pattern = pattern | pattern << bpp;		pattern = pattern | pattern << bpp*2;		break;	case BITS_PER_LONG/2 ... BITS_PER_LONG-1:		pattern = color;		pattern = pattern | pattern << bpp;		break;	default:		return color;	}#ifndef __LITTLE_ENDIAN	pattern <<= (BITS_PER_LONG % bpp);	pattern |= pattern >> bpp;#endif	return pattern;} /* overwrite bits according to a pattern in a line */static __always_inline void bitfill(const struct fb_address *dst,				    struct fb_pattern *pattern,				    unsigned long (*get)(struct fb_pattern *pattern),				    void (*rotate)(struct fb_pattern *pattern),				    int end){	unsigned long first, last; 	end += dst->bits;	first = fb_pixel_mask(dst->bits, pattern->reverse);	last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), pattern->reverse); 	if (end <= BITS_PER_LONG) {		last = last ? (last & first) : first;		first = get(pattern);		if (last == ~0UL)			fb_write_offset(first, 0, dst);		else if (last)			fb_modify_offset(first, last, 0, dst);	} else {		int offset = first != ~0UL; 		if (offset) {			fb_modify_offset(get(pattern), first, 0, dst);			rotate(pattern);		}		end /= BITS_PER_LONG;		for (; offset + 4 <= end; offset += 4) {			fb_write_offset(get(pattern), offset + 0, dst);			rotate(pattern);			fb_write_offset(get(pattern), offset + 1, dst);			rotate(pattern);			fb_write_offset(get(pattern), offset + 2, dst);			rotate(pattern);			fb_write_offset(get(pattern), offset + 3, dst);			rotate(pattern);		}		while (offset < end) {			fb_write_offset(get(pattern), offset++, dst);			rotate(pattern);		} 		if (last)			fb_modify_offset(get(pattern), last, offset, dst);	}} /* inverts bits according to a pattern in a line */static __always_inline void bitinvert(const struct fb_address *dst,				      struct fb_pattern *pattern,				      unsigned long (*get)(struct fb_pattern *pattern),				      void (*rotate)(struct fb_pattern *pattern),				      int end){	unsigned long first, last;	int offset; 	end += dst->bits;	first = fb_pixel_mask(dst->bits, pattern->reverse);	last = ~fb_pixel_mask(end & (BITS_PER_LONG-1), pattern->reverse); 	if (end <= BITS_PER_LONG) {		offset = 0;		last = last ? (last & first) : first;	} else {		offset = first != ~0UL; 		if (offset) {			first &= get(pattern);			if (first)				fb_invert_offset(first, 0, dst);			rotate(pattern);		} 		end /= BITS_PER_LONG;		for (; offset + 4 <= end; offset += 4) {			fb_invert_offset(get(pattern), offset + 0, dst);			rotate(pattern);			fb_invert_offset(get(pattern), offset + 1, dst);			rotate(pattern);			fb_invert_offset(get(pattern), offset + 2, dst);			rotate(pattern);			fb_invert_offset(get(pattern), offset + 3, dst);			rotate(pattern);		}		while (offset < end) {			fb_invert_offset(get(pattern), offset++, dst);			rotate(pattern);		}	} 	last &= get(pattern);	if (last)		fb_invert_offset(last, offset, dst);} /* pattern doesn't change. 1, 2, 4, 8, 16, 32, 64 bpp */static inline void fb_fillrect_static(const struct fb_fillrect *rect, int bpp,				      struct fb_address *dst, struct fb_pattern *pattern,				      unsigned int bits_per_line){	u32 height = rect->height;	int width = rect->width * bpp; 	if (bpp > 8 && pattern->reverse.byte)		pattern->pixels = swab_long(pattern->pixels); 	if (rect->rop == ROP_XOR)		while (height--) {			bitinvert(dst, pattern, fb_pattern_get, fb_pattern_static, width);			fb_address_forward(dst, bits_per_line);		}	else		while (height--) {			bitfill(dst, pattern, fb_pattern_get, fb_pattern_static, width);			fb_address_forward(dst, bits_per_line);		}} /* rotate pattern to the correct position */static inline unsigned long fb_rotate(unsigned long pattern, int shift, int bpp){	shift %= bpp;	return fb_right(pattern, shift) | fb_left(pattern, bpp - shift);} /* rotating pattern, for example 24 bpp */static __always_inline void fb_fillrect_rotating(const struct fb_fillrect *rect,						 int bpp, struct fb_address *dst,						 struct fb_pattern *pattern,						 unsigned long (*get)(struct fb_pattern *pattern),						 unsigned int bits_per_line){	unsigned long pat = pattern->pixels;	u32 height = rect->height;	int width = rect->width * bpp; 	if (rect->rop == ROP_XOR)		while (height--) {			pattern->pixels = fb_rotate(pat, dst->bits, bpp);			bitinvert(dst, pattern, get, fb_pattern_rotate, width);			fb_address_forward(dst, bits_per_line);		}	else		while (height--) {			pattern->pixels = fb_rotate(pat, dst->bits, bpp);			bitfill(dst, pattern, get, fb_pattern_rotate, width);			fb_address_forward(dst, bits_per_line);		}} static inline void fb_fillrect(struct fb_info *p, const struct fb_fillrect *rect){	int bpp = p->var.bits_per_pixel;	unsigned int bits_per_line = BYTES_TO_BITS(p->fix.line_length);	const u32 *palette = fb_palette(p);	struct fb_address dst = fb_address_init(p);	struct fb_pattern pattern; 	fb_address_forward(&dst, rect->dy * bits_per_line + rect->dx * bpp); 	pattern.pixels = pixel_to_pat(bpp, palette ? palette[rect->color] : rect->color);	pattern.reverse = fb_reverse_init(p);	pattern.left = BITS_PER_LONG % bpp;	if (pattern.left) {		pattern.right = bpp - pattern.left;		if (pattern.reverse.byte)			fb_fillrect_rotating(rect, bpp, &dst, &pattern,					     fb_pattern_get_reverse, bits_per_line);		else			fb_fillrect_rotating(rect, bpp, &dst, &pattern,					     fb_pattern_get, bits_per_line);	} else		fb_fillrect_static(rect, bpp, &dst, &pattern, bits_per_line);}