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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
vesafb.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：18k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

vesafb.c：源码内容
  1. /*
  2.  * framebuffer driver for VBE 2.0 compliant graphic boards
  3.  *
  4.  * switching to graphics mode happens at boot time (while
  5.  * running in real mode, see arch/i386/boot/video.S).
  6.  *
  7.  * (c) 1998 Gerd Knorr <kraxel@goldbach.in-berlin.de>
  8.  *
  9.  */
  11. #include <linux/module.h>
  12. #include <linux/kernel.h>
  13. #include <linux/errno.h>
  14. #include <linux/string.h>
  15. #include <linux/mm.h>
  16. #include <linux/tty.h>
  17. #include <linux/slab.h>
  18. #include <linux/delay.h>
  19. #include <linux/fb.h>
  20. #include <linux/console.h>
  21. #include <linux/selection.h>
  22. #include <linux/ioport.h>
  23. #include <linux/init.h>
  25. #include <asm/io.h>
  26. #include <asm/mtrr.h>
  28. #include <video/fbcon.h>
  29. #include <video/fbcon-cfb8.h>
  30. #include <video/fbcon-cfb16.h>
  31. #include <video/fbcon-cfb24.h>
  32. #include <video/fbcon-cfb32.h>
  33. #include <video/fbcon-mac.h>
  35. #define dac_reg (0x3c8)
  36. #define dac_val (0x3c9)
  38. /* --------------------------------------------------------------------- */
  40. /*
  41.  * card parameters
  42.  */
  44. /* card */
  45. unsigned long video_base; /* physical addr */
  46. int   video_size;
  47. char *video_vbase;        /* mapped */
  49. /* mode */
  50. static int  video_bpp;
  51. static int  video_width;
  52. static int  video_height;
  53. static int  video_height_virtual;
  54. static int  video_type = FB_TYPE_PACKED_PIXELS;
  55. static int  video_visual;
  56. static int  video_linelength;
  57. static int  video_cmap_len;
  59. /* --------------------------------------------------------------------- */
  61. static struct fb_var_screeninfo vesafb_defined = {
  62. 0,0,0,0, /* W,H, W, H (virtual) load xres,xres_virtual*/
  63. 0,0, /* virtual -> visible no offset */
  64. 8, /* depth -> load bits_per_pixel */
  65. 0, /* greyscale ? */
  66. {0,0,0}, /* R */
  67. {0,0,0}, /* G */
  68. {0,0,0}, /* B */
  69. {0,0,0}, /* transparency */
  70. 0, /* standard pixel format */
  71. FB_ACTIVATE_NOW,
  72. -1,-1,
  73. 0,
  74. 0L,0L,0L,0L,0L,
  75. 0L,0L,0, /* No sync info */
  76. FB_VMODE_NONINTERLACED,
  77. {0,0,0,0,0,0}
  78. };
  80. static struct display disp;
  81. static struct fb_info fb_info;
  82. static struct { u_short blue, green, red, pad; } palette[256];
  83. static union {
  84. #ifdef FBCON_HAS_CFB16
  85.     u16 cfb16[16];
  86. #endif
  87. #ifdef FBCON_HAS_CFB24
  88.     u32 cfb24[16];
  89. #endif
  90. #ifdef FBCON_HAS_CFB32
  91.     u32 cfb32[16];
  92. #endif
  93. } fbcon_cmap;
  95. static int             inverse   = 0;
  96. static int             mtrr      = 0;
  97. static int             currcon   = 0;
  99. static int             pmi_setpal = 0; /* pmi for palette changes ??? */
  100. static int             ypan       = 0;  /* 0..nothing, 1..ypan, 2..ywrap */
  101. static unsigned short  *pmi_base  = 0;
  102. static void            (*pmi_start)(void);
  103. static void            (*pmi_pal)(void);
  105. static struct display_switch vesafb_sw;
  107. /* --------------------------------------------------------------------- */
  109. static int vesafb_pan_display(struct fb_var_screeninfo *var, int con,
  110.                               struct fb_info *info)
  111. {
  112. #ifdef __i386__
  113. int offset;
  115. if (!ypan)
  116. return -EINVAL;
  117. if (var->xoffset)
  118. return -EINVAL;
  119. if (var->yoffset > var->yres_virtual)
  120. return -EINVAL;
  121. if ((ypan==1) && var->yoffset+var->yres > var->yres_virtual)
  122. return -EINVAL;
  124. offset = (var->yoffset * video_linelength + var->xoffset) / 4;
  126.         __asm__ __volatile__(
  127.                 "call *(%%edi)"
  128.                 : /* no return value */
  129.                 : "a" (0x4f07),         /* EAX */
  130.                   "b" (0),              /* EBX */
  131.                   "c" (offset),         /* ECX */
  132.                   "d" (offset >> 16),   /* EDX */
  133.                   "D" (&pmi_start));    /* EDI */
  134. #endif
  135. return 0;
  136. }
  138. static int vesafb_update_var(int con, struct fb_info *info)
  139. {
  140. if (con == currcon && ypan) {
  141. struct fb_var_screeninfo *var = &fb_display[currcon].var;
  142. return vesafb_pan_display(var,con,info);
  143. }
  144. return 0;
  145. }
  147. static int vesafb_get_fix(struct fb_fix_screeninfo *fix, int con,
  148.  struct fb_info *info)
  149. {
  150. memset(fix, 0, sizeof(struct fb_fix_screeninfo));
  151. strcpy(fix->id,"VESA VGA");
  153. fix->smem_start=video_base;
  154. fix->smem_len=video_size;
  155. fix->type = video_type;
  156. fix->visual = video_visual;
  157. fix->xpanstep  = 0;
  158. fix->ypanstep  = ypan     ? 1 : 0;
  159. fix->ywrapstep = (ypan>1) ? 1 : 0;
  160. fix->line_length=video_linelength;
  161. return 0;
  162. }
  164. static int vesafb_get_var(struct fb_var_screeninfo *var, int con,
  165.  struct fb_info *info)
  166. {
  167. if(con==-1)
  168. memcpy(var, &vesafb_defined, sizeof(struct fb_var_screeninfo));
  169. else
  170. *var=fb_display[con].var;
  171. return 0;
  172. }
  174. static void vesafb_set_disp(int con)
  175. {
  176. struct fb_fix_screeninfo fix;
  177. struct display *display;
  178. struct display_switch *sw;
  180. if (con >= 0)
  181. display = &fb_display[con];
  182. else
  183. display = &disp; /* used during initialization */
  185. vesafb_get_fix(&fix, con, 0);
  187. memset(display, 0, sizeof(struct display));
  188. display->screen_base = video_vbase;
  189. display->visual = fix.visual;
  190. display->type = fix.type;
  191. display->type_aux = fix.type_aux;
  192. display->ypanstep = fix.ypanstep;
  193. display->ywrapstep = fix.ywrapstep;
  194. display->line_length = fix.line_length;
  195. display->next_line = fix.line_length;
  196. display->can_soft_blank = 0;
  197. display->inverse = inverse;
  198. vesafb_get_var(&display->var, -1, &fb_info);
  200. switch (video_bpp) {
  201. #ifdef FBCON_HAS_CFB8
  202. case 8:
  203. sw = &fbcon_cfb8;
  204. break;
  205. #endif
  206. #ifdef FBCON_HAS_CFB16
  207. case 15:
  208. case 16:
  209. sw = &fbcon_cfb16;
  210. display->dispsw_data = fbcon_cmap.cfb16;
  211. break;
  212. #endif
  213. #ifdef FBCON_HAS_CFB24
  214. case 24:
  215. sw = &fbcon_cfb24;
  216. display->dispsw_data = fbcon_cmap.cfb24;
  217. break;
  218. #endif
  219. #ifdef FBCON_HAS_CFB32
  220. case 32:
  221. sw = &fbcon_cfb32;
  222. display->dispsw_data = fbcon_cmap.cfb32;
  223. break;
  224. #endif
  225. default:
  226. #ifdef FBCON_HAS_MAC
  227. sw = &fbcon_mac;
  228. break;
  229. #else
  230. sw = &fbcon_dummy;
  231. return;
  232. #endif
  233. }
  234. memcpy(&vesafb_sw, sw, sizeof(*sw));
  235. display->dispsw = &vesafb_sw;
  236. if (!ypan) {
  237. display->scrollmode = SCROLL_YREDRAW;
  238. vesafb_sw.bmove = fbcon_redraw_bmove;
  239. }
  240. }
  242. static int vesafb_set_var(struct fb_var_screeninfo *var, int con,
  243.   struct fb_info *info)
  244. {
  245. static int first = 1;
  247. if (var->xres           != vesafb_defined.xres           ||
  248.     var->yres           != vesafb_defined.yres           ||
  249.     var->xres_virtual   != vesafb_defined.xres_virtual   ||
  250.     var->yres_virtual   >  video_height_virtual          ||
  251.     var->yres_virtual   <  video_height                  ||
  252.     var->xoffset                                         ||
  253.     var->bits_per_pixel != vesafb_defined.bits_per_pixel ||
  254.     var->nonstd) {
  255. if (first) {
  256. printk(KERN_ERR "Vesafb does not support changing the video moden");
  257. first = 0;
  258. }
  259. return -EINVAL;
  260. }
  262. if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_TEST)
  263. return 0;
  265. if (ypan) {
  266. if (vesafb_defined.yres_virtual != var->yres_virtual) {
  267. vesafb_defined.yres_virtual = var->yres_virtual;
  268. if (con != -1) {
  269. fb_display[con].var = vesafb_defined;
  270. info->changevar(con);
  271. }
  272. }
  274. if (var->yoffset != vesafb_defined.yoffset)
  275. return vesafb_pan_display(var,con,info);
  276. return 0;
  277. }
  279. if (var->yoffset)
  280. return -EINVAL;
  281. return 0;
  282. }
  284. static int vesa_getcolreg(unsigned regno, unsigned *red, unsigned *green,
  285.   unsigned *blue, unsigned *transp,
  286.   struct fb_info *fb_info)
  287. {
  288. /*
  289.  *  Read a single color register and split it into colors/transparent.
  290.  *  Return != 0 for invalid regno.
  291.  */
  293. if (regno >= video_cmap_len)
  294. return 1;
  296. *red   = palette[regno].red;
  297. *green = palette[regno].green;
  298. *blue  = palette[regno].blue;
  299. *transp = 0;
  300. return 0;
  301. }
  303. #ifdef FBCON_HAS_CFB8
  305. static void vesa_setpalette(int regno, unsigned red, unsigned green, unsigned blue)
  306. {
  307. #ifdef i386
  308. struct { u_char blue, green, red, pad; } entry;
  310. if (pmi_setpal) {
  311. entry.red   = red   >> 10;
  312. entry.green = green >> 10;
  313. entry.blue  = blue  >> 10;
  314. entry.pad   = 0;
  315.         __asm__ __volatile__(
  316.                 "call *(%%esi)"
  317.                 : /* no return value */
  318.                 : "a" (0x4f09),         /* EAX */
  319.                   "b" (0),              /* EBX */
  320.                   "c" (1),              /* ECX */
  321.                   "d" (regno),          /* EDX */
  322.                   "D" (&entry),         /* EDI */
  323.                   "S" (&pmi_pal));      /* ESI */
  324. } else {
  325. /* without protected mode interface, try VGA registers... */
  326. outb_p(regno,       dac_reg);
  327. outb_p(red   >> 10, dac_val);
  328. outb_p(green >> 10, dac_val);
  329. outb_p(blue  >> 10, dac_val);
  330. }
  331. #endif
  333. }
  335. #endif
  337. static int vesa_setcolreg(unsigned regno, unsigned red, unsigned green,
  338.   unsigned blue, unsigned transp,
  339.   struct fb_info *fb_info)
  340. {
  341. /*
  342.  *  Set a single color register. The values supplied are
  343.  *  already rounded down to the hardware's capabilities
  344.  *  (according to the entries in the `var' structure). Return
  345.  *  != 0 for invalid regno.
  346.  */
  348. if (regno >= video_cmap_len)
  349. return 1;
  351. palette[regno].red   = red;
  352. palette[regno].green = green;
  353. palette[regno].blue  = blue;
  355. switch (video_bpp) {
  356. #ifdef FBCON_HAS_CFB8
  357. case 8:
  358. vesa_setpalette(regno,red,green,blue);
  359. break;
  360. #endif
  361. #ifdef FBCON_HAS_CFB16
  362. case 15:
  363. case 16:
  364. if (vesafb_defined.red.offset == 10) {
  365. /* 1:5:5:5 */
  366. fbcon_cmap.cfb16[regno] =
  367. ((red   & 0xf800) >>  1) |
  368. ((green & 0xf800) >>  6) |
  369. ((blue  & 0xf800) >> 11);
  370. } else {
  371. /* 0:5:6:5 */
  372. fbcon_cmap.cfb16[regno] =
  373. ((red   & 0xf800)      ) |
  374. ((green & 0xfc00) >>  5) |
  375. ((blue  & 0xf800) >> 11);
  376. }
  377. break;
  378. #endif
  379. #ifdef FBCON_HAS_CFB24
  380. case 24:
  381. red   >>= 8;
  382. green >>= 8;
  383. blue  >>= 8;
  384. fbcon_cmap.cfb24[regno] =
  385. (red   << vesafb_defined.red.offset)   |
  386. (green << vesafb_defined.green.offset) |
  387. (blue  << vesafb_defined.blue.offset);
  388. break;
  389. #endif
  390. #ifdef FBCON_HAS_CFB32
  391. case 32:
  392. red   >>= 8;
  393. green >>= 8;
  394. blue  >>= 8;
  395. fbcon_cmap.cfb32[regno] =
  396. (red   << vesafb_defined.red.offset)   |
  397. (green << vesafb_defined.green.offset) |
  398. (blue  << vesafb_defined.blue.offset);
  399. break;
  400. #endif
  401.     }
  402.     return 0;
  403. }
  405. static void do_install_cmap(int con, struct fb_info *info)
  406. {
  407. if (con != currcon)
  408. return;
  409. if (fb_display[con].cmap.len)
  410. fb_set_cmap(&fb_display[con].cmap, 1, vesa_setcolreg, info);
  411. else
  412. fb_set_cmap(fb_default_cmap(video_cmap_len), 1, vesa_setcolreg,
  413.     info);
  414. }
  416. static int vesafb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
  417.    struct fb_info *info)
  418. {
  419. if (con == currcon) /* current console? */
  420. return fb_get_cmap(cmap, kspc, vesa_getcolreg, info);
  421. else if (fb_display[con].cmap.len) /* non default colormap? */
  422. fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
  423. else
  424. fb_copy_cmap(fb_default_cmap(video_cmap_len),
  425.      cmap, kspc ? 0 : 2);
  426. return 0;
  427. }
  429. static int vesafb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  430.    struct fb_info *info)
  431. {
  432. int err;
  434. if (!fb_display[con].cmap.len) { /* no colormap allocated? */
  435. err = fb_alloc_cmap(&fb_display[con].cmap,video_cmap_len,0);
  436. if (err)
  437. return err;
  438. }
  439. if (con == currcon) /* current console? */
  440. return fb_set_cmap(cmap, kspc, vesa_setcolreg, info);
  441. else
  442. fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
  443. return 0;
  444. }
  446. static struct fb_ops vesafb_ops = {
  447. owner: THIS_MODULE,
  448. fb_get_fix: vesafb_get_fix,
  449. fb_get_var: vesafb_get_var,
  450. fb_set_var: vesafb_set_var,
  451. fb_get_cmap: vesafb_get_cmap,
  452. fb_set_cmap: vesafb_set_cmap,
  453. fb_pan_display: vesafb_pan_display,
  454. };
  456. int __init vesafb_setup(char *options)
  457. {
  458. char *this_opt;
  460. fb_info.fontname[0] = '';
  462. if (!options || !*options)
  463. return 0;
  465. while ((this_opt = strsep(&options, ",")) != NULL) {
  466. if (!*this_opt) continue;
  468. if (! strcmp(this_opt, "inverse"))
  469. inverse=1;
  470. else if (! strcmp(this_opt, "redraw"))
  471. ypan=0;
  472. else if (! strcmp(this_opt, "ypan"))
  473. ypan=1;
  474. else if (! strcmp(this_opt, "ywrap"))
  475. ypan=2;
  476. else if (! strcmp(this_opt, "vgapal"))
  477. pmi_setpal=0;
  478. else if (! strcmp(this_opt, "pmipal"))
  479. pmi_setpal=1;
  480. else if (! strcmp(this_opt, "mtrr"))
  481. mtrr=1;
  482. else if (!strncmp(this_opt, "font:", 5))
  483. strcpy(fb_info.fontname, this_opt+5);
  484. }
  485. return 0;
  486. }
  488. static int vesafb_switch(int con, struct fb_info *info)
  489. {
  490. /* Do we have to save the colormap? */
  491. if (fb_display[currcon].cmap.len)
  492. fb_get_cmap(&fb_display[currcon].cmap, 1, vesa_getcolreg,
  493.     info);
  495. currcon = con;
  496. /* Install new colormap */
  497. do_install_cmap(con, info);
  498. vesafb_update_var(con,info);
  499. return 1;
  500. }
  502. /* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */
  504. static void vesafb_blank(int blank, struct fb_info *info)
  505. {
  506. /* Not supported */
  507. }
  509. int __init vesafb_init(void)
  510. {
  511. int i,j;
  513. if (screen_info.orig_video_isVGA != VIDEO_TYPE_VLFB)
  514. return -ENXIO;
  516. video_base          = screen_info.lfb_base;
  517. video_bpp           = screen_info.lfb_depth;
  518. if (15 == video_bpp)
  519. video_bpp = 16;
  520. video_width         = screen_info.lfb_width;
  521. video_height        = screen_info.lfb_height;
  522. video_linelength    = screen_info.lfb_linelength;
  523. video_size          = screen_info.lfb_size * 65536;
  524. video_visual = (video_bpp == 8) ?
  525. FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
  527. #ifndef __i386__
  528. screen_info.vesapm_seg = 0;
  529. #endif
  531. if (!request_mem_region(video_base, video_size, "vesafb")) {
  532. printk(KERN_WARNING
  533.        "vesafb: abort, cannot reserve video memory at 0x%lxn",
  534. video_base);
  535. /* We cannot make this fatal. Sometimes this comes from magic
  536.    spaces our resource handlers simply don't know about */
  537. }
  539.         video_vbase = ioremap(video_base, video_size);
  540. if (!video_vbase) {
  541. release_mem_region(video_base, video_size);
  542. printk(KERN_ERR
  543.        "vesafb: abort, cannot ioremap video memory 0x%x @ 0x%lxn",
  544. video_size, video_base);
  545. return -EIO;
  546. }
  548. printk(KERN_INFO "vesafb: framebuffer at 0x%lx, mapped to 0x%p, size %dkn",
  549.        video_base, video_vbase, video_size/1024);
  550. printk(KERN_INFO "vesafb: mode is %dx%dx%d, linelength=%d, pages=%dn",
  551.        video_width, video_height, video_bpp, video_linelength, screen_info.pages);
  553. if (screen_info.vesapm_seg) {
  554. printk(KERN_INFO "vesafb: protected mode interface info at %04x:%04xn",
  555.        screen_info.vesapm_seg,screen_info.vesapm_off);
  556. }
  558. if (screen_info.vesapm_seg < 0xc000)
  559. ypan = pmi_setpal = 0; /* not available or some DOS TSR ... */
  561. if (ypan || pmi_setpal) {
  562. pmi_base  = (unsigned short*)bus_to_virt(((unsigned long)screen_info.vesapm_seg << 4) + screen_info.vesapm_off);
  563. pmi_start = (void*)((char*)pmi_base + pmi_base[1]);
  564. pmi_pal   = (void*)((char*)pmi_base + pmi_base[2]);
  565. printk(KERN_INFO "vesafb: pmi: set display start = %p, set palette = %pn",pmi_start,pmi_pal);
  566. if (pmi_base[3]) {
  567. printk(KERN_INFO "vesafb: pmi: ports = ");
  568. for (i = pmi_base[3]/2; pmi_base[i] != 0xffff; i++)
  569. printk("%x ",pmi_base[i]);
  570. printk("n");
  571. if (pmi_base[i] != 0xffff) {
  572. /*
  573.  * memory areas not supported (yet?)
  574.  *
  575.  * Rules are: we have to set up a descriptor for the requested
  576.  * memory area and pass it in the ES register to the BIOS function.
  577.  */
  578. printk(KERN_INFO "vesafb: can't handle memory requests, pmi disabledn");
  579. ypan = pmi_setpal = 0;
  580. }
  581. }
  582. }
  584. vesafb_defined.xres=video_width;
  585. vesafb_defined.yres=video_height;
  586. vesafb_defined.xres_virtual=video_width;
  587. vesafb_defined.yres_virtual=video_size / video_linelength;
  588. vesafb_defined.bits_per_pixel=video_bpp;
  590. if (ypan && vesafb_defined.yres_virtual > video_height) {
  591. printk(KERN_INFO "vesafb: scrolling: %s using protected mode interface, yres_virtual=%dn",
  592.        (ypan > 1) ? "ywrap" : "ypan",vesafb_defined.yres_virtual);
  593. } else {
  594. printk(KERN_INFO "vesafb: scrolling: redrawn");
  595. vesafb_defined.yres_virtual = video_height;
  596. ypan = 0;
  597. }
  598. video_height_virtual = vesafb_defined.yres_virtual;
  600. /* some dummy values for timing to make fbset happy */
  601. vesafb_defined.pixclock     = 10000000 / video_width * 1000 / video_height;
  602. vesafb_defined.left_margin  = (video_width / 8) & 0xf8;
  603. vesafb_defined.right_margin = 32;
  604. vesafb_defined.upper_margin = 16;
  605. vesafb_defined.lower_margin = 4;
  606. vesafb_defined.hsync_len    = (video_width / 8) & 0xf8;
  607. vesafb_defined.vsync_len    = 4;
  609. if (video_bpp > 8) {
  610. vesafb_defined.red.offset    = screen_info.red_pos;
  611. vesafb_defined.red.length    = screen_info.red_size;
  612. vesafb_defined.green.offset  = screen_info.green_pos;
  613. vesafb_defined.green.length  = screen_info.green_size;
  614. vesafb_defined.blue.offset   = screen_info.blue_pos;
  615. vesafb_defined.blue.length   = screen_info.blue_size;
  616. vesafb_defined.transp.offset = screen_info.rsvd_pos;
  617. vesafb_defined.transp.length = screen_info.rsvd_size;
  618. printk(KERN_INFO "vesafb: directcolor: "
  619.        "size=%d:%d:%d:%d, shift=%d:%d:%d:%dn",
  620.        screen_info.rsvd_size,
  621.        screen_info.red_size,
  622.        screen_info.green_size,
  623.        screen_info.blue_size,
  624.        screen_info.rsvd_pos,
  625.        screen_info.red_pos,
  626.        screen_info.green_pos,
  627.        screen_info.blue_pos);
  628. video_cmap_len = 16;
  629. } else {
  630. vesafb_defined.red.length   = 6;
  631. vesafb_defined.green.length = 6;
  632. vesafb_defined.blue.length  = 6;
  633. for(i = 0; i < 16; i++) {
  634. j = color_table[i];
  635. palette[i].red   = default_red[j];
  636. palette[i].green = default_grn[j];
  637. palette[i].blue  = default_blu[j];
  638. }
  639. video_cmap_len = 256;
  640. }
  642. /* request failure does not faze us, as vgacon probably has this
  643.  * region already (FIXME) */
  644. request_region(0x3c0, 32, "vesafb");
  646. if (mtrr) {
  647. int temp_size = video_size;
  648. /* Find the largest power-of-two */
  649. while (temp_size & (temp_size - 1))
  650.                  temp_size &= (temp_size - 1);
  651.                         
  652.                 /* Try and find a power of two to add */
  653. while (temp_size && mtrr_add(video_base, temp_size, MTRR_TYPE_WRCOMB, 1)==-EINVAL) {
  654. temp_size >>= 1;
  655. }
  656. }
  658. strcpy(fb_info.modename, "VESA VGA");
  659. fb_info.changevar = NULL;
  660. fb_info.node = -1;
  661. fb_info.fbops = &vesafb_ops;
  662. fb_info.disp=&disp;
  663. fb_info.switch_con=&vesafb_switch;
  664. fb_info.updatevar=&vesafb_update_var;
  665. fb_info.blank=&vesafb_blank;
  666. fb_info.flags=FBINFO_FLAG_DEFAULT;
  667. vesafb_set_disp(-1);
  669. if (register_framebuffer(&fb_info)<0)
  670. return -EINVAL;
  672. printk(KERN_INFO "fb%d: %s frame buffer devicen",
  673.        GET_FB_IDX(fb_info.node), fb_info.modename);
  674. return 0;
  675. }
  677. /*
  678.  * Overrides for Emacs so that we follow Linus's tabbing style.
  679.  * ---------------------------------------------------------------------------
  680.  * Local variables:
  681.  * c-basic-offset: 8
  682.  * End:
  683.  */
  685. MODULE_LICENSE("GPL");