atafb_iplan2p8.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322
  1. /*
  2. * linux/drivers/video/iplan2p8.c -- Low level frame buffer operations for
  3. * interleaved bitplanes à la Atari (8
  4. * planes, 2 bytes interleave)
  5. *
  6. * Created 5 Apr 1997 by Geert Uytterhoeven
  7. *
  8. * This file is subject to the terms and conditions of the GNU General Public
  9. * License. See the file COPYING in the main directory of this archive for
  10. * more details.
  11. */
  12. #include <linux/string.h>
  13. #include <linux/fb.h>
  14. #include <asm/setup.h>
  15. #include "atafb.h"
  16. #define BPL 8
  17. #include "atafb_utils.h"
  18. /* Copies a 8 plane column from 's', height 'h', to 'd'. */
  19. /* This expands a 8 bit color into two longs for two movepl (8 plane)
  20. * operations.
  21. */
  22. void atafb_iplan2p8_copyarea(struct fb_info *info, u_long next_line,
  23. int sy, int sx, int dy, int dx,
  24. int height, int width)
  25. {
  26. /* bmove() has to distinguish two major cases: If both, source and
  27. * destination, start at even addresses or both are at odd
  28. * addresses, just the first odd and last even column (if present)
  29. * require special treatment (memmove_col()). The rest between
  30. * then can be copied by normal operations, because all adjacent
  31. * bytes are affected and are to be stored in the same order.
  32. * The pathological case is when the move should go from an odd
  33. * address to an even or vice versa. Since the bytes in the plane
  34. * words must be assembled in new order, it seems wisest to make
  35. * all movements by memmove_col().
  36. */
  37. u8 *src, *dst;
  38. u32 *s, *d;
  39. int w, l , i, j;
  40. u_int colsize;
  41. u_int upwards = (dy < sy) || (dy == sy && dx < sx);
  42. colsize = height;
  43. if (!((sx ^ dx) & 15)) {
  44. /* odd->odd or even->even */
  45. if (upwards) {
  46. src = (u8 *)info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL);
  47. dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);
  48. if (sx & 15) {
  49. memmove32_col(dst, src, 0xff00ff, height, next_line - BPL * 2);
  50. src += BPL * 2;
  51. dst += BPL * 2;
  52. width -= 8;
  53. }
  54. w = width >> 4;
  55. if (w) {
  56. s = (u32 *)src;
  57. d = (u32 *)dst;
  58. w *= BPL / 2;
  59. l = next_line - w * 4;
  60. for (j = height; j > 0; j--) {
  61. for (i = w; i > 0; i--)
  62. *d++ = *s++;
  63. s = (u32 *)((u8 *)s + l);
  64. d = (u32 *)((u8 *)d + l);
  65. }
  66. }
  67. if (width & 15)
  68. memmove32_col(dst + width / (8 / BPL), src + width / (8 / BPL),
  69. 0xff00ff00, height, next_line - BPL * 2);
  70. } else {
  71. src = (u8 *)info->screen_base + (sy - 1) * next_line + ((sx + width + 8) & ~15) / (8 / BPL);
  72. dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);
  73. if ((sx + width) & 15) {
  74. src -= BPL * 2;
  75. dst -= BPL * 2;
  76. memmove32_col(dst, src, 0xff00ff00, colsize, -next_line - BPL * 2);
  77. width -= 8;
  78. }
  79. w = width >> 4;
  80. if (w) {
  81. s = (u32 *)src;
  82. d = (u32 *)dst;
  83. w *= BPL / 2;
  84. l = next_line - w * 4;
  85. for (j = height; j > 0; j--) {
  86. for (i = w; i > 0; i--)
  87. *--d = *--s;
  88. s = (u32 *)((u8 *)s - l);
  89. d = (u32 *)((u8 *)d - l);
  90. }
  91. }
  92. if (sx & 15)
  93. memmove32_col(dst - (width - 16) / (8 / BPL),
  94. src - (width - 16) / (8 / BPL),
  95. 0xff00ff, colsize, -next_line - BPL * 2);
  96. }
  97. } else {
  98. /* odd->even or even->odd */
  99. if (upwards) {
  100. u32 *src32, *dst32;
  101. u32 pval[4], v, v1, mask;
  102. int i, j, w, f;
  103. src = (u8 *)info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL);
  104. dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);
  105. mask = 0xff00ff00;
  106. f = 0;
  107. w = width;
  108. if (sx & 15) {
  109. f = 1;
  110. w += 8;
  111. }
  112. if ((sx + width) & 15)
  113. f |= 2;
  114. w >>= 4;
  115. for (i = height; i; i--) {
  116. src32 = (u32 *)src;
  117. dst32 = (u32 *)dst;
  118. if (f & 1) {
  119. pval[0] = (*src32++ << 8) & mask;
  120. pval[1] = (*src32++ << 8) & mask;
  121. pval[2] = (*src32++ << 8) & mask;
  122. pval[3] = (*src32++ << 8) & mask;
  123. } else {
  124. pval[0] = dst32[0] & mask;
  125. pval[1] = dst32[1] & mask;
  126. pval[2] = dst32[2] & mask;
  127. pval[3] = dst32[3] & mask;
  128. }
  129. for (j = w; j > 0; j--) {
  130. v = *src32++;
  131. v1 = v & mask;
  132. *dst32++ = pval[0] | (v1 >> 8);
  133. pval[0] = (v ^ v1) << 8;
  134. v = *src32++;
  135. v1 = v & mask;
  136. *dst32++ = pval[1] | (v1 >> 8);
  137. pval[1] = (v ^ v1) << 8;
  138. v = *src32++;
  139. v1 = v & mask;
  140. *dst32++ = pval[2] | (v1 >> 8);
  141. pval[2] = (v ^ v1) << 8;
  142. v = *src32++;
  143. v1 = v & mask;
  144. *dst32++ = pval[3] | (v1 >> 8);
  145. pval[3] = (v ^ v1) << 8;
  146. }
  147. if (f & 2) {
  148. dst32[0] = (dst32[0] & mask) | pval[0];
  149. dst32[1] = (dst32[1] & mask) | pval[1];
  150. dst32[2] = (dst32[2] & mask) | pval[2];
  151. dst32[3] = (dst32[3] & mask) | pval[3];
  152. }
  153. src += next_line;
  154. dst += next_line;
  155. }
  156. } else {
  157. u32 *src32, *dst32;
  158. u32 pval[4], v, v1, mask;
  159. int i, j, w, f;
  160. src = (u8 *)info->screen_base + (sy - 1) * next_line + ((sx + width + 8) & ~15) / (8 / BPL);
  161. dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);
  162. mask = 0xff00ff;
  163. f = 0;
  164. w = width;
  165. if ((dx + width) & 15)
  166. f = 1;
  167. if (sx & 15) {
  168. f |= 2;
  169. w += 8;
  170. }
  171. w >>= 4;
  172. for (i = height; i; i--) {
  173. src32 = (u32 *)src;
  174. dst32 = (u32 *)dst;
  175. if (f & 1) {
  176. pval[0] = dst32[-1] & mask;
  177. pval[1] = dst32[-2] & mask;
  178. pval[2] = dst32[-3] & mask;
  179. pval[3] = dst32[-4] & mask;
  180. } else {
  181. pval[0] = (*--src32 >> 8) & mask;
  182. pval[1] = (*--src32 >> 8) & mask;
  183. pval[2] = (*--src32 >> 8) & mask;
  184. pval[3] = (*--src32 >> 8) & mask;
  185. }
  186. for (j = w; j > 0; j--) {
  187. v = *--src32;
  188. v1 = v & mask;
  189. *--dst32 = pval[0] | (v1 << 8);
  190. pval[0] = (v ^ v1) >> 8;
  191. v = *--src32;
  192. v1 = v & mask;
  193. *--dst32 = pval[1] | (v1 << 8);
  194. pval[1] = (v ^ v1) >> 8;
  195. v = *--src32;
  196. v1 = v & mask;
  197. *--dst32 = pval[2] | (v1 << 8);
  198. pval[2] = (v ^ v1) >> 8;
  199. v = *--src32;
  200. v1 = v & mask;
  201. *--dst32 = pval[3] | (v1 << 8);
  202. pval[3] = (v ^ v1) >> 8;
  203. }
  204. if (!(f & 2)) {
  205. dst32[-1] = (dst32[-1] & mask) | pval[0];
  206. dst32[-2] = (dst32[-2] & mask) | pval[1];
  207. dst32[-3] = (dst32[-3] & mask) | pval[2];
  208. dst32[-4] = (dst32[-4] & mask) | pval[3];
  209. }
  210. src -= next_line;
  211. dst -= next_line;
  212. }
  213. }
  214. }
  215. }
  216. void atafb_iplan2p8_fillrect(struct fb_info *info, u_long next_line, u32 color,
  217. int sy, int sx, int height, int width)
  218. {
  219. u32 *dest;
  220. int rows, i;
  221. u32 cval[4];
  222. dest = (u32 *)(info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL));
  223. if (sx & 15) {
  224. u8 *dest8 = (u8 *)dest + 1;
  225. expand8_col2mask(color, cval);
  226. for (i = height; i; i--) {
  227. fill8_col(dest8, cval);
  228. dest8 += next_line;
  229. }
  230. dest += BPL / 2;
  231. width -= 8;
  232. }
  233. expand16_col2mask(color, cval);
  234. rows = width >> 4;
  235. if (rows) {
  236. u32 *d = dest;
  237. u32 off = next_line - rows * BPL * 2;
  238. for (i = height; i; i--) {
  239. d = fill16_col(d, rows, cval);
  240. d = (u32 *)((long)d + off);
  241. }
  242. dest += rows * BPL / 2;
  243. width &= 15;
  244. }
  245. if (width) {
  246. u8 *dest8 = (u8 *)dest;
  247. expand8_col2mask(color, cval);
  248. for (i = height; i; i--) {
  249. fill8_col(dest8, cval);
  250. dest8 += next_line;
  251. }
  252. }
  253. }
  254. void atafb_iplan2p8_linefill(struct fb_info *info, u_long next_line,
  255. int dy, int dx, u32 width,
  256. const u8 *data, u32 bgcolor, u32 fgcolor)
  257. {
  258. u32 *dest;
  259. const u16 *data16;
  260. int rows;
  261. u32 fgm[4], bgm[4], m;
  262. dest = (u32 *)(info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL));
  263. if (dx & 15) {
  264. fill8_2col((u8 *)dest + 1, fgcolor, bgcolor, *data++);
  265. dest += BPL / 2;
  266. width -= 8;
  267. }
  268. if (width >= 16) {
  269. data16 = (const u16 *)data;
  270. expand16_2col2mask(fgcolor, bgcolor, fgm, bgm);
  271. for (rows = width / 16; rows; rows--) {
  272. u16 d = *data16++;
  273. m = d | ((u32)d << 16);
  274. *dest++ = (m & fgm[0]) ^ bgm[0];
  275. *dest++ = (m & fgm[1]) ^ bgm[1];
  276. *dest++ = (m & fgm[2]) ^ bgm[2];
  277. *dest++ = (m & fgm[3]) ^ bgm[3];
  278. }
  279. data = (const u8 *)data16;
  280. width &= 15;
  281. }
  282. if (width)
  283. fill8_2col((u8 *)dest, fgcolor, bgcolor, *data);
  284. }