vesafb.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503
  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. */
  10. #include <linux/module.h>
  11. #include <linux/kernel.h>
  12. #include <linux/errno.h>
  13. #include <linux/string.h>
  14. #include <linux/mm.h>
  15. #include <linux/slab.h>
  16. #include <linux/delay.h>
  17. #include <linux/fb.h>
  18. #include <linux/ioport.h>
  19. #include <linux/init.h>
  20. #include <linux/platform_device.h>
  21. #include <linux/screen_info.h>
  22. #include <video/vga.h>
  23. #include <asm/io.h>
  24. #include <asm/mtrr.h>
  25. #define dac_reg (0x3c8)
  26. #define dac_val (0x3c9)
  27. /* --------------------------------------------------------------------- */
  28. static struct fb_var_screeninfo vesafb_defined __initdata = {
  29. .activate = FB_ACTIVATE_NOW,
  30. .height = -1,
  31. .width = -1,
  32. .right_margin = 32,
  33. .upper_margin = 16,
  34. .lower_margin = 4,
  35. .vsync_len = 4,
  36. .vmode = FB_VMODE_NONINTERLACED,
  37. };
  38. static struct fb_fix_screeninfo vesafb_fix __initdata = {
  39. .id = "VESA VGA",
  40. .type = FB_TYPE_PACKED_PIXELS,
  41. .accel = FB_ACCEL_NONE,
  42. };
  43. static int inverse __read_mostly;
  44. static int mtrr __read_mostly; /* disable mtrr */
  45. static int vram_remap __initdata; /* Set amount of memory to be used */
  46. static int vram_total __initdata; /* Set total amount of memory */
  47. static int pmi_setpal __read_mostly = 1; /* pmi for palette changes ??? */
  48. static int ypan __read_mostly; /* 0..nothing, 1..ypan, 2..ywrap */
  49. static void (*pmi_start)(void) __read_mostly;
  50. static void (*pmi_pal) (void) __read_mostly;
  51. static int depth __read_mostly;
  52. static int vga_compat __read_mostly;
  53. /* --------------------------------------------------------------------- */
  54. static int vesafb_pan_display(struct fb_var_screeninfo *var,
  55. struct fb_info *info)
  56. {
  57. #ifdef __i386__
  58. int offset;
  59. offset = (var->yoffset * info->fix.line_length + var->xoffset) / 4;
  60. __asm__ __volatile__(
  61. "call *(%%edi)"
  62. : /* no return value */
  63. : "a" (0x4f07), /* EAX */
  64. "b" (0), /* EBX */
  65. "c" (offset), /* ECX */
  66. "d" (offset >> 16), /* EDX */
  67. "D" (&pmi_start)); /* EDI */
  68. #endif
  69. return 0;
  70. }
  71. static int vesa_setpalette(int regno, unsigned red, unsigned green,
  72. unsigned blue)
  73. {
  74. int shift = 16 - depth;
  75. int err = -EINVAL;
  76. /*
  77. * Try VGA registers first...
  78. */
  79. if (vga_compat) {
  80. outb_p(regno, dac_reg);
  81. outb_p(red >> shift, dac_val);
  82. outb_p(green >> shift, dac_val);
  83. outb_p(blue >> shift, dac_val);
  84. err = 0;
  85. }
  86. #ifdef __i386__
  87. /*
  88. * Fallback to the PMI....
  89. */
  90. if (err && pmi_setpal) {
  91. struct { u_char blue, green, red, pad; } entry;
  92. entry.red = red >> shift;
  93. entry.green = green >> shift;
  94. entry.blue = blue >> shift;
  95. entry.pad = 0;
  96. __asm__ __volatile__(
  97. "call *(%%esi)"
  98. : /* no return value */
  99. : "a" (0x4f09), /* EAX */
  100. "b" (0), /* EBX */
  101. "c" (1), /* ECX */
  102. "d" (regno), /* EDX */
  103. "D" (&entry), /* EDI */
  104. "S" (&pmi_pal)); /* ESI */
  105. err = 0;
  106. }
  107. #endif
  108. return err;
  109. }
  110. static int vesafb_setcolreg(unsigned regno, unsigned red, unsigned green,
  111. unsigned blue, unsigned transp,
  112. struct fb_info *info)
  113. {
  114. int err = 0;
  115. /*
  116. * Set a single color register. The values supplied are
  117. * already rounded down to the hardware's capabilities
  118. * (according to the entries in the `var' structure). Return
  119. * != 0 for invalid regno.
  120. */
  121. if (regno >= info->cmap.len)
  122. return 1;
  123. if (info->var.bits_per_pixel == 8)
  124. err = vesa_setpalette(regno,red,green,blue);
  125. else if (regno < 16) {
  126. switch (info->var.bits_per_pixel) {
  127. case 16:
  128. if (info->var.red.offset == 10) {
  129. /* 1:5:5:5 */
  130. ((u32*) (info->pseudo_palette))[regno] =
  131. ((red & 0xf800) >> 1) |
  132. ((green & 0xf800) >> 6) |
  133. ((blue & 0xf800) >> 11);
  134. } else {
  135. /* 0:5:6:5 */
  136. ((u32*) (info->pseudo_palette))[regno] =
  137. ((red & 0xf800) ) |
  138. ((green & 0xfc00) >> 5) |
  139. ((blue & 0xf800) >> 11);
  140. }
  141. break;
  142. case 24:
  143. case 32:
  144. red >>= 8;
  145. green >>= 8;
  146. blue >>= 8;
  147. ((u32 *)(info->pseudo_palette))[regno] =
  148. (red << info->var.red.offset) |
  149. (green << info->var.green.offset) |
  150. (blue << info->var.blue.offset);
  151. break;
  152. }
  153. }
  154. return err;
  155. }
  156. static struct fb_ops vesafb_ops = {
  157. .owner = THIS_MODULE,
  158. .fb_setcolreg = vesafb_setcolreg,
  159. .fb_pan_display = vesafb_pan_display,
  160. .fb_fillrect = cfb_fillrect,
  161. .fb_copyarea = cfb_copyarea,
  162. .fb_imageblit = cfb_imageblit,
  163. };
  164. static int __init vesafb_setup(char *options)
  165. {
  166. char *this_opt;
  167. if (!options || !*options)
  168. return 0;
  169. while ((this_opt = strsep(&options, ",")) != NULL) {
  170. if (!*this_opt) continue;
  171. if (! strcmp(this_opt, "inverse"))
  172. inverse=1;
  173. else if (! strcmp(this_opt, "redraw"))
  174. ypan=0;
  175. else if (! strcmp(this_opt, "ypan"))
  176. ypan=1;
  177. else if (! strcmp(this_opt, "ywrap"))
  178. ypan=2;
  179. else if (! strcmp(this_opt, "vgapal"))
  180. pmi_setpal=0;
  181. else if (! strcmp(this_opt, "pmipal"))
  182. pmi_setpal=1;
  183. else if (! strncmp(this_opt, "mtrr:", 5))
  184. mtrr = simple_strtoul(this_opt+5, NULL, 0);
  185. else if (! strcmp(this_opt, "nomtrr"))
  186. mtrr=0;
  187. else if (! strncmp(this_opt, "vtotal:", 7))
  188. vram_total = simple_strtoul(this_opt+7, NULL, 0);
  189. else if (! strncmp(this_opt, "vremap:", 7))
  190. vram_remap = simple_strtoul(this_opt+7, NULL, 0);
  191. }
  192. return 0;
  193. }
  194. static int __init vesafb_probe(struct platform_device *dev)
  195. {
  196. struct fb_info *info;
  197. int i, err;
  198. unsigned int size_vmode;
  199. unsigned int size_remap;
  200. unsigned int size_total;
  201. if (screen_info.orig_video_isVGA != VIDEO_TYPE_VLFB)
  202. return -ENODEV;
  203. vga_compat = (screen_info.capabilities & 2) ? 0 : 1;
  204. vesafb_fix.smem_start = screen_info.lfb_base;
  205. vesafb_defined.bits_per_pixel = screen_info.lfb_depth;
  206. if (15 == vesafb_defined.bits_per_pixel)
  207. vesafb_defined.bits_per_pixel = 16;
  208. vesafb_defined.xres = screen_info.lfb_width;
  209. vesafb_defined.yres = screen_info.lfb_height;
  210. vesafb_fix.line_length = screen_info.lfb_linelength;
  211. vesafb_fix.visual = (vesafb_defined.bits_per_pixel == 8) ?
  212. FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
  213. /* size_vmode -- that is the amount of memory needed for the
  214. * used video mode, i.e. the minimum amount of
  215. * memory we need. */
  216. size_vmode = vesafb_defined.yres * vesafb_fix.line_length;
  217. /* size_total -- all video memory we have. Used for mtrr
  218. * entries, ressource allocation and bounds
  219. * checking. */
  220. size_total = screen_info.lfb_size * 65536;
  221. if (vram_total)
  222. size_total = vram_total * 1024 * 1024;
  223. if (size_total < size_vmode)
  224. size_total = size_vmode;
  225. /* size_remap -- the amount of video memory we are going to
  226. * use for vesafb. With modern cards it is no
  227. * option to simply use size_total as that
  228. * wastes plenty of kernel address space. */
  229. size_remap = size_vmode * 2;
  230. if (vram_remap)
  231. size_remap = vram_remap * 1024 * 1024;
  232. if (size_remap < size_vmode)
  233. size_remap = size_vmode;
  234. if (size_remap > size_total)
  235. size_remap = size_total;
  236. vesafb_fix.smem_len = size_remap;
  237. #ifndef __i386__
  238. screen_info.vesapm_seg = 0;
  239. #endif
  240. if (!request_mem_region(vesafb_fix.smem_start, size_total, "vesafb")) {
  241. printk(KERN_WARNING
  242. "vesafb: cannot reserve video memory at 0x%lx\n",
  243. vesafb_fix.smem_start);
  244. /* We cannot make this fatal. Sometimes this comes from magic
  245. spaces our resource handlers simply don't know about */
  246. }
  247. info = framebuffer_alloc(sizeof(u32) * 256, &dev->dev);
  248. if (!info) {
  249. release_mem_region(vesafb_fix.smem_start, size_total);
  250. return -ENOMEM;
  251. }
  252. info->pseudo_palette = info->par;
  253. info->par = NULL;
  254. info->screen_base = ioremap(vesafb_fix.smem_start, vesafb_fix.smem_len);
  255. if (!info->screen_base) {
  256. printk(KERN_ERR
  257. "vesafb: abort, cannot ioremap video memory 0x%x @ 0x%lx\n",
  258. vesafb_fix.smem_len, vesafb_fix.smem_start);
  259. err = -EIO;
  260. goto err;
  261. }
  262. printk(KERN_INFO "vesafb: framebuffer at 0x%lx, mapped to 0x%p, "
  263. "using %dk, total %dk\n",
  264. vesafb_fix.smem_start, info->screen_base,
  265. size_remap/1024, size_total/1024);
  266. printk(KERN_INFO "vesafb: mode is %dx%dx%d, linelength=%d, pages=%d\n",
  267. vesafb_defined.xres, vesafb_defined.yres, vesafb_defined.bits_per_pixel, vesafb_fix.line_length, screen_info.pages);
  268. if (screen_info.vesapm_seg) {
  269. printk(KERN_INFO "vesafb: protected mode interface info at %04x:%04x\n",
  270. screen_info.vesapm_seg,screen_info.vesapm_off);
  271. }
  272. if (screen_info.vesapm_seg < 0xc000)
  273. ypan = pmi_setpal = 0; /* not available or some DOS TSR ... */
  274. if (ypan || pmi_setpal) {
  275. unsigned short *pmi_base;
  276. pmi_base = (unsigned short*)phys_to_virt(((unsigned long)screen_info.vesapm_seg << 4) + screen_info.vesapm_off);
  277. pmi_start = (void*)((char*)pmi_base + pmi_base[1]);
  278. pmi_pal = (void*)((char*)pmi_base + pmi_base[2]);
  279. printk(KERN_INFO "vesafb: pmi: set display start = %p, set palette = %p\n",pmi_start,pmi_pal);
  280. if (pmi_base[3]) {
  281. printk(KERN_INFO "vesafb: pmi: ports = ");
  282. for (i = pmi_base[3]/2; pmi_base[i] != 0xffff; i++)
  283. printk("%x ",pmi_base[i]);
  284. printk("\n");
  285. if (pmi_base[i] != 0xffff) {
  286. /*
  287. * memory areas not supported (yet?)
  288. *
  289. * Rules are: we have to set up a descriptor for the requested
  290. * memory area and pass it in the ES register to the BIOS function.
  291. */
  292. printk(KERN_INFO "vesafb: can't handle memory requests, pmi disabled\n");
  293. ypan = pmi_setpal = 0;
  294. }
  295. }
  296. }
  297. if (vesafb_defined.bits_per_pixel == 8 && !pmi_setpal && !vga_compat) {
  298. printk(KERN_WARNING "vesafb: hardware palette is unchangeable,\n"
  299. " colors may be incorrect\n");
  300. vesafb_fix.visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
  301. }
  302. vesafb_defined.xres_virtual = vesafb_defined.xres;
  303. vesafb_defined.yres_virtual = vesafb_fix.smem_len / vesafb_fix.line_length;
  304. if (ypan && vesafb_defined.yres_virtual > vesafb_defined.yres) {
  305. printk(KERN_INFO "vesafb: scrolling: %s using protected mode interface, yres_virtual=%d\n",
  306. (ypan > 1) ? "ywrap" : "ypan",vesafb_defined.yres_virtual);
  307. } else {
  308. printk(KERN_INFO "vesafb: scrolling: redraw\n");
  309. vesafb_defined.yres_virtual = vesafb_defined.yres;
  310. ypan = 0;
  311. }
  312. /* some dummy values for timing to make fbset happy */
  313. vesafb_defined.pixclock = 10000000 / vesafb_defined.xres * 1000 / vesafb_defined.yres;
  314. vesafb_defined.left_margin = (vesafb_defined.xres / 8) & 0xf8;
  315. vesafb_defined.hsync_len = (vesafb_defined.xres / 8) & 0xf8;
  316. vesafb_defined.red.offset = screen_info.red_pos;
  317. vesafb_defined.red.length = screen_info.red_size;
  318. vesafb_defined.green.offset = screen_info.green_pos;
  319. vesafb_defined.green.length = screen_info.green_size;
  320. vesafb_defined.blue.offset = screen_info.blue_pos;
  321. vesafb_defined.blue.length = screen_info.blue_size;
  322. vesafb_defined.transp.offset = screen_info.rsvd_pos;
  323. vesafb_defined.transp.length = screen_info.rsvd_size;
  324. if (vesafb_defined.bits_per_pixel <= 8) {
  325. depth = vesafb_defined.green.length;
  326. vesafb_defined.red.length =
  327. vesafb_defined.green.length =
  328. vesafb_defined.blue.length =
  329. vesafb_defined.bits_per_pixel;
  330. }
  331. printk(KERN_INFO "vesafb: %s: "
  332. "size=%d:%d:%d:%d, shift=%d:%d:%d:%d\n",
  333. (vesafb_defined.bits_per_pixel > 8) ?
  334. "Truecolor" : (vga_compat || pmi_setpal) ?
  335. "Pseudocolor" : "Static Pseudocolor",
  336. screen_info.rsvd_size,
  337. screen_info.red_size,
  338. screen_info.green_size,
  339. screen_info.blue_size,
  340. screen_info.rsvd_pos,
  341. screen_info.red_pos,
  342. screen_info.green_pos,
  343. screen_info.blue_pos);
  344. vesafb_fix.ypanstep = ypan ? 1 : 0;
  345. vesafb_fix.ywrapstep = (ypan>1) ? 1 : 0;
  346. /* request failure does not faze us, as vgacon probably has this
  347. * region already (FIXME) */
  348. request_region(0x3c0, 32, "vesafb");
  349. #ifdef CONFIG_MTRR
  350. if (mtrr) {
  351. unsigned int temp_size = size_total;
  352. unsigned int type = 0;
  353. switch (mtrr) {
  354. case 1:
  355. type = MTRR_TYPE_UNCACHABLE;
  356. break;
  357. case 2:
  358. type = MTRR_TYPE_WRBACK;
  359. break;
  360. case 3:
  361. type = MTRR_TYPE_WRCOMB;
  362. break;
  363. case 4:
  364. type = MTRR_TYPE_WRTHROUGH;
  365. break;
  366. default:
  367. type = 0;
  368. break;
  369. }
  370. if (type) {
  371. int rc;
  372. /* Find the largest power-of-two */
  373. while (temp_size & (temp_size - 1))
  374. temp_size &= (temp_size - 1);
  375. /* Try and find a power of two to add */
  376. do {
  377. rc = mtrr_add(vesafb_fix.smem_start, temp_size,
  378. type, 1);
  379. temp_size >>= 1;
  380. } while (temp_size >= PAGE_SIZE && rc == -EINVAL);
  381. }
  382. }
  383. #endif
  384. info->fbops = &vesafb_ops;
  385. info->var = vesafb_defined;
  386. info->fix = vesafb_fix;
  387. info->flags = FBINFO_FLAG_DEFAULT |
  388. (ypan) ? FBINFO_HWACCEL_YPAN : 0;
  389. if (!ypan)
  390. info->fbops->fb_pan_display = NULL;
  391. if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
  392. err = -ENOMEM;
  393. goto err;
  394. }
  395. if (register_framebuffer(info)<0) {
  396. err = -EINVAL;
  397. fb_dealloc_cmap(&info->cmap);
  398. goto err;
  399. }
  400. printk(KERN_INFO "fb%d: %s frame buffer device\n",
  401. info->node, info->fix.id);
  402. return 0;
  403. err:
  404. if (info->screen_base)
  405. iounmap(info->screen_base);
  406. framebuffer_release(info);
  407. release_mem_region(vesafb_fix.smem_start, size_total);
  408. return err;
  409. }
  410. static struct platform_driver vesafb_driver = {
  411. .probe = vesafb_probe,
  412. .driver = {
  413. .name = "vesafb",
  414. },
  415. };
  416. static struct platform_device *vesafb_device;
  417. static int __init vesafb_init(void)
  418. {
  419. int ret;
  420. char *option = NULL;
  421. /* ignore error return of fb_get_options */
  422. fb_get_options("vesafb", &option);
  423. vesafb_setup(option);
  424. ret = platform_driver_register(&vesafb_driver);
  425. if (!ret) {
  426. vesafb_device = platform_device_alloc("vesafb", 0);
  427. if (vesafb_device)
  428. ret = platform_device_add(vesafb_device);
  429. else
  430. ret = -ENOMEM;
  431. if (ret) {
  432. platform_device_put(vesafb_device);
  433. platform_driver_unregister(&vesafb_driver);
  434. }
  435. }
  436. return ret;
  437. }
  438. module_init(vesafb_init);
  439. MODULE_LICENSE("GPL");