video/fbdev/c2p_core.h

0001 /*
0002  *  Fast C2P (Chunky-to-Planar) Conversion
0003  *
0004  *  Copyright (C) 2003-2008 Geert Uytterhoeven
0005  *
0006  *  NOTES:
0007  *    - This code was inspired by Scout's C2P tutorial
0008  *    - It assumes to run on a big endian system
0009  *
0010  *  This file is subject to the terms and conditions of the GNU General Public
0011  *  License. See the file COPYING in the main directory of this archive
0012  *  for more details.
0013  */
0014
0015 #include <linux/build_bug.h>
0016
0017
0018     /*
0019      *  Basic transpose step
0020      */
0021
0022 static inline void _transp(u32 d[], unsigned int i1, unsigned int i2,
0023                unsigned int shift, u32 mask)
0024 {
0025     u32 t = (d[i1] ^ (d[i2] >> shift)) & mask;
0026
0027     d[i1] ^= t;
0028     d[i2] ^= t << shift;
0029 }
0030
0031
0032 static __always_inline u32 get_mask(unsigned int n)
0033 {
0034     switch (n) {
0035     case 1:
0036         return 0x55555555;
0037
0038     case 2:
0039         return 0x33333333;
0040
0041     case 4:
0042         return 0x0f0f0f0f;
0043
0044     case 8:
0045         return 0x00ff00ff;
0046
0047     case 16:
0048         return 0x0000ffff;
0049     }
0050
0051     BUILD_BUG();
0052     return 0;
0053 }
0054
0055
0056     /*
0057      *  Transpose operations on 8 32-bit words
0058      */
0059
0060 static __always_inline void transp8(u32 d[], unsigned int n, unsigned int m)
0061 {
0062     u32 mask = get_mask(n);
0063
0064     switch (m) {
0065     case 1:
0066         /* First n x 1 block */
0067         _transp(d, 0, 1, n, mask);
0068         /* Second n x 1 block */
0069         _transp(d, 2, 3, n, mask);
0070         /* Third n x 1 block */
0071         _transp(d, 4, 5, n, mask);
0072         /* Fourth n x 1 block */
0073         _transp(d, 6, 7, n, mask);
0074         return;
0075
0076     case 2:
0077         /* First n x 2 block */
0078         _transp(d, 0, 2, n, mask);
0079         _transp(d, 1, 3, n, mask);
0080         /* Second n x 2 block */
0081         _transp(d, 4, 6, n, mask);
0082         _transp(d, 5, 7, n, mask);
0083         return;
0084
0085     case 4:
0086         /* Single n x 4 block */
0087         _transp(d, 0, 4, n, mask);
0088         _transp(d, 1, 5, n, mask);
0089         _transp(d, 2, 6, n, mask);
0090         _transp(d, 3, 7, n, mask);
0091         return;
0092     }
0093
0094     BUILD_BUG();
0095 }
0096
0097
0098     /*
0099      *  Transpose operations on 4 32-bit words
0100      */
0101
0102 static __always_inline void transp4(u32 d[], unsigned int n, unsigned int m)
0103 {
0104     u32 mask = get_mask(n);
0105
0106     switch (m) {
0107     case 1:
0108         /* First n x 1 block */
0109         _transp(d, 0, 1, n, mask);
0110         /* Second n x 1 block */
0111         _transp(d, 2, 3, n, mask);
0112         return;
0113
0114     case 2:
0115         /* Single n x 2 block */
0116         _transp(d, 0, 2, n, mask);
0117         _transp(d, 1, 3, n, mask);
0118         return;
0119     }
0120
0121     BUILD_BUG();
0122 }
0123
0124
0125     /*
0126      *  Transpose operations on 4 32-bit words (reverse order)
0127      */
0128
0129 static __always_inline void transp4x(u32 d[], unsigned int n, unsigned int m)
0130 {
0131     u32 mask = get_mask(n);
0132
0133     switch (m) {
0134     case 2:
0135         /* Single n x 2 block */
0136         _transp(d, 2, 0, n, mask);
0137         _transp(d, 3, 1, n, mask);
0138         return;
0139     }
0140
0141     BUILD_BUG();
0142 }
0143
0144
0145     /*
0146      *  Compose two values, using a bitmask as decision value
0147      *  This is equivalent to (a & mask) | (b & ~mask)
0148      */
0149
0150 static inline u32 comp(u32 a, u32 b, u32 mask)
0151 {
0152     return ((a ^ b) & mask) ^ b;
0153 }