开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
mach64_cursor.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：6k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

mach64_cursor.c：源码内容
  2. /*
  3.  *  ATI Mach64 CT/VT/GT/LT Cursor Support
  4.  */
  6. #include <linux/slab.h>
  7. #include <linux/console.h>
  8. #include <linux/fb.h>
  9. #include <linux/init.h>
  11. #include <asm/io.h>
  12. #include <asm/uaccess.h>
  14. #include <video/fbcon.h>
  16. #ifdef __sparc__
  17. #include <asm/pbm.h>
  18. #include <asm/fbio.h>
  19. #endif
  21. #include "mach64.h"
  22. #include "atyfb.h"
  25. #define DEFAULT_CURSOR_BLINK_RATE (20)
  26. #define CURSOR_DRAW_DELAY (2)
  29.     /*
  30.      *  Hardware Cursor support.
  31.      */
  33. static const u8 cursor_pixel_map[2] = { 0, 15 };
  34. static const u8 cursor_color_map[2] = { 0, 0xff };
  36. static const u8 cursor_bits_lookup[16] =
  37. {
  38. 0x00, 0x40, 0x10, 0x50, 0x04, 0x44, 0x14, 0x54,
  39. 0x01, 0x41, 0x11, 0x51, 0x05, 0x45, 0x15, 0x55
  40. };
  42. static const u8 cursor_mask_lookup[16] =
  43. {
  44. 0xaa, 0x2a, 0x8a, 0x0a, 0xa2, 0x22, 0x82, 0x02,
  45. 0xa8, 0x28, 0x88, 0x08, 0xa0, 0x20, 0x80, 0x00
  46. };
  48. void aty_set_cursor_color(struct fb_info_aty *fb)
  49. {
  50. struct aty_cursor *c = fb->cursor;
  51. const u8 *pixel = cursor_pixel_map; /* ++Geert: Why?? */
  52. const u8 *red = cursor_color_map;
  53. const u8 *green = cursor_color_map;
  54. const u8 *blue = cursor_color_map;
  55. int i;
  57. if (!c)
  58. return;
  60. #ifdef __sparc__
  61. if (fb->mmaped && (!fb->fb_info.display_fg
  62.     || fb->fb_info.display_fg->vc_num == fb->vtconsole))
  63. return;
  64. #endif
  66. for (i = 0; i < 2; i++) {
  67. c->color[i] =  (u32)red[i] << 24;
  68. c->color[i] |= (u32)green[i] << 16;
  69.   c->color[i] |= (u32)blue[i] <<  8;
  70.   c->color[i] |= (u32)pixel[i];
  71. }
  73. wait_for_fifo(2, fb);
  74. aty_st_le32(CUR_CLR0, c->color[0], fb);
  75. aty_st_le32(CUR_CLR1, c->color[1], fb);
  76. }
  78. void aty_set_cursor_shape(struct fb_info_aty *fb)
  79. {
  80. struct aty_cursor *c = fb->cursor;
  81. u8 *ram, m, b;
  82. int x, y;
  84. if (!c)
  85. return;
  87. #ifdef __sparc__
  88. if (fb->mmaped && (!fb->fb_info.display_fg
  89.     || fb->fb_info.display_fg->vc_num == fb->vtconsole))
  90. return;
  91. #endif
  93. ram = c->ram;
  94. for (y = 0; y < c->size.y; y++) {
  95. for (x = 0; x < c->size.x >> 2; x++) {
  96. m = c->mask[x][y];
  97. b = c->bits[x][y];
  98. fb_writeb (cursor_mask_lookup[m >> 4] |
  99.    cursor_bits_lookup[(b & m) >> 4],
  100.    ram++);
  101. fb_writeb (cursor_mask_lookup[m & 0x0f] |
  102.    cursor_bits_lookup[(b & m) & 0x0f],
  103.    ram++);
  104. }
  105. for ( ; x < 8; x++) {
  106. fb_writeb (0xaa, ram++);
  107. fb_writeb (0xaa, ram++);
  108. }
  109. }
  110. fb_memset (ram, 0xaa, (64 - c->size.y) * 16);
  111. }
  113. static void
  114. aty_set_cursor(struct fb_info_aty *fb, int on)
  115. {
  116. struct atyfb_par *par = &fb->current_par;
  117. struct aty_cursor *c = fb->cursor;
  118. u16 xoff, yoff;
  119. int x, y;
  121. if (!c)
  122. return;
  124. #ifdef __sparc__
  125. if (fb->mmaped && (!fb->fb_info.display_fg
  126.     || fb->fb_info.display_fg->vc_num == fb->vtconsole))
  127. return;
  128. #endif
  130. if (on) {
  131. x = c->pos.x - c->hot.x - par->crtc.xoffset;
  132. if (x < 0) {
  133. xoff = -x;
  134. x = 0;
  135. } else {
  136. xoff = 0;
  137. }
  139. y = c->pos.y - c->hot.y - par->crtc.yoffset;
  140. if (y < 0) {
  141. yoff = -y;
  142. y = 0;
  143. } else {
  144. yoff = 0;
  145. }
  147. wait_for_fifo(4, fb);
  148. aty_st_le32(CUR_OFFSET, (c->offset >> 3) + (yoff << 1), fb);
  149. aty_st_le32(CUR_HORZ_VERT_OFF,
  150.     ((u32)(64 - c->size.y + yoff) << 16) | xoff, fb);
  151. aty_st_le32(CUR_HORZ_VERT_POSN, ((u32)y << 16) | x, fb);
  152. aty_st_le32(GEN_TEST_CNTL, aty_ld_le32(GEN_TEST_CNTL, fb)
  153.        | HWCURSOR_ENABLE, fb);
  154. } else {
  155. wait_for_fifo(1, fb);
  156. aty_st_le32(GEN_TEST_CNTL,
  157.     aty_ld_le32(GEN_TEST_CNTL, fb) & ~HWCURSOR_ENABLE,
  158.     fb);
  159. }
  160. if (fb->blitter_may_be_busy)
  161. wait_for_idle(fb);
  162. }
  164. static void
  165. aty_cursor_timer_handler(unsigned long dev_addr)
  166. {
  167. struct fb_info_aty *fb = (struct fb_info_aty *)dev_addr;
  169. if (!fb->cursor)
  170. return;
  172. if (!fb->cursor->enable)
  173. goto out;
  175. if (fb->cursor->vbl_cnt && --fb->cursor->vbl_cnt == 0) {
  176. fb->cursor->on ^= 1;
  177. aty_set_cursor(fb, fb->cursor->on);
  178. fb->cursor->vbl_cnt = fb->cursor->blink_rate;
  179. }
  181. out:
  182. fb->cursor->timer->expires = jiffies + (HZ / 50);
  183. add_timer(fb->cursor->timer);
  184. }
  186. void atyfb_cursor(struct display *p, int mode, int x, int y)
  187. {
  188. struct fb_info_aty *fb = (struct fb_info_aty *)p->fb_info;
  189. struct aty_cursor *c = fb->cursor;
  191. if (!c)
  192. return;
  194. #ifdef __sparc__
  195. if (fb->mmaped && (!fb->fb_info.display_fg
  196.     || fb->fb_info.display_fg->vc_num == fb->vtconsole))
  197. return;
  198. #endif
  200. x *= fontwidth(p);
  201. y *= fontheight(p);
  202. if (c->pos.x == x && c->pos.y == y && (mode == CM_ERASE) == !c->enable)
  203. return;
  205. c->enable = 0;
  206. if (c->on)
  207. aty_set_cursor(fb, 0);
  208. c->pos.x = x;
  209. c->pos.y = y;
  211. switch (mode) {
  212. case CM_ERASE:
  213. c->on = 0;
  214. break;
  216. case CM_DRAW:
  217. case CM_MOVE:
  218. if (c->on)
  219. aty_set_cursor(fb, 1);
  220. else
  221. c->vbl_cnt = CURSOR_DRAW_DELAY;
  222. c->enable = 1;
  223. break;
  224. }
  225. }
  227. struct aty_cursor * __init aty_init_cursor(struct fb_info_aty *fb)
  228. {
  229. struct aty_cursor *cursor;
  230. unsigned long addr;
  232. cursor = kmalloc(sizeof(struct aty_cursor), GFP_ATOMIC);
  233. if (!cursor)
  234. return 0;
  235. memset(cursor, 0, sizeof(*cursor));
  237. cursor->timer = kmalloc(sizeof(*cursor->timer), GFP_KERNEL);
  238. if (!cursor->timer) {
  239. kfree(cursor);
  240. return 0;
  241. }
  242. memset(cursor->timer, 0, sizeof(*cursor->timer));
  244. cursor->blink_rate = DEFAULT_CURSOR_BLINK_RATE;
  245. fb->total_vram -= PAGE_SIZE;
  246. cursor->offset = fb->total_vram;
  248. #ifdef __sparc__
  249. addr = fb->frame_buffer - 0x800000 + cursor->offset;
  250. cursor->ram = (u8 *)addr;
  251. #else
  252. #ifdef __BIG_ENDIAN
  253. addr = fb->frame_buffer_phys - 0x800000 + cursor->offset;
  254. cursor->ram = (u8 *)ioremap(addr, 1024);
  255. #else
  256. addr = fb->frame_buffer + cursor->offset;
  257. cursor->ram = (u8 *)addr;
  258. #endif
  259. #endif
  261. if (!cursor->ram) {
  262. kfree(cursor);
  263. return NULL;
  264. }
  266. init_timer(cursor->timer);
  267. cursor->timer->expires = jiffies + (HZ / 50);
  268. cursor->timer->data = (unsigned long)fb;
  269. cursor->timer->function = aty_cursor_timer_handler;
  270. add_timer(cursor->timer);
  272. return cursor;
  273. }
  275. int atyfb_set_font(struct display *d, int width, int height)
  276. {
  277.     struct fb_info_aty *fb = (struct fb_info_aty *)d->fb_info;
  278.     struct aty_cursor *c = fb->cursor;
  279.     int i, j;
  281.     if (c) {
  282. if (!width || !height) {
  283.     width = 8;
  284.     height = 16;
  285. }
  287. c->hot.x = 0;
  288. c->hot.y = 0;
  289. c->size.x = width;
  290. c->size.y = height;
  292. memset(c->bits, 0xff, sizeof(c->bits));
  293. memset(c->mask, 0, sizeof(c->mask));
  295. for (i = 0, j = width; j >= 0; j -= 8, i++) {
  296.     c->mask[i][height-2] = (j >= 8) ? 0xff : (0xff << (8 - j));
  297.     c->mask[i][height-1] = (j >= 8) ? 0xff : (0xff << (8 - j));
  298. }
  300. aty_set_cursor_color(fb);
  301. aty_set_cursor_shape(fb);
  302.     }
  303.     return 1;
  304. }