fbmem.c 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827
  1. /*
  2. * linux/drivers/video/fbmem.c
  3. *
  4. * Copyright (C) 1994 Martin Schaller
  5. *
  6. * 2001 - Documented with DocBook
  7. * - Brad Douglas <brad@neruo.com>
  8. *
  9. * This file is subject to the terms and conditions of the GNU General Public
  10. * License. See the file COPYING in the main directory of this archive
  11. * for more details.
  12. */
  13. #include <linux/module.h>
  14. #include <linux/compat.h>
  15. #include <linux/types.h>
  16. #include <linux/errno.h>
  17. #include <linux/smp_lock.h>
  18. #include <linux/kernel.h>
  19. #include <linux/major.h>
  20. #include <linux/slab.h>
  21. #include <linux/mm.h>
  22. #include <linux/mman.h>
  23. #include <linux/vt.h>
  24. #include <linux/init.h>
  25. #include <linux/linux_logo.h>
  26. #include <linux/proc_fs.h>
  27. #include <linux/seq_file.h>
  28. #include <linux/console.h>
  29. #include <linux/kmod.h>
  30. #include <linux/err.h>
  31. #include <linux/device.h>
  32. #include <linux/efi.h>
  33. #include <linux/fb.h>
  34. #include <asm/fb.h>
  35. /*
  36. * Frame buffer device initialization and setup routines
  37. */
  38. #define FBPIXMAPSIZE (1024 * 8)
  39. struct fb_info *registered_fb[FB_MAX] __read_mostly;
  40. int num_registered_fb __read_mostly;
  41. int lock_fb_info(struct fb_info *info)
  42. {
  43. mutex_lock(&info->lock);
  44. if (!info->fbops) {
  45. mutex_unlock(&info->lock);
  46. return 0;
  47. }
  48. return 1;
  49. }
  50. EXPORT_SYMBOL(lock_fb_info);
  51. /*
  52. * Helpers
  53. */
  54. int fb_get_color_depth(struct fb_var_screeninfo *var,
  55. struct fb_fix_screeninfo *fix)
  56. {
  57. int depth = 0;
  58. if (fix->visual == FB_VISUAL_MONO01 ||
  59. fix->visual == FB_VISUAL_MONO10)
  60. depth = 1;
  61. else {
  62. if (var->green.length == var->blue.length &&
  63. var->green.length == var->red.length &&
  64. var->green.offset == var->blue.offset &&
  65. var->green.offset == var->red.offset)
  66. depth = var->green.length;
  67. else
  68. depth = var->green.length + var->red.length +
  69. var->blue.length;
  70. }
  71. return depth;
  72. }
  73. EXPORT_SYMBOL(fb_get_color_depth);
  74. /*
  75. * Data padding functions.
  76. */
  77. void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height)
  78. {
  79. __fb_pad_aligned_buffer(dst, d_pitch, src, s_pitch, height);
  80. }
  81. EXPORT_SYMBOL(fb_pad_aligned_buffer);
  82. void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx, u32 height,
  83. u32 shift_high, u32 shift_low, u32 mod)
  84. {
  85. u8 mask = (u8) (0xfff << shift_high), tmp;
  86. int i, j;
  87. for (i = height; i--; ) {
  88. for (j = 0; j < idx; j++) {
  89. tmp = dst[j];
  90. tmp &= mask;
  91. tmp |= *src >> shift_low;
  92. dst[j] = tmp;
  93. tmp = *src << shift_high;
  94. dst[j+1] = tmp;
  95. src++;
  96. }
  97. tmp = dst[idx];
  98. tmp &= mask;
  99. tmp |= *src >> shift_low;
  100. dst[idx] = tmp;
  101. if (shift_high < mod) {
  102. tmp = *src << shift_high;
  103. dst[idx+1] = tmp;
  104. }
  105. src++;
  106. dst += d_pitch;
  107. }
  108. }
  109. EXPORT_SYMBOL(fb_pad_unaligned_buffer);
  110. /*
  111. * we need to lock this section since fb_cursor
  112. * may use fb_imageblit()
  113. */
  114. char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size)
  115. {
  116. u32 align = buf->buf_align - 1, offset;
  117. char *addr = buf->addr;
  118. /* If IO mapped, we need to sync before access, no sharing of
  119. * the pixmap is done
  120. */
  121. if (buf->flags & FB_PIXMAP_IO) {
  122. if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC))
  123. info->fbops->fb_sync(info);
  124. return addr;
  125. }
  126. /* See if we fit in the remaining pixmap space */
  127. offset = buf->offset + align;
  128. offset &= ~align;
  129. if (offset + size > buf->size) {
  130. /* We do not fit. In order to be able to re-use the buffer,
  131. * we must ensure no asynchronous DMA'ing or whatever operation
  132. * is in progress, we sync for that.
  133. */
  134. if (info->fbops->fb_sync && (buf->flags & FB_PIXMAP_SYNC))
  135. info->fbops->fb_sync(info);
  136. offset = 0;
  137. }
  138. buf->offset = offset + size;
  139. addr += offset;
  140. return addr;
  141. }
  142. #ifdef CONFIG_LOGO
  143. static inline unsigned safe_shift(unsigned d, int n)
  144. {
  145. return n < 0 ? d >> -n : d << n;
  146. }
  147. static void fb_set_logocmap(struct fb_info *info,
  148. const struct linux_logo *logo)
  149. {
  150. struct fb_cmap palette_cmap;
  151. u16 palette_green[16];
  152. u16 palette_blue[16];
  153. u16 palette_red[16];
  154. int i, j, n;
  155. const unsigned char *clut = logo->clut;
  156. palette_cmap.start = 0;
  157. palette_cmap.len = 16;
  158. palette_cmap.red = palette_red;
  159. palette_cmap.green = palette_green;
  160. palette_cmap.blue = palette_blue;
  161. palette_cmap.transp = NULL;
  162. for (i = 0; i < logo->clutsize; i += n) {
  163. n = logo->clutsize - i;
  164. /* palette_cmap provides space for only 16 colors at once */
  165. if (n > 16)
  166. n = 16;
  167. palette_cmap.start = 32 + i;
  168. palette_cmap.len = n;
  169. for (j = 0; j < n; ++j) {
  170. palette_cmap.red[j] = clut[0] << 8 | clut[0];
  171. palette_cmap.green[j] = clut[1] << 8 | clut[1];
  172. palette_cmap.blue[j] = clut[2] << 8 | clut[2];
  173. clut += 3;
  174. }
  175. fb_set_cmap(&palette_cmap, info);
  176. }
  177. }
  178. static void fb_set_logo_truepalette(struct fb_info *info,
  179. const struct linux_logo *logo,
  180. u32 *palette)
  181. {
  182. static const unsigned char mask[] = { 0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff };
  183. unsigned char redmask, greenmask, bluemask;
  184. int redshift, greenshift, blueshift;
  185. int i;
  186. const unsigned char *clut = logo->clut;
  187. /*
  188. * We have to create a temporary palette since console palette is only
  189. * 16 colors long.
  190. */
  191. /* Bug: Doesn't obey msb_right ... (who needs that?) */
  192. redmask = mask[info->var.red.length < 8 ? info->var.red.length : 8];
  193. greenmask = mask[info->var.green.length < 8 ? info->var.green.length : 8];
  194. bluemask = mask[info->var.blue.length < 8 ? info->var.blue.length : 8];
  195. redshift = info->var.red.offset - (8 - info->var.red.length);
  196. greenshift = info->var.green.offset - (8 - info->var.green.length);
  197. blueshift = info->var.blue.offset - (8 - info->var.blue.length);
  198. for ( i = 0; i < logo->clutsize; i++) {
  199. palette[i+32] = (safe_shift((clut[0] & redmask), redshift) |
  200. safe_shift((clut[1] & greenmask), greenshift) |
  201. safe_shift((clut[2] & bluemask), blueshift));
  202. clut += 3;
  203. }
  204. }
  205. static void fb_set_logo_directpalette(struct fb_info *info,
  206. const struct linux_logo *logo,
  207. u32 *palette)
  208. {
  209. int redshift, greenshift, blueshift;
  210. int i;
  211. redshift = info->var.red.offset;
  212. greenshift = info->var.green.offset;
  213. blueshift = info->var.blue.offset;
  214. for (i = 32; i < 32 + logo->clutsize; i++)
  215. palette[i] = i << redshift | i << greenshift | i << blueshift;
  216. }
  217. static void fb_set_logo(struct fb_info *info,
  218. const struct linux_logo *logo, u8 *dst,
  219. int depth)
  220. {
  221. int i, j, k;
  222. const u8 *src = logo->data;
  223. u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0;
  224. u8 fg = 1, d;
  225. switch (fb_get_color_depth(&info->var, &info->fix)) {
  226. case 1:
  227. fg = 1;
  228. break;
  229. case 2:
  230. fg = 3;
  231. break;
  232. default:
  233. fg = 7;
  234. break;
  235. }
  236. if (info->fix.visual == FB_VISUAL_MONO01 ||
  237. info->fix.visual == FB_VISUAL_MONO10)
  238. fg = ~((u8) (0xfff << info->var.green.length));
  239. switch (depth) {
  240. case 4:
  241. for (i = 0; i < logo->height; i++)
  242. for (j = 0; j < logo->width; src++) {
  243. *dst++ = *src >> 4;
  244. j++;
  245. if (j < logo->width) {
  246. *dst++ = *src & 0x0f;
  247. j++;
  248. }
  249. }
  250. break;
  251. case 1:
  252. for (i = 0; i < logo->height; i++) {
  253. for (j = 0; j < logo->width; src++) {
  254. d = *src ^ xor;
  255. for (k = 7; k >= 0; k--) {
  256. *dst++ = ((d >> k) & 1) ? fg : 0;
  257. j++;
  258. }
  259. }
  260. }
  261. break;
  262. }
  263. }
  264. /*
  265. * Three (3) kinds of logo maps exist. linux_logo_clut224 (>16 colors),
  266. * linux_logo_vga16 (16 colors) and linux_logo_mono (2 colors). Depending on
  267. * the visual format and color depth of the framebuffer, the DAC, the
  268. * pseudo_palette, and the logo data will be adjusted accordingly.
  269. *
  270. * Case 1 - linux_logo_clut224:
  271. * Color exceeds the number of console colors (16), thus we set the hardware DAC
  272. * using fb_set_cmap() appropriately. The "needs_cmapreset" flag will be set.
  273. *
  274. * For visuals that require color info from the pseudo_palette, we also construct
  275. * one for temporary use. The "needs_directpalette" or "needs_truepalette" flags
  276. * will be set.
  277. *
  278. * Case 2 - linux_logo_vga16:
  279. * The number of colors just matches the console colors, thus there is no need
  280. * to set the DAC or the pseudo_palette. However, the bitmap is packed, ie,
  281. * each byte contains color information for two pixels (upper and lower nibble).
  282. * To be consistent with fb_imageblit() usage, we therefore separate the two
  283. * nibbles into separate bytes. The "depth" flag will be set to 4.
  284. *
  285. * Case 3 - linux_logo_mono:
  286. * This is similar with Case 2. Each byte contains information for 8 pixels.
  287. * We isolate each bit and expand each into a byte. The "depth" flag will
  288. * be set to 1.
  289. */
  290. static struct logo_data {
  291. int depth;
  292. int needs_directpalette;
  293. int needs_truepalette;
  294. int needs_cmapreset;
  295. const struct linux_logo *logo;
  296. } fb_logo __read_mostly;
  297. static void fb_rotate_logo_ud(const u8 *in, u8 *out, u32 width, u32 height)
  298. {
  299. u32 size = width * height, i;
  300. out += size - 1;
  301. for (i = size; i--; )
  302. *out-- = *in++;
  303. }
  304. static void fb_rotate_logo_cw(const u8 *in, u8 *out, u32 width, u32 height)
  305. {
  306. int i, j, h = height - 1;
  307. for (i = 0; i < height; i++)
  308. for (j = 0; j < width; j++)
  309. out[height * j + h - i] = *in++;
  310. }
  311. static void fb_rotate_logo_ccw(const u8 *in, u8 *out, u32 width, u32 height)
  312. {
  313. int i, j, w = width - 1;
  314. for (i = 0; i < height; i++)
  315. for (j = 0; j < width; j++)
  316. out[height * (w - j) + i] = *in++;
  317. }
  318. static void fb_rotate_logo(struct fb_info *info, u8 *dst,
  319. struct fb_image *image, int rotate)
  320. {
  321. u32 tmp;
  322. if (rotate == FB_ROTATE_UD) {
  323. fb_rotate_logo_ud(image->data, dst, image->width,
  324. image->height);
  325. image->dx = info->var.xres - image->width - image->dx;
  326. image->dy = info->var.yres - image->height - image->dy;
  327. } else if (rotate == FB_ROTATE_CW) {
  328. fb_rotate_logo_cw(image->data, dst, image->width,
  329. image->height);
  330. tmp = image->width;
  331. image->width = image->height;
  332. image->height = tmp;
  333. tmp = image->dy;
  334. image->dy = image->dx;
  335. image->dx = info->var.xres - image->width - tmp;
  336. } else if (rotate == FB_ROTATE_CCW) {
  337. fb_rotate_logo_ccw(image->data, dst, image->width,
  338. image->height);
  339. tmp = image->width;
  340. image->width = image->height;
  341. image->height = tmp;
  342. tmp = image->dx;
  343. image->dx = image->dy;
  344. image->dy = info->var.yres - image->height - tmp;
  345. }
  346. image->data = dst;
  347. }
  348. static void fb_do_show_logo(struct fb_info *info, struct fb_image *image,
  349. int rotate, unsigned int num)
  350. {
  351. unsigned int x;
  352. if (rotate == FB_ROTATE_UR) {
  353. for (x = 0;
  354. x < num && image->dx + image->width <= info->var.xres;
  355. x++) {
  356. info->fbops->fb_imageblit(info, image);
  357. image->dx += image->width + 8;
  358. }
  359. } else if (rotate == FB_ROTATE_UD) {
  360. for (x = 0; x < num && image->dx >= 0; x++) {
  361. info->fbops->fb_imageblit(info, image);
  362. image->dx -= image->width + 8;
  363. }
  364. } else if (rotate == FB_ROTATE_CW) {
  365. for (x = 0;
  366. x < num && image->dy + image->height <= info->var.yres;
  367. x++) {
  368. info->fbops->fb_imageblit(info, image);
  369. image->dy += image->height + 8;
  370. }
  371. } else if (rotate == FB_ROTATE_CCW) {
  372. for (x = 0; x < num && image->dy >= 0; x++) {
  373. info->fbops->fb_imageblit(info, image);
  374. image->dy -= image->height + 8;
  375. }
  376. }
  377. }
  378. static int fb_show_logo_line(struct fb_info *info, int rotate,
  379. const struct linux_logo *logo, int y,
  380. unsigned int n)
  381. {
  382. u32 *palette = NULL, *saved_pseudo_palette = NULL;
  383. unsigned char *logo_new = NULL, *logo_rotate = NULL;
  384. struct fb_image image;
  385. /* Return if the frame buffer is not mapped or suspended */
  386. if (logo == NULL || info->state != FBINFO_STATE_RUNNING ||
  387. info->flags & FBINFO_MODULE)
  388. return 0;
  389. image.depth = 8;
  390. image.data = logo->data;
  391. if (fb_logo.needs_cmapreset)
  392. fb_set_logocmap(info, logo);
  393. if (fb_logo.needs_truepalette ||
  394. fb_logo.needs_directpalette) {
  395. palette = kmalloc(256 * 4, GFP_KERNEL);
  396. if (palette == NULL)
  397. return 0;
  398. if (fb_logo.needs_truepalette)
  399. fb_set_logo_truepalette(info, logo, palette);
  400. else
  401. fb_set_logo_directpalette(info, logo, palette);
  402. saved_pseudo_palette = info->pseudo_palette;
  403. info->pseudo_palette = palette;
  404. }
  405. if (fb_logo.depth <= 4) {
  406. logo_new = kmalloc(logo->width * logo->height, GFP_KERNEL);
  407. if (logo_new == NULL) {
  408. kfree(palette);
  409. if (saved_pseudo_palette)
  410. info->pseudo_palette = saved_pseudo_palette;
  411. return 0;
  412. }
  413. image.data = logo_new;
  414. fb_set_logo(info, logo, logo_new, fb_logo.depth);
  415. }
  416. image.dx = 0;
  417. image.dy = y;
  418. image.width = logo->width;
  419. image.height = logo->height;
  420. if (rotate) {
  421. logo_rotate = kmalloc(logo->width *
  422. logo->height, GFP_KERNEL);
  423. if (logo_rotate)
  424. fb_rotate_logo(info, logo_rotate, &image, rotate);
  425. }
  426. fb_do_show_logo(info, &image, rotate, n);
  427. kfree(palette);
  428. if (saved_pseudo_palette != NULL)
  429. info->pseudo_palette = saved_pseudo_palette;
  430. kfree(logo_new);
  431. kfree(logo_rotate);
  432. return logo->height;
  433. }
  434. #ifdef CONFIG_FB_LOGO_EXTRA
  435. #define FB_LOGO_EX_NUM_MAX 10
  436. static struct logo_data_extra {
  437. const struct linux_logo *logo;
  438. unsigned int n;
  439. } fb_logo_ex[FB_LOGO_EX_NUM_MAX];
  440. static unsigned int fb_logo_ex_num;
  441. void fb_append_extra_logo(const struct linux_logo *logo, unsigned int n)
  442. {
  443. if (!n || fb_logo_ex_num == FB_LOGO_EX_NUM_MAX)
  444. return;
  445. fb_logo_ex[fb_logo_ex_num].logo = logo;
  446. fb_logo_ex[fb_logo_ex_num].n = n;
  447. fb_logo_ex_num++;
  448. }
  449. static int fb_prepare_extra_logos(struct fb_info *info, unsigned int height,
  450. unsigned int yres)
  451. {
  452. unsigned int i;
  453. /* FIXME: logo_ex supports only truecolor fb. */
  454. if (info->fix.visual != FB_VISUAL_TRUECOLOR)
  455. fb_logo_ex_num = 0;
  456. for (i = 0; i < fb_logo_ex_num; i++) {
  457. if (fb_logo_ex[i].logo->type != fb_logo.logo->type) {
  458. fb_logo_ex[i].logo = NULL;
  459. continue;
  460. }
  461. height += fb_logo_ex[i].logo->height;
  462. if (height > yres) {
  463. height -= fb_logo_ex[i].logo->height;
  464. fb_logo_ex_num = i;
  465. break;
  466. }
  467. }
  468. return height;
  469. }
  470. static int fb_show_extra_logos(struct fb_info *info, int y, int rotate)
  471. {
  472. unsigned int i;
  473. for (i = 0; i < fb_logo_ex_num; i++)
  474. y += fb_show_logo_line(info, rotate,
  475. fb_logo_ex[i].logo, y, fb_logo_ex[i].n);
  476. return y;
  477. }
  478. #else /* !CONFIG_FB_LOGO_EXTRA */
  479. static inline int fb_prepare_extra_logos(struct fb_info *info,
  480. unsigned int height,
  481. unsigned int yres)
  482. {
  483. return height;
  484. }
  485. static inline int fb_show_extra_logos(struct fb_info *info, int y, int rotate)
  486. {
  487. return y;
  488. }
  489. #endif /* CONFIG_FB_LOGO_EXTRA */
  490. int fb_prepare_logo(struct fb_info *info, int rotate)
  491. {
  492. int depth = fb_get_color_depth(&info->var, &info->fix);
  493. unsigned int yres;
  494. memset(&fb_logo, 0, sizeof(struct logo_data));
  495. if (info->flags & FBINFO_MISC_TILEBLITTING ||
  496. info->flags & FBINFO_MODULE)
  497. return 0;
  498. if (info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
  499. depth = info->var.blue.length;
  500. if (info->var.red.length < depth)
  501. depth = info->var.red.length;
  502. if (info->var.green.length < depth)
  503. depth = info->var.green.length;
  504. }
  505. if (info->fix.visual == FB_VISUAL_STATIC_PSEUDOCOLOR && depth > 4) {
  506. /* assume console colormap */
  507. depth = 4;
  508. }
  509. /* Return if no suitable logo was found */
  510. fb_logo.logo = fb_find_logo(depth);
  511. if (!fb_logo.logo) {
  512. return 0;
  513. }
  514. if (rotate == FB_ROTATE_UR || rotate == FB_ROTATE_UD)
  515. yres = info->var.yres;
  516. else
  517. yres = info->var.xres;
  518. if (fb_logo.logo->height > yres) {
  519. fb_logo.logo = NULL;
  520. return 0;
  521. }
  522. /* What depth we asked for might be different from what we get */
  523. if (fb_logo.logo->type == LINUX_LOGO_CLUT224)
  524. fb_logo.depth = 8;
  525. else if (fb_logo.logo->type == LINUX_LOGO_VGA16)
  526. fb_logo.depth = 4;
  527. else
  528. fb_logo.depth = 1;
  529. if (fb_logo.depth > 4 && depth > 4) {
  530. switch (info->fix.visual) {
  531. case FB_VISUAL_TRUECOLOR:
  532. fb_logo.needs_truepalette = 1;
  533. break;
  534. case FB_VISUAL_DIRECTCOLOR:
  535. fb_logo.needs_directpalette = 1;
  536. fb_logo.needs_cmapreset = 1;
  537. break;
  538. case FB_VISUAL_PSEUDOCOLOR:
  539. fb_logo.needs_cmapreset = 1;
  540. break;
  541. }
  542. }
  543. return fb_prepare_extra_logos(info, fb_logo.logo->height, yres);
  544. }
  545. int fb_show_logo(struct fb_info *info, int rotate)
  546. {
  547. int y;
  548. y = fb_show_logo_line(info, rotate, fb_logo.logo, 0,
  549. num_online_cpus());
  550. y = fb_show_extra_logos(info, y, rotate);
  551. return y;
  552. }
  553. #else
  554. int fb_prepare_logo(struct fb_info *info, int rotate) { return 0; }
  555. int fb_show_logo(struct fb_info *info, int rotate) { return 0; }
  556. #endif /* CONFIG_LOGO */
  557. static void *fb_seq_start(struct seq_file *m, loff_t *pos)
  558. {
  559. return (*pos < FB_MAX) ? pos : NULL;
  560. }
  561. static void *fb_seq_next(struct seq_file *m, void *v, loff_t *pos)
  562. {
  563. (*pos)++;
  564. return (*pos < FB_MAX) ? pos : NULL;
  565. }
  566. static void fb_seq_stop(struct seq_file *m, void *v)
  567. {
  568. }
  569. static int fb_seq_show(struct seq_file *m, void *v)
  570. {
  571. int i = *(loff_t *)v;
  572. struct fb_info *fi = registered_fb[i];
  573. if (fi)
  574. seq_printf(m, "%d %s\n", fi->node, fi->fix.id);
  575. return 0;
  576. }
  577. static const struct seq_operations proc_fb_seq_ops = {
  578. .start = fb_seq_start,
  579. .next = fb_seq_next,
  580. .stop = fb_seq_stop,
  581. .show = fb_seq_show,
  582. };
  583. static int proc_fb_open(struct inode *inode, struct file *file)
  584. {
  585. return seq_open(file, &proc_fb_seq_ops);
  586. }
  587. static const struct file_operations fb_proc_fops = {
  588. .owner = THIS_MODULE,
  589. .open = proc_fb_open,
  590. .read = seq_read,
  591. .llseek = seq_lseek,
  592. .release = seq_release,
  593. };
  594. static ssize_t
  595. fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
  596. {
  597. unsigned long p = *ppos;
  598. struct inode *inode = file->f_path.dentry->d_inode;
  599. int fbidx = iminor(inode);
  600. struct fb_info *info = registered_fb[fbidx];
  601. u32 *buffer, *dst;
  602. u32 __iomem *src;
  603. int c, i, cnt = 0, err = 0;
  604. unsigned long total_size;
  605. if (!info || ! info->screen_base)
  606. return -ENODEV;
  607. if (info->state != FBINFO_STATE_RUNNING)
  608. return -EPERM;
  609. if (info->fbops->fb_read)
  610. return info->fbops->fb_read(info, buf, count, ppos);
  611. total_size = info->screen_size;
  612. if (total_size == 0)
  613. total_size = info->fix.smem_len;
  614. if (p >= total_size)
  615. return 0;
  616. if (count >= total_size)
  617. count = total_size;
  618. if (count + p > total_size)
  619. count = total_size - p;
  620. buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
  621. GFP_KERNEL);
  622. if (!buffer)
  623. return -ENOMEM;
  624. src = (u32 __iomem *) (info->screen_base + p);
  625. if (info->fbops->fb_sync)
  626. info->fbops->fb_sync(info);
  627. while (count) {
  628. c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
  629. dst = buffer;
  630. for (i = c >> 2; i--; )
  631. *dst++ = fb_readl(src++);
  632. if (c & 3) {
  633. u8 *dst8 = (u8 *) dst;
  634. u8 __iomem *src8 = (u8 __iomem *) src;
  635. for (i = c & 3; i--;)
  636. *dst8++ = fb_readb(src8++);
  637. src = (u32 __iomem *) src8;
  638. }
  639. if (copy_to_user(buf, buffer, c)) {
  640. err = -EFAULT;
  641. break;
  642. }
  643. *ppos += c;
  644. buf += c;
  645. cnt += c;
  646. count -= c;
  647. }
  648. kfree(buffer);
  649. return (err) ? err : cnt;
  650. }
  651. static ssize_t
  652. fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
  653. {
  654. unsigned long p = *ppos;
  655. struct inode *inode = file->f_path.dentry->d_inode;
  656. int fbidx = iminor(inode);
  657. struct fb_info *info = registered_fb[fbidx];
  658. u32 *buffer, *src;
  659. u32 __iomem *dst;
  660. int c, i, cnt = 0, err = 0;
  661. unsigned long total_size;
  662. if (!info || !info->screen_base)
  663. return -ENODEV;
  664. if (info->state != FBINFO_STATE_RUNNING)
  665. return -EPERM;
  666. if (info->fbops->fb_write)
  667. return info->fbops->fb_write(info, buf, count, ppos);
  668. total_size = info->screen_size;
  669. if (total_size == 0)
  670. total_size = info->fix.smem_len;
  671. if (p > total_size)
  672. return -EFBIG;
  673. if (count > total_size) {
  674. err = -EFBIG;
  675. count = total_size;
  676. }
  677. if (count + p > total_size) {
  678. if (!err)
  679. err = -ENOSPC;
  680. count = total_size - p;
  681. }
  682. buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
  683. GFP_KERNEL);
  684. if (!buffer)
  685. return -ENOMEM;
  686. dst = (u32 __iomem *) (info->screen_base + p);
  687. if (info->fbops->fb_sync)
  688. info->fbops->fb_sync(info);
  689. while (count) {
  690. c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
  691. src = buffer;
  692. if (copy_from_user(src, buf, c)) {
  693. err = -EFAULT;
  694. break;
  695. }
  696. for (i = c >> 2; i--; )
  697. fb_writel(*src++, dst++);
  698. if (c & 3) {
  699. u8 *src8 = (u8 *) src;
  700. u8 __iomem *dst8 = (u8 __iomem *) dst;
  701. for (i = c & 3; i--; )
  702. fb_writeb(*src8++, dst8++);
  703. dst = (u32 __iomem *) dst8;
  704. }
  705. *ppos += c;
  706. buf += c;
  707. cnt += c;
  708. count -= c;
  709. }
  710. kfree(buffer);
  711. return (cnt) ? cnt : err;
  712. }
  713. int
  714. fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
  715. {
  716. struct fb_fix_screeninfo *fix = &info->fix;
  717. unsigned int yres = info->var.yres;
  718. int err = 0;
  719. if (var->yoffset > 0) {
  720. if (var->vmode & FB_VMODE_YWRAP) {
  721. if (!fix->ywrapstep || (var->yoffset % fix->ywrapstep))
  722. err = -EINVAL;
  723. else
  724. yres = 0;
  725. } else if (!fix->ypanstep || (var->yoffset % fix->ypanstep))
  726. err = -EINVAL;
  727. }
  728. if (var->xoffset > 0 && (!fix->xpanstep ||
  729. (var->xoffset % fix->xpanstep)))
  730. err = -EINVAL;
  731. if (err || !info->fbops->fb_pan_display ||
  732. var->yoffset + yres > info->var.yres_virtual ||
  733. var->xoffset + info->var.xres > info->var.xres_virtual)
  734. return -EINVAL;
  735. if ((err = info->fbops->fb_pan_display(var, info)))
  736. return err;
  737. info->var.xoffset = var->xoffset;
  738. info->var.yoffset = var->yoffset;
  739. if (var->vmode & FB_VMODE_YWRAP)
  740. info->var.vmode |= FB_VMODE_YWRAP;
  741. else
  742. info->var.vmode &= ~FB_VMODE_YWRAP;
  743. return 0;
  744. }
  745. static int fb_check_caps(struct fb_info *info, struct fb_var_screeninfo *var,
  746. u32 activate)
  747. {
  748. struct fb_event event;
  749. struct fb_blit_caps caps, fbcaps;
  750. int err = 0;
  751. memset(&caps, 0, sizeof(caps));
  752. memset(&fbcaps, 0, sizeof(fbcaps));
  753. caps.flags = (activate & FB_ACTIVATE_ALL) ? 1 : 0;
  754. event.info = info;
  755. event.data = &caps;
  756. fb_notifier_call_chain(FB_EVENT_GET_REQ, &event);
  757. info->fbops->fb_get_caps(info, &fbcaps, var);
  758. if (((fbcaps.x ^ caps.x) & caps.x) ||
  759. ((fbcaps.y ^ caps.y) & caps.y) ||
  760. (fbcaps.len < caps.len))
  761. err = -EINVAL;
  762. return err;
  763. }
  764. int
  765. fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
  766. {
  767. int flags = info->flags;
  768. int ret = 0;
  769. if (var->activate & FB_ACTIVATE_INV_MODE) {
  770. struct fb_videomode mode1, mode2;
  771. fb_var_to_videomode(&mode1, var);
  772. fb_var_to_videomode(&mode2, &info->var);
  773. /* make sure we don't delete the videomode of current var */
  774. ret = fb_mode_is_equal(&mode1, &mode2);
  775. if (!ret) {
  776. struct fb_event event;
  777. event.info = info;
  778. event.data = &mode1;
  779. ret = fb_notifier_call_chain(FB_EVENT_MODE_DELETE, &event);
  780. }
  781. if (!ret)
  782. fb_delete_videomode(&mode1, &info->modelist);
  783. ret = (ret) ? -EINVAL : 0;
  784. goto done;
  785. }
  786. if ((var->activate & FB_ACTIVATE_FORCE) ||
  787. memcmp(&info->var, var, sizeof(struct fb_var_screeninfo))) {
  788. u32 activate = var->activate;
  789. if (!info->fbops->fb_check_var) {
  790. *var = info->var;
  791. goto done;
  792. }
  793. ret = info->fbops->fb_check_var(var, info);
  794. if (ret)
  795. goto done;
  796. if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
  797. struct fb_videomode mode;
  798. if (info->fbops->fb_get_caps) {
  799. ret = fb_check_caps(info, var, activate);
  800. if (ret)
  801. goto done;
  802. }
  803. info->var = *var;
  804. if (info->fbops->fb_set_par)
  805. info->fbops->fb_set_par(info);
  806. fb_pan_display(info, &info->var);
  807. fb_set_cmap(&info->cmap, info);
  808. fb_var_to_videomode(&mode, &info->var);
  809. if (info->modelist.prev && info->modelist.next &&
  810. !list_empty(&info->modelist))
  811. ret = fb_add_videomode(&mode, &info->modelist);
  812. if (!ret && (flags & FBINFO_MISC_USEREVENT)) {
  813. struct fb_event event;
  814. int evnt = (activate & FB_ACTIVATE_ALL) ?
  815. FB_EVENT_MODE_CHANGE_ALL :
  816. FB_EVENT_MODE_CHANGE;
  817. info->flags &= ~FBINFO_MISC_USEREVENT;
  818. event.info = info;
  819. event.data = &mode;
  820. fb_notifier_call_chain(evnt, &event);
  821. }
  822. }
  823. }
  824. done:
  825. return ret;
  826. }
  827. int
  828. fb_blank(struct fb_info *info, int blank)
  829. {
  830. int ret = -EINVAL;
  831. if (blank > FB_BLANK_POWERDOWN)
  832. blank = FB_BLANK_POWERDOWN;
  833. if (info->fbops->fb_blank)
  834. ret = info->fbops->fb_blank(blank, info);
  835. if (!ret) {
  836. struct fb_event event;
  837. event.info = info;
  838. event.data = &blank;
  839. fb_notifier_call_chain(FB_EVENT_BLANK, &event);
  840. }
  841. return ret;
  842. }
  843. static long do_fb_ioctl(struct fb_info *info, unsigned int cmd,
  844. unsigned long arg)
  845. {
  846. struct fb_ops *fb;
  847. struct fb_var_screeninfo var;
  848. struct fb_fix_screeninfo fix;
  849. struct fb_con2fbmap con2fb;
  850. struct fb_cmap cmap_from;
  851. struct fb_cmap_user cmap;
  852. struct fb_event event;
  853. void __user *argp = (void __user *)arg;
  854. long ret = 0;
  855. switch (cmd) {
  856. case FBIOGET_VSCREENINFO:
  857. if (!lock_fb_info(info))
  858. return -ENODEV;
  859. var = info->var;
  860. unlock_fb_info(info);
  861. ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0;
  862. break;
  863. case FBIOPUT_VSCREENINFO:
  864. if (copy_from_user(&var, argp, sizeof(var)))
  865. return -EFAULT;
  866. if (!lock_fb_info(info))
  867. return -ENODEV;
  868. acquire_console_sem();
  869. info->flags |= FBINFO_MISC_USEREVENT;
  870. ret = fb_set_var(info, &var);
  871. info->flags &= ~FBINFO_MISC_USEREVENT;
  872. release_console_sem();
  873. unlock_fb_info(info);
  874. if (!ret && copy_to_user(argp, &var, sizeof(var)))
  875. ret = -EFAULT;
  876. break;
  877. case FBIOGET_FSCREENINFO:
  878. if (!lock_fb_info(info))
  879. return -ENODEV;
  880. fix = info->fix;
  881. unlock_fb_info(info);
  882. ret = copy_to_user(argp, &fix, sizeof(fix)) ? -EFAULT : 0;
  883. break;
  884. case FBIOPUTCMAP:
  885. if (copy_from_user(&cmap, argp, sizeof(cmap)))
  886. return -EFAULT;
  887. ret = fb_set_user_cmap(&cmap, info);
  888. break;
  889. case FBIOGETCMAP:
  890. if (copy_from_user(&cmap, argp, sizeof(cmap)))
  891. return -EFAULT;
  892. if (!lock_fb_info(info))
  893. return -ENODEV;
  894. cmap_from = info->cmap;
  895. unlock_fb_info(info);
  896. ret = fb_cmap_to_user(&cmap_from, &cmap);
  897. break;
  898. case FBIOPAN_DISPLAY:
  899. if (copy_from_user(&var, argp, sizeof(var)))
  900. return -EFAULT;
  901. if (!lock_fb_info(info))
  902. return -ENODEV;
  903. acquire_console_sem();
  904. ret = fb_pan_display(info, &var);
  905. release_console_sem();
  906. unlock_fb_info(info);
  907. if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
  908. return -EFAULT;
  909. break;
  910. case FBIO_CURSOR:
  911. ret = -EINVAL;
  912. break;
  913. case FBIOGET_CON2FBMAP:
  914. if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
  915. return -EFAULT;
  916. if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
  917. return -EINVAL;
  918. con2fb.framebuffer = -1;
  919. event.data = &con2fb;
  920. if (!lock_fb_info(info))
  921. return -ENODEV;
  922. event.info = info;
  923. fb_notifier_call_chain(FB_EVENT_GET_CONSOLE_MAP, &event);
  924. unlock_fb_info(info);
  925. ret = copy_to_user(argp, &con2fb, sizeof(con2fb)) ? -EFAULT : 0;
  926. break;
  927. case FBIOPUT_CON2FBMAP:
  928. if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
  929. return -EFAULT;
  930. if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
  931. return -EINVAL;
  932. if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX)
  933. return -EINVAL;
  934. if (!registered_fb[con2fb.framebuffer])
  935. request_module("fb%d", con2fb.framebuffer);
  936. if (!registered_fb[con2fb.framebuffer]) {
  937. ret = -EINVAL;
  938. break;
  939. }
  940. event.data = &con2fb;
  941. if (!lock_fb_info(info))
  942. return -ENODEV;
  943. event.info = info;
  944. ret = fb_notifier_call_chain(FB_EVENT_SET_CONSOLE_MAP, &event);
  945. unlock_fb_info(info);
  946. break;
  947. case FBIOBLANK:
  948. if (!lock_fb_info(info))
  949. return -ENODEV;
  950. acquire_console_sem();
  951. info->flags |= FBINFO_MISC_USEREVENT;
  952. ret = fb_blank(info, arg);
  953. info->flags &= ~FBINFO_MISC_USEREVENT;
  954. release_console_sem();
  955. unlock_fb_info(info);
  956. break;
  957. default:
  958. if (!lock_fb_info(info))
  959. return -ENODEV;
  960. fb = info->fbops;
  961. if (fb->fb_ioctl)
  962. ret = fb->fb_ioctl(info, cmd, arg);
  963. else
  964. ret = -ENOTTY;
  965. unlock_fb_info(info);
  966. }
  967. return ret;
  968. }
  969. static long fb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  970. {
  971. struct inode *inode = file->f_path.dentry->d_inode;
  972. int fbidx = iminor(inode);
  973. struct fb_info *info = registered_fb[fbidx];
  974. return do_fb_ioctl(info, cmd, arg);
  975. }
  976. #ifdef CONFIG_COMPAT
  977. struct fb_fix_screeninfo32 {
  978. char id[16];
  979. compat_caddr_t smem_start;
  980. u32 smem_len;
  981. u32 type;
  982. u32 type_aux;
  983. u32 visual;
  984. u16 xpanstep;
  985. u16 ypanstep;
  986. u16 ywrapstep;
  987. u32 line_length;
  988. compat_caddr_t mmio_start;
  989. u32 mmio_len;
  990. u32 accel;
  991. u16 reserved[3];
  992. };
  993. struct fb_cmap32 {
  994. u32 start;
  995. u32 len;
  996. compat_caddr_t red;
  997. compat_caddr_t green;
  998. compat_caddr_t blue;
  999. compat_caddr_t transp;
  1000. };
  1001. static int fb_getput_cmap(struct fb_info *info, unsigned int cmd,
  1002. unsigned long arg)
  1003. {
  1004. struct fb_cmap_user __user *cmap;
  1005. struct fb_cmap32 __user *cmap32;
  1006. __u32 data;
  1007. int err;
  1008. cmap = compat_alloc_user_space(sizeof(*cmap));
  1009. cmap32 = compat_ptr(arg);
  1010. if (copy_in_user(&cmap->start, &cmap32->start, 2 * sizeof(__u32)))
  1011. return -EFAULT;
  1012. if (get_user(data, &cmap32->red) ||
  1013. put_user(compat_ptr(data), &cmap->red) ||
  1014. get_user(data, &cmap32->green) ||
  1015. put_user(compat_ptr(data), &cmap->green) ||
  1016. get_user(data, &cmap32->blue) ||
  1017. put_user(compat_ptr(data), &cmap->blue) ||
  1018. get_user(data, &cmap32->transp) ||
  1019. put_user(compat_ptr(data), &cmap->transp))
  1020. return -EFAULT;
  1021. err = do_fb_ioctl(info, cmd, (unsigned long) cmap);
  1022. if (!err) {
  1023. if (copy_in_user(&cmap32->start,
  1024. &cmap->start,
  1025. 2 * sizeof(__u32)))
  1026. err = -EFAULT;
  1027. }
  1028. return err;
  1029. }
  1030. static int do_fscreeninfo_to_user(struct fb_fix_screeninfo *fix,
  1031. struct fb_fix_screeninfo32 __user *fix32)
  1032. {
  1033. __u32 data;
  1034. int err;
  1035. err = copy_to_user(&fix32->id, &fix->id, sizeof(fix32->id));
  1036. data = (__u32) (unsigned long) fix->smem_start;
  1037. err |= put_user(data, &fix32->smem_start);
  1038. err |= put_user(fix->smem_len, &fix32->smem_len);
  1039. err |= put_user(fix->type, &fix32->type);
  1040. err |= put_user(fix->type_aux, &fix32->type_aux);
  1041. err |= put_user(fix->visual, &fix32->visual);
  1042. err |= put_user(fix->xpanstep, &fix32->xpanstep);
  1043. err |= put_user(fix->ypanstep, &fix32->ypanstep);
  1044. err |= put_user(fix->ywrapstep, &fix32->ywrapstep);
  1045. err |= put_user(fix->line_length, &fix32->line_length);
  1046. data = (__u32) (unsigned long) fix->mmio_start;
  1047. err |= put_user(data, &fix32->mmio_start);
  1048. err |= put_user(fix->mmio_len, &fix32->mmio_len);
  1049. err |= put_user(fix->accel, &fix32->accel);
  1050. err |= copy_to_user(fix32->reserved, fix->reserved,
  1051. sizeof(fix->reserved));
  1052. return err;
  1053. }
  1054. static int fb_get_fscreeninfo(struct fb_info *info, unsigned int cmd,
  1055. unsigned long arg)
  1056. {
  1057. mm_segment_t old_fs;
  1058. struct fb_fix_screeninfo fix;
  1059. struct fb_fix_screeninfo32 __user *fix32;
  1060. int err;
  1061. fix32 = compat_ptr(arg);
  1062. old_fs = get_fs();
  1063. set_fs(KERNEL_DS);
  1064. err = do_fb_ioctl(info, cmd, (unsigned long) &fix);
  1065. set_fs(old_fs);
  1066. if (!err)
  1067. err = do_fscreeninfo_to_user(&fix, fix32);
  1068. return err;
  1069. }
  1070. static long fb_compat_ioctl(struct file *file, unsigned int cmd,
  1071. unsigned long arg)
  1072. {
  1073. struct inode *inode = file->f_path.dentry->d_inode;
  1074. int fbidx = iminor(inode);
  1075. struct fb_info *info = registered_fb[fbidx];
  1076. struct fb_ops *fb = info->fbops;
  1077. long ret = -ENOIOCTLCMD;
  1078. switch(cmd) {
  1079. case FBIOGET_VSCREENINFO:
  1080. case FBIOPUT_VSCREENINFO:
  1081. case FBIOPAN_DISPLAY:
  1082. case FBIOGET_CON2FBMAP:
  1083. case FBIOPUT_CON2FBMAP:
  1084. arg = (unsigned long) compat_ptr(arg);
  1085. case FBIOBLANK:
  1086. ret = do_fb_ioctl(info, cmd, arg);
  1087. break;
  1088. case FBIOGET_FSCREENINFO:
  1089. ret = fb_get_fscreeninfo(info, cmd, arg);
  1090. break;
  1091. case FBIOGETCMAP:
  1092. case FBIOPUTCMAP:
  1093. ret = fb_getput_cmap(info, cmd, arg);
  1094. break;
  1095. default:
  1096. if (fb->fb_compat_ioctl)
  1097. ret = fb->fb_compat_ioctl(info, cmd, arg);
  1098. break;
  1099. }
  1100. return ret;
  1101. }
  1102. #endif
  1103. static int
  1104. fb_mmap(struct file *file, struct vm_area_struct * vma)
  1105. {
  1106. int fbidx = iminor(file->f_path.dentry->d_inode);
  1107. struct fb_info *info = registered_fb[fbidx];
  1108. struct fb_ops *fb = info->fbops;
  1109. unsigned long off;
  1110. unsigned long start;
  1111. u32 len;
  1112. if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
  1113. return -EINVAL;
  1114. off = vma->vm_pgoff << PAGE_SHIFT;
  1115. if (!fb)
  1116. return -ENODEV;
  1117. mutex_lock(&info->mm_lock);
  1118. if (fb->fb_mmap) {
  1119. int res;
  1120. res = fb->fb_mmap(info, vma);
  1121. mutex_unlock(&info->mm_lock);
  1122. return res;
  1123. }
  1124. /* frame buffer memory */
  1125. start = info->fix.smem_start;
  1126. len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.smem_len);
  1127. if (off >= len) {
  1128. /* memory mapped io */
  1129. off -= len;
  1130. if (info->var.accel_flags) {
  1131. mutex_unlock(&info->mm_lock);
  1132. return -EINVAL;
  1133. }
  1134. start = info->fix.mmio_start;
  1135. len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len);
  1136. }
  1137. mutex_unlock(&info->mm_lock);
  1138. start &= PAGE_MASK;
  1139. if ((vma->vm_end - vma->vm_start + off) > len)
  1140. return -EINVAL;
  1141. off += start;
  1142. vma->vm_pgoff = off >> PAGE_SHIFT;
  1143. /* This is an IO map - tell maydump to skip this VMA */
  1144. vma->vm_flags |= VM_IO | VM_RESERVED;
  1145. fb_pgprotect(file, vma, off);
  1146. if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
  1147. vma->vm_end - vma->vm_start, vma->vm_page_prot))
  1148. return -EAGAIN;
  1149. return 0;
  1150. }
  1151. static int
  1152. fb_open(struct inode *inode, struct file *file)
  1153. __acquires(&info->lock)
  1154. __releases(&info->lock)
  1155. {
  1156. int fbidx = iminor(inode);
  1157. struct fb_info *info;
  1158. int res = 0;
  1159. if (fbidx >= FB_MAX)
  1160. return -ENODEV;
  1161. info = registered_fb[fbidx];
  1162. if (!info)
  1163. request_module("fb%d", fbidx);
  1164. info = registered_fb[fbidx];
  1165. if (!info)
  1166. return -ENODEV;
  1167. mutex_lock(&info->lock);
  1168. if (!try_module_get(info->fbops->owner)) {
  1169. res = -ENODEV;
  1170. goto out;
  1171. }
  1172. file->private_data = info;
  1173. if (info->fbops->fb_open) {
  1174. res = info->fbops->fb_open(info,1);
  1175. if (res)
  1176. module_put(info->fbops->owner);
  1177. }
  1178. #ifdef CONFIG_FB_DEFERRED_IO
  1179. if (info->fbdefio)
  1180. fb_deferred_io_open(info, inode, file);
  1181. #endif
  1182. out:
  1183. mutex_unlock(&info->lock);
  1184. return res;
  1185. }
  1186. static int
  1187. fb_release(struct inode *inode, struct file *file)
  1188. __acquires(&info->lock)
  1189. __releases(&info->lock)
  1190. {
  1191. struct fb_info * const info = file->private_data;
  1192. mutex_lock(&info->lock);
  1193. if (info->fbops->fb_release)
  1194. info->fbops->fb_release(info,1);
  1195. module_put(info->fbops->owner);
  1196. mutex_unlock(&info->lock);
  1197. return 0;
  1198. }
  1199. static const struct file_operations fb_fops = {
  1200. .owner = THIS_MODULE,
  1201. .read = fb_read,
  1202. .write = fb_write,
  1203. .unlocked_ioctl = fb_ioctl,
  1204. #ifdef CONFIG_COMPAT
  1205. .compat_ioctl = fb_compat_ioctl,
  1206. #endif
  1207. .mmap = fb_mmap,
  1208. .open = fb_open,
  1209. .release = fb_release,
  1210. #ifdef HAVE_ARCH_FB_UNMAPPED_AREA
  1211. .get_unmapped_area = get_fb_unmapped_area,
  1212. #endif
  1213. #ifdef CONFIG_FB_DEFERRED_IO
  1214. .fsync = fb_deferred_io_fsync,
  1215. #endif
  1216. };
  1217. struct class *fb_class;
  1218. EXPORT_SYMBOL(fb_class);
  1219. static int fb_check_foreignness(struct fb_info *fi)
  1220. {
  1221. const bool foreign_endian = fi->flags & FBINFO_FOREIGN_ENDIAN;
  1222. fi->flags &= ~FBINFO_FOREIGN_ENDIAN;
  1223. #ifdef __BIG_ENDIAN
  1224. fi->flags |= foreign_endian ? 0 : FBINFO_BE_MATH;
  1225. #else
  1226. fi->flags |= foreign_endian ? FBINFO_BE_MATH : 0;
  1227. #endif /* __BIG_ENDIAN */
  1228. if (fi->flags & FBINFO_BE_MATH && !fb_be_math(fi)) {
  1229. pr_err("%s: enable CONFIG_FB_BIG_ENDIAN to "
  1230. "support this framebuffer\n", fi->fix.id);
  1231. return -ENOSYS;
  1232. } else if (!(fi->flags & FBINFO_BE_MATH) && fb_be_math(fi)) {
  1233. pr_err("%s: enable CONFIG_FB_LITTLE_ENDIAN to "
  1234. "support this framebuffer\n", fi->fix.id);
  1235. return -ENOSYS;
  1236. }
  1237. return 0;
  1238. }
  1239. static bool fb_do_apertures_overlap(struct fb_info *gen, struct fb_info *hw)
  1240. {
  1241. /* is the generic aperture base the same as the HW one */
  1242. if (gen->aperture_base == hw->aperture_base)
  1243. return true;
  1244. /* is the generic aperture base inside the hw base->hw base+size */
  1245. if (gen->aperture_base > hw->aperture_base && gen->aperture_base <= hw->aperture_base + hw->aperture_size)
  1246. return true;
  1247. return false;
  1248. }
  1249. /**
  1250. * register_framebuffer - registers a frame buffer device
  1251. * @fb_info: frame buffer info structure
  1252. *
  1253. * Registers a frame buffer device @fb_info.
  1254. *
  1255. * Returns negative errno on error, or zero for success.
  1256. *
  1257. */
  1258. int
  1259. register_framebuffer(struct fb_info *fb_info)
  1260. {
  1261. int i;
  1262. struct fb_event event;
  1263. struct fb_videomode mode;
  1264. if (num_registered_fb == FB_MAX)
  1265. return -ENXIO;
  1266. if (fb_check_foreignness(fb_info))
  1267. return -ENOSYS;
  1268. /* check all firmware fbs and kick off if the base addr overlaps */
  1269. for (i = 0 ; i < FB_MAX; i++) {
  1270. if (!registered_fb[i])
  1271. continue;
  1272. if (registered_fb[i]->flags & FBINFO_MISC_FIRMWARE) {
  1273. if (fb_do_apertures_overlap(registered_fb[i], fb_info)) {
  1274. printk(KERN_ERR "fb: conflicting fb hw usage "
  1275. "%s vs %s - removing generic driver\n",
  1276. fb_info->fix.id,
  1277. registered_fb[i]->fix.id);
  1278. unregister_framebuffer(registered_fb[i]);
  1279. break;
  1280. }
  1281. }
  1282. }
  1283. num_registered_fb++;
  1284. for (i = 0 ; i < FB_MAX; i++)
  1285. if (!registered_fb[i])
  1286. break;
  1287. fb_info->node = i;
  1288. fb_info->dev = device_create(fb_class, fb_info->device,
  1289. MKDEV(FB_MAJOR, i), NULL, "fb%d", i);
  1290. if (IS_ERR(fb_info->dev)) {
  1291. /* Not fatal */
  1292. printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));
  1293. fb_info->dev = NULL;
  1294. } else
  1295. fb_init_device(fb_info);
  1296. if (fb_info->pixmap.addr == NULL) {
  1297. fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);
  1298. if (fb_info->pixmap.addr) {
  1299. fb_info->pixmap.size = FBPIXMAPSIZE;
  1300. fb_info->pixmap.buf_align = 1;
  1301. fb_info->pixmap.scan_align = 1;
  1302. fb_info->pixmap.access_align = 32;
  1303. fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
  1304. }
  1305. }
  1306. fb_info->pixmap.offset = 0;
  1307. if (!fb_info->pixmap.blit_x)
  1308. fb_info->pixmap.blit_x = ~(u32)0;
  1309. if (!fb_info->pixmap.blit_y)
  1310. fb_info->pixmap.blit_y = ~(u32)0;
  1311. if (!fb_info->modelist.prev || !fb_info->modelist.next)
  1312. INIT_LIST_HEAD(&fb_info->modelist);
  1313. fb_var_to_videomode(&mode, &fb_info->var);
  1314. fb_add_videomode(&mode, &fb_info->modelist);
  1315. registered_fb[i] = fb_info;
  1316. event.info = fb_info;
  1317. if (!lock_fb_info(fb_info))
  1318. return -ENODEV;
  1319. fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);
  1320. unlock_fb_info(fb_info);
  1321. return 0;
  1322. }
  1323. /**
  1324. * unregister_framebuffer - releases a frame buffer device
  1325. * @fb_info: frame buffer info structure
  1326. *
  1327. * Unregisters a frame buffer device @fb_info.
  1328. *
  1329. * Returns negative errno on error, or zero for success.
  1330. *
  1331. * This function will also notify the framebuffer console
  1332. * to release the driver.
  1333. *
  1334. * This is meant to be called within a driver's module_exit()
  1335. * function. If this is called outside module_exit(), ensure
  1336. * that the driver implements fb_open() and fb_release() to
  1337. * check that no processes are using the device.
  1338. */
  1339. int
  1340. unregister_framebuffer(struct fb_info *fb_info)
  1341. {
  1342. struct fb_event event;
  1343. int i, ret = 0;
  1344. i = fb_info->node;
  1345. if (!registered_fb[i]) {
  1346. ret = -EINVAL;
  1347. goto done;
  1348. }
  1349. if (!lock_fb_info(fb_info))
  1350. return -ENODEV;
  1351. event.info = fb_info;
  1352. ret = fb_notifier_call_chain(FB_EVENT_FB_UNBIND, &event);
  1353. unlock_fb_info(fb_info);
  1354. if (ret) {
  1355. ret = -EINVAL;
  1356. goto done;
  1357. }
  1358. if (fb_info->pixmap.addr &&
  1359. (fb_info->pixmap.flags & FB_PIXMAP_DEFAULT))
  1360. kfree(fb_info->pixmap.addr);
  1361. fb_destroy_modelist(&fb_info->modelist);
  1362. registered_fb[i]=NULL;
  1363. num_registered_fb--;
  1364. fb_cleanup_device(fb_info);
  1365. device_destroy(fb_class, MKDEV(FB_MAJOR, i));
  1366. event.info = fb_info;
  1367. fb_notifier_call_chain(FB_EVENT_FB_UNREGISTERED, &event);
  1368. /* this may free fb info */
  1369. if (fb_info->fbops->fb_destroy)
  1370. fb_info->fbops->fb_destroy(fb_info);
  1371. done:
  1372. return ret;
  1373. }
  1374. /**
  1375. * fb_set_suspend - low level driver signals suspend
  1376. * @info: framebuffer affected
  1377. * @state: 0 = resuming, !=0 = suspending
  1378. *
  1379. * This is meant to be used by low level drivers to
  1380. * signal suspend/resume to the core & clients.
  1381. * It must be called with the console semaphore held
  1382. */
  1383. void fb_set_suspend(struct fb_info *info, int state)
  1384. {
  1385. struct fb_event event;
  1386. if (!lock_fb_info(info))
  1387. return;
  1388. event.info = info;
  1389. if (state) {
  1390. fb_notifier_call_chain(FB_EVENT_SUSPEND, &event);
  1391. info->state = FBINFO_STATE_SUSPENDED;
  1392. } else {
  1393. info->state = FBINFO_STATE_RUNNING;
  1394. fb_notifier_call_chain(FB_EVENT_RESUME, &event);
  1395. }
  1396. unlock_fb_info(info);
  1397. }
  1398. /**
  1399. * fbmem_init - init frame buffer subsystem
  1400. *
  1401. * Initialize the frame buffer subsystem.
  1402. *
  1403. * NOTE: This function is _only_ to be called by drivers/char/mem.c.
  1404. *
  1405. */
  1406. static int __init
  1407. fbmem_init(void)
  1408. {
  1409. proc_create("fb", 0, NULL, &fb_proc_fops);
  1410. if (register_chrdev(FB_MAJOR,"fb",&fb_fops))
  1411. printk("unable to get major %d for fb devs\n", FB_MAJOR);
  1412. fb_class = class_create(THIS_MODULE, "graphics");
  1413. if (IS_ERR(fb_class)) {
  1414. printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));
  1415. fb_class = NULL;
  1416. }
  1417. return 0;
  1418. }
  1419. #ifdef MODULE
  1420. module_init(fbmem_init);
  1421. static void __exit
  1422. fbmem_exit(void)
  1423. {
  1424. remove_proc_entry("fb", NULL);
  1425. class_destroy(fb_class);
  1426. unregister_chrdev(FB_MAJOR, "fb");
  1427. }
  1428. module_exit(fbmem_exit);
  1429. MODULE_LICENSE("GPL");
  1430. MODULE_DESCRIPTION("Framebuffer base");
  1431. #else
  1432. subsys_initcall(fbmem_init);
  1433. #endif
  1434. int fb_new_modelist(struct fb_info *info)
  1435. {
  1436. struct fb_event event;
  1437. struct fb_var_screeninfo var = info->var;
  1438. struct list_head *pos, *n;
  1439. struct fb_modelist *modelist;
  1440. struct fb_videomode *m, mode;
  1441. int err = 1;
  1442. list_for_each_safe(pos, n, &info->modelist) {
  1443. modelist = list_entry(pos, struct fb_modelist, list);
  1444. m = &modelist->mode;
  1445. fb_videomode_to_var(&var, m);
  1446. var.activate = FB_ACTIVATE_TEST;
  1447. err = fb_set_var(info, &var);
  1448. fb_var_to_videomode(&mode, &var);
  1449. if (err || !fb_mode_is_equal(m, &mode)) {
  1450. list_del(pos);
  1451. kfree(pos);
  1452. }
  1453. }
  1454. err = 1;
  1455. if (!list_empty(&info->modelist)) {
  1456. if (!lock_fb_info(info))
  1457. return -ENODEV;
  1458. event.info = info;
  1459. err = fb_notifier_call_chain(FB_EVENT_NEW_MODELIST, &event);
  1460. unlock_fb_info(info);
  1461. }
  1462. return err;
  1463. }
  1464. static char *video_options[FB_MAX] __read_mostly;
  1465. static int ofonly __read_mostly;
  1466. /**
  1467. * fb_get_options - get kernel boot parameters
  1468. * @name: framebuffer name as it would appear in
  1469. * the boot parameter line
  1470. * (video=<name>:<options>)
  1471. * @option: the option will be stored here
  1472. *
  1473. * NOTE: Needed to maintain backwards compatibility
  1474. */
  1475. int fb_get_options(char *name, char **option)
  1476. {
  1477. char *opt, *options = NULL;
  1478. int opt_len, retval = 0;
  1479. int name_len = strlen(name), i;
  1480. if (name_len && ofonly && strncmp(name, "offb", 4))
  1481. retval = 1;
  1482. if (name_len && !retval) {
  1483. for (i = 0; i < FB_MAX; i++) {
  1484. if (video_options[i] == NULL)
  1485. continue;
  1486. opt_len = strlen(video_options[i]);
  1487. if (!opt_len)
  1488. continue;
  1489. opt = video_options[i];
  1490. if (!strncmp(name, opt, name_len) &&
  1491. opt[name_len] == ':')
  1492. options = opt + name_len + 1;
  1493. }
  1494. }
  1495. if (options && !strncmp(options, "off", 3))
  1496. retval = 1;
  1497. if (option)
  1498. *option = options;
  1499. return retval;
  1500. }
  1501. #ifndef MODULE
  1502. /**
  1503. * video_setup - process command line options
  1504. * @options: string of options
  1505. *
  1506. * Process command line options for frame buffer subsystem.
  1507. *
  1508. * NOTE: This function is a __setup and __init function.
  1509. * It only stores the options. Drivers have to call
  1510. * fb_get_options() as necessary.
  1511. *
  1512. * Returns zero.
  1513. *
  1514. */
  1515. static int __init video_setup(char *options)
  1516. {
  1517. int i, global = 0;
  1518. if (!options || !*options)
  1519. global = 1;
  1520. if (!global && !strncmp(options, "ofonly", 6)) {
  1521. ofonly = 1;
  1522. global = 1;
  1523. }
  1524. if (!global && !strstr(options, "fb:")) {
  1525. fb_mode_option = options;
  1526. global = 1;
  1527. }
  1528. if (!global) {
  1529. for (i = 0; i < FB_MAX; i++) {
  1530. if (video_options[i] == NULL) {
  1531. video_options[i] = options;
  1532. break;
  1533. }
  1534. }
  1535. }
  1536. return 1;
  1537. }
  1538. __setup("video=", video_setup);
  1539. #endif
  1540. /*
  1541. * Visible symbols for modules
  1542. */
  1543. EXPORT_SYMBOL(register_framebuffer);
  1544. EXPORT_SYMBOL(unregister_framebuffer);
  1545. EXPORT_SYMBOL(num_registered_fb);
  1546. EXPORT_SYMBOL(registered_fb);
  1547. EXPORT_SYMBOL(fb_show_logo);
  1548. EXPORT_SYMBOL(fb_set_var);
  1549. EXPORT_SYMBOL(fb_blank);
  1550. EXPORT_SYMBOL(fb_pan_display);
  1551. EXPORT_SYMBOL(fb_get_buffer_offset);
  1552. EXPORT_SYMBOL(fb_set_suspend);
  1553. EXPORT_SYMBOL(fb_get_options);
  1554. MODULE_LICENSE("GPL");