fsl-diu-fb.c 43 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710
  1. /*
  2. * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
  3. *
  4. * Freescale DIU Frame Buffer device driver
  5. *
  6. * Authors: Hongjun Chen <hong-jun.chen@freescale.com>
  7. * Paul Widmer <paul.widmer@freescale.com>
  8. * Srikanth Srinivasan <srikanth.srinivasan@freescale.com>
  9. * York Sun <yorksun@freescale.com>
  10. *
  11. * Based on imxfb.c Copyright (C) 2004 S.Hauer, Pengutronix
  12. *
  13. * This program is free software; you can redistribute it and/or modify it
  14. * under the terms of the GNU General Public License as published by the
  15. * Free Software Foundation; either version 2 of the License, or (at your
  16. * option) any later version.
  17. *
  18. */
  19. #include <linux/module.h>
  20. #include <linux/kernel.h>
  21. #include <linux/errno.h>
  22. #include <linux/string.h>
  23. #include <linux/slab.h>
  24. #include <linux/fb.h>
  25. #include <linux/init.h>
  26. #include <linux/dma-mapping.h>
  27. #include <linux/platform_device.h>
  28. #include <linux/interrupt.h>
  29. #include <linux/clk.h>
  30. #include <linux/uaccess.h>
  31. #include <linux/vmalloc.h>
  32. #include <linux/of_platform.h>
  33. #include <sysdev/fsl_soc.h>
  34. #include "fsl-diu-fb.h"
  35. /*
  36. * These parameters give default parameters
  37. * for video output 1024x768,
  38. * FIXME - change timing to proper amounts
  39. * hsync 31.5kHz, vsync 60Hz
  40. */
  41. static struct fb_videomode __devinitdata fsl_diu_default_mode = {
  42. .refresh = 60,
  43. .xres = 1024,
  44. .yres = 768,
  45. .pixclock = 15385,
  46. .left_margin = 160,
  47. .right_margin = 24,
  48. .upper_margin = 29,
  49. .lower_margin = 3,
  50. .hsync_len = 136,
  51. .vsync_len = 6,
  52. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  53. .vmode = FB_VMODE_NONINTERLACED
  54. };
  55. static struct fb_videomode __devinitdata fsl_diu_mode_db[] = {
  56. {
  57. .name = "1024x768-60",
  58. .refresh = 60,
  59. .xres = 1024,
  60. .yres = 768,
  61. .pixclock = 15385,
  62. .left_margin = 160,
  63. .right_margin = 24,
  64. .upper_margin = 29,
  65. .lower_margin = 3,
  66. .hsync_len = 136,
  67. .vsync_len = 6,
  68. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  69. .vmode = FB_VMODE_NONINTERLACED
  70. },
  71. {
  72. .name = "1024x768-70",
  73. .refresh = 70,
  74. .xres = 1024,
  75. .yres = 768,
  76. .pixclock = 16886,
  77. .left_margin = 3,
  78. .right_margin = 3,
  79. .upper_margin = 2,
  80. .lower_margin = 2,
  81. .hsync_len = 40,
  82. .vsync_len = 18,
  83. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  84. .vmode = FB_VMODE_NONINTERLACED
  85. },
  86. {
  87. .name = "1024x768-75",
  88. .refresh = 75,
  89. .xres = 1024,
  90. .yres = 768,
  91. .pixclock = 15009,
  92. .left_margin = 3,
  93. .right_margin = 3,
  94. .upper_margin = 2,
  95. .lower_margin = 2,
  96. .hsync_len = 80,
  97. .vsync_len = 32,
  98. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  99. .vmode = FB_VMODE_NONINTERLACED
  100. },
  101. {
  102. .name = "1280x1024-60",
  103. .refresh = 60,
  104. .xres = 1280,
  105. .yres = 1024,
  106. .pixclock = 9375,
  107. .left_margin = 38,
  108. .right_margin = 128,
  109. .upper_margin = 2,
  110. .lower_margin = 7,
  111. .hsync_len = 216,
  112. .vsync_len = 37,
  113. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  114. .vmode = FB_VMODE_NONINTERLACED
  115. },
  116. {
  117. .name = "1280x1024-70",
  118. .refresh = 70,
  119. .xres = 1280,
  120. .yres = 1024,
  121. .pixclock = 9380,
  122. .left_margin = 6,
  123. .right_margin = 6,
  124. .upper_margin = 4,
  125. .lower_margin = 4,
  126. .hsync_len = 60,
  127. .vsync_len = 94,
  128. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  129. .vmode = FB_VMODE_NONINTERLACED
  130. },
  131. {
  132. .name = "1280x1024-75",
  133. .refresh = 75,
  134. .xres = 1280,
  135. .yres = 1024,
  136. .pixclock = 9380,
  137. .left_margin = 6,
  138. .right_margin = 6,
  139. .upper_margin = 4,
  140. .lower_margin = 4,
  141. .hsync_len = 60,
  142. .vsync_len = 15,
  143. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  144. .vmode = FB_VMODE_NONINTERLACED
  145. },
  146. {
  147. .name = "320x240", /* for AOI only */
  148. .refresh = 60,
  149. .xres = 320,
  150. .yres = 240,
  151. .pixclock = 15385,
  152. .left_margin = 0,
  153. .right_margin = 0,
  154. .upper_margin = 0,
  155. .lower_margin = 0,
  156. .hsync_len = 0,
  157. .vsync_len = 0,
  158. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  159. .vmode = FB_VMODE_NONINTERLACED
  160. },
  161. {
  162. .name = "1280x480-60",
  163. .refresh = 60,
  164. .xres = 1280,
  165. .yres = 480,
  166. .pixclock = 18939,
  167. .left_margin = 353,
  168. .right_margin = 47,
  169. .upper_margin = 39,
  170. .lower_margin = 4,
  171. .hsync_len = 8,
  172. .vsync_len = 2,
  173. .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  174. .vmode = FB_VMODE_NONINTERLACED
  175. },
  176. };
  177. static char *fb_mode = "1024x768-32@60";
  178. static unsigned long default_bpp = 32;
  179. static int monitor_port;
  180. #if defined(CONFIG_NOT_COHERENT_CACHE)
  181. static u8 *coherence_data;
  182. static size_t coherence_data_size;
  183. static unsigned int d_cache_line_size;
  184. #endif
  185. static DEFINE_SPINLOCK(diu_lock);
  186. struct fsl_diu_data {
  187. struct fb_info *fsl_diu_info[FSL_AOI_NUM - 1];
  188. /*FSL_AOI_NUM has one dummy AOI */
  189. struct device_attribute dev_attr;
  190. struct diu_ad *dummy_ad;
  191. void *dummy_aoi_virt;
  192. unsigned int irq;
  193. int fb_enabled;
  194. int monitor_port;
  195. };
  196. struct mfb_info {
  197. int index;
  198. int type;
  199. char *id;
  200. int registered;
  201. int blank;
  202. unsigned long pseudo_palette[16];
  203. struct diu_ad *ad;
  204. int cursor_reset;
  205. unsigned char g_alpha;
  206. unsigned int count;
  207. int x_aoi_d; /* aoi display x offset to physical screen */
  208. int y_aoi_d; /* aoi display y offset to physical screen */
  209. struct fsl_diu_data *parent;
  210. };
  211. static struct mfb_info mfb_template[] = {
  212. { /* AOI 0 for plane 0 */
  213. .index = 0,
  214. .type = MFB_TYPE_OUTPUT,
  215. .id = "Panel0",
  216. .registered = 0,
  217. .count = 0,
  218. .x_aoi_d = 0,
  219. .y_aoi_d = 0,
  220. },
  221. { /* AOI 0 for plane 1 */
  222. .index = 1,
  223. .type = MFB_TYPE_OUTPUT,
  224. .id = "Panel1 AOI0",
  225. .registered = 0,
  226. .g_alpha = 0xff,
  227. .count = 0,
  228. .x_aoi_d = 0,
  229. .y_aoi_d = 0,
  230. },
  231. { /* AOI 1 for plane 1 */
  232. .index = 2,
  233. .type = MFB_TYPE_OUTPUT,
  234. .id = "Panel1 AOI1",
  235. .registered = 0,
  236. .g_alpha = 0xff,
  237. .count = 0,
  238. .x_aoi_d = 0,
  239. .y_aoi_d = 480,
  240. },
  241. { /* AOI 0 for plane 2 */
  242. .index = 3,
  243. .type = MFB_TYPE_OUTPUT,
  244. .id = "Panel2 AOI0",
  245. .registered = 0,
  246. .g_alpha = 0xff,
  247. .count = 0,
  248. .x_aoi_d = 640,
  249. .y_aoi_d = 0,
  250. },
  251. { /* AOI 1 for plane 2 */
  252. .index = 4,
  253. .type = MFB_TYPE_OUTPUT,
  254. .id = "Panel2 AOI1",
  255. .registered = 0,
  256. .g_alpha = 0xff,
  257. .count = 0,
  258. .x_aoi_d = 640,
  259. .y_aoi_d = 480,
  260. },
  261. };
  262. static struct diu_hw dr = {
  263. .mode = MFB_MODE1,
  264. .reg_lock = __SPIN_LOCK_UNLOCKED(diu_hw.reg_lock),
  265. };
  266. static struct diu_pool pool;
  267. /**
  268. * fsl_diu_alloc - allocate memory for the DIU
  269. * @size: number of bytes to allocate
  270. * @param: returned physical address of memory
  271. *
  272. * This function allocates a physically-contiguous block of memory.
  273. */
  274. static void *fsl_diu_alloc(size_t size, phys_addr_t *phys)
  275. {
  276. void *virt;
  277. pr_debug("size=%zu\n", size);
  278. virt = alloc_pages_exact(size, GFP_DMA | __GFP_ZERO);
  279. if (virt) {
  280. *phys = virt_to_phys(virt);
  281. pr_debug("virt=%p phys=%llx\n", virt,
  282. (unsigned long long)*phys);
  283. }
  284. return virt;
  285. }
  286. /**
  287. * fsl_diu_free - release DIU memory
  288. * @virt: pointer returned by fsl_diu_alloc()
  289. * @size: number of bytes allocated by fsl_diu_alloc()
  290. *
  291. * This function releases memory allocated by fsl_diu_alloc().
  292. */
  293. static void fsl_diu_free(void *virt, size_t size)
  294. {
  295. pr_debug("virt=%p size=%zu\n", virt, size);
  296. if (virt && size)
  297. free_pages_exact(virt, size);
  298. }
  299. static int fsl_diu_enable_panel(struct fb_info *info)
  300. {
  301. struct mfb_info *pmfbi, *cmfbi, *mfbi = info->par;
  302. struct diu *hw = dr.diu_reg;
  303. struct diu_ad *ad = mfbi->ad;
  304. struct fsl_diu_data *machine_data = mfbi->parent;
  305. int res = 0;
  306. pr_debug("enable_panel index %d\n", mfbi->index);
  307. if (mfbi->type != MFB_TYPE_OFF) {
  308. switch (mfbi->index) {
  309. case 0: /* plane 0 */
  310. if (hw->desc[0] != ad->paddr)
  311. out_be32(&hw->desc[0], ad->paddr);
  312. break;
  313. case 1: /* plane 1 AOI 0 */
  314. cmfbi = machine_data->fsl_diu_info[2]->par;
  315. if (hw->desc[1] != ad->paddr) { /* AOI0 closed */
  316. if (cmfbi->count > 0) /* AOI1 open */
  317. ad->next_ad =
  318. cpu_to_le32(cmfbi->ad->paddr);
  319. else
  320. ad->next_ad = 0;
  321. out_be32(&hw->desc[1], ad->paddr);
  322. }
  323. break;
  324. case 3: /* plane 2 AOI 0 */
  325. cmfbi = machine_data->fsl_diu_info[4]->par;
  326. if (hw->desc[2] != ad->paddr) { /* AOI0 closed */
  327. if (cmfbi->count > 0) /* AOI1 open */
  328. ad->next_ad =
  329. cpu_to_le32(cmfbi->ad->paddr);
  330. else
  331. ad->next_ad = 0;
  332. out_be32(&hw->desc[2], ad->paddr);
  333. }
  334. break;
  335. case 2: /* plane 1 AOI 1 */
  336. pmfbi = machine_data->fsl_diu_info[1]->par;
  337. ad->next_ad = 0;
  338. if (hw->desc[1] == machine_data->dummy_ad->paddr)
  339. out_be32(&hw->desc[1], ad->paddr);
  340. else /* AOI0 open */
  341. pmfbi->ad->next_ad = cpu_to_le32(ad->paddr);
  342. break;
  343. case 4: /* plane 2 AOI 1 */
  344. pmfbi = machine_data->fsl_diu_info[3]->par;
  345. ad->next_ad = 0;
  346. if (hw->desc[2] == machine_data->dummy_ad->paddr)
  347. out_be32(&hw->desc[2], ad->paddr);
  348. else /* AOI0 was open */
  349. pmfbi->ad->next_ad = cpu_to_le32(ad->paddr);
  350. break;
  351. default:
  352. res = -EINVAL;
  353. break;
  354. }
  355. } else
  356. res = -EINVAL;
  357. return res;
  358. }
  359. static int fsl_diu_disable_panel(struct fb_info *info)
  360. {
  361. struct mfb_info *pmfbi, *cmfbi, *mfbi = info->par;
  362. struct diu *hw = dr.diu_reg;
  363. struct diu_ad *ad = mfbi->ad;
  364. struct fsl_diu_data *machine_data = mfbi->parent;
  365. int res = 0;
  366. switch (mfbi->index) {
  367. case 0: /* plane 0 */
  368. if (hw->desc[0] != machine_data->dummy_ad->paddr)
  369. out_be32(&hw->desc[0],
  370. machine_data->dummy_ad->paddr);
  371. break;
  372. case 1: /* plane 1 AOI 0 */
  373. cmfbi = machine_data->fsl_diu_info[2]->par;
  374. if (cmfbi->count > 0) /* AOI1 is open */
  375. out_be32(&hw->desc[1], cmfbi->ad->paddr);
  376. /* move AOI1 to the first */
  377. else /* AOI1 was closed */
  378. out_be32(&hw->desc[1],
  379. machine_data->dummy_ad->paddr);
  380. /* close AOI 0 */
  381. break;
  382. case 3: /* plane 2 AOI 0 */
  383. cmfbi = machine_data->fsl_diu_info[4]->par;
  384. if (cmfbi->count > 0) /* AOI1 is open */
  385. out_be32(&hw->desc[2], cmfbi->ad->paddr);
  386. /* move AOI1 to the first */
  387. else /* AOI1 was closed */
  388. out_be32(&hw->desc[2],
  389. machine_data->dummy_ad->paddr);
  390. /* close AOI 0 */
  391. break;
  392. case 2: /* plane 1 AOI 1 */
  393. pmfbi = machine_data->fsl_diu_info[1]->par;
  394. if (hw->desc[1] != ad->paddr) {
  395. /* AOI1 is not the first in the chain */
  396. if (pmfbi->count > 0)
  397. /* AOI0 is open, must be the first */
  398. pmfbi->ad->next_ad = 0;
  399. } else /* AOI1 is the first in the chain */
  400. out_be32(&hw->desc[1], machine_data->dummy_ad->paddr);
  401. /* close AOI 1 */
  402. break;
  403. case 4: /* plane 2 AOI 1 */
  404. pmfbi = machine_data->fsl_diu_info[3]->par;
  405. if (hw->desc[2] != ad->paddr) {
  406. /* AOI1 is not the first in the chain */
  407. if (pmfbi->count > 0)
  408. /* AOI0 is open, must be the first */
  409. pmfbi->ad->next_ad = 0;
  410. } else /* AOI1 is the first in the chain */
  411. out_be32(&hw->desc[2], machine_data->dummy_ad->paddr);
  412. /* close AOI 1 */
  413. break;
  414. default:
  415. res = -EINVAL;
  416. break;
  417. }
  418. return res;
  419. }
  420. static void enable_lcdc(struct fb_info *info)
  421. {
  422. struct diu *hw = dr.diu_reg;
  423. struct mfb_info *mfbi = info->par;
  424. struct fsl_diu_data *machine_data = mfbi->parent;
  425. if (!machine_data->fb_enabled) {
  426. out_be32(&hw->diu_mode, dr.mode);
  427. machine_data->fb_enabled++;
  428. }
  429. }
  430. static void disable_lcdc(struct fb_info *info)
  431. {
  432. struct diu *hw = dr.diu_reg;
  433. struct mfb_info *mfbi = info->par;
  434. struct fsl_diu_data *machine_data = mfbi->parent;
  435. if (machine_data->fb_enabled) {
  436. out_be32(&hw->diu_mode, 0);
  437. machine_data->fb_enabled = 0;
  438. }
  439. }
  440. static void adjust_aoi_size_position(struct fb_var_screeninfo *var,
  441. struct fb_info *info)
  442. {
  443. struct mfb_info *lower_aoi_mfbi, *upper_aoi_mfbi, *mfbi = info->par;
  444. struct fsl_diu_data *machine_data = mfbi->parent;
  445. int available_height, upper_aoi_bottom, index = mfbi->index;
  446. int lower_aoi_is_open, upper_aoi_is_open;
  447. __u32 base_plane_width, base_plane_height, upper_aoi_height;
  448. base_plane_width = machine_data->fsl_diu_info[0]->var.xres;
  449. base_plane_height = machine_data->fsl_diu_info[0]->var.yres;
  450. switch (index) {
  451. case 0:
  452. if (mfbi->x_aoi_d != 0)
  453. mfbi->x_aoi_d = 0;
  454. if (mfbi->y_aoi_d != 0)
  455. mfbi->y_aoi_d = 0;
  456. break;
  457. case 1: /* AOI 0 */
  458. case 3:
  459. lower_aoi_mfbi = machine_data->fsl_diu_info[index+1]->par;
  460. lower_aoi_is_open = lower_aoi_mfbi->count > 0 ? 1 : 0;
  461. if (var->xres > base_plane_width)
  462. var->xres = base_plane_width;
  463. if ((mfbi->x_aoi_d + var->xres) > base_plane_width)
  464. mfbi->x_aoi_d = base_plane_width - var->xres;
  465. if (lower_aoi_is_open)
  466. available_height = lower_aoi_mfbi->y_aoi_d;
  467. else
  468. available_height = base_plane_height;
  469. if (var->yres > available_height)
  470. var->yres = available_height;
  471. if ((mfbi->y_aoi_d + var->yres) > available_height)
  472. mfbi->y_aoi_d = available_height - var->yres;
  473. break;
  474. case 2: /* AOI 1 */
  475. case 4:
  476. upper_aoi_mfbi = machine_data->fsl_diu_info[index-1]->par;
  477. upper_aoi_height =
  478. machine_data->fsl_diu_info[index-1]->var.yres;
  479. upper_aoi_bottom = upper_aoi_mfbi->y_aoi_d + upper_aoi_height;
  480. upper_aoi_is_open = upper_aoi_mfbi->count > 0 ? 1 : 0;
  481. if (var->xres > base_plane_width)
  482. var->xres = base_plane_width;
  483. if ((mfbi->x_aoi_d + var->xres) > base_plane_width)
  484. mfbi->x_aoi_d = base_plane_width - var->xres;
  485. if (mfbi->y_aoi_d < 0)
  486. mfbi->y_aoi_d = 0;
  487. if (upper_aoi_is_open) {
  488. if (mfbi->y_aoi_d < upper_aoi_bottom)
  489. mfbi->y_aoi_d = upper_aoi_bottom;
  490. available_height = base_plane_height
  491. - upper_aoi_bottom;
  492. } else
  493. available_height = base_plane_height;
  494. if (var->yres > available_height)
  495. var->yres = available_height;
  496. if ((mfbi->y_aoi_d + var->yres) > base_plane_height)
  497. mfbi->y_aoi_d = base_plane_height - var->yres;
  498. break;
  499. }
  500. }
  501. /*
  502. * Checks to see if the hardware supports the state requested by var passed
  503. * in. This function does not alter the hardware state! If the var passed in
  504. * is slightly off by what the hardware can support then we alter the var
  505. * PASSED in to what we can do. If the hardware doesn't support mode change
  506. * a -EINVAL will be returned by the upper layers.
  507. */
  508. static int fsl_diu_check_var(struct fb_var_screeninfo *var,
  509. struct fb_info *info)
  510. {
  511. unsigned long htotal, vtotal;
  512. pr_debug("check_var xres: %d\n", var->xres);
  513. pr_debug("check_var yres: %d\n", var->yres);
  514. if (var->xres_virtual < var->xres)
  515. var->xres_virtual = var->xres;
  516. if (var->yres_virtual < var->yres)
  517. var->yres_virtual = var->yres;
  518. if (var->xoffset < 0)
  519. var->xoffset = 0;
  520. if (var->yoffset < 0)
  521. var->yoffset = 0;
  522. if (var->xoffset + info->var.xres > info->var.xres_virtual)
  523. var->xoffset = info->var.xres_virtual - info->var.xres;
  524. if (var->yoffset + info->var.yres > info->var.yres_virtual)
  525. var->yoffset = info->var.yres_virtual - info->var.yres;
  526. if ((var->bits_per_pixel != 32) && (var->bits_per_pixel != 24) &&
  527. (var->bits_per_pixel != 16))
  528. var->bits_per_pixel = default_bpp;
  529. switch (var->bits_per_pixel) {
  530. case 16:
  531. var->red.length = 5;
  532. var->red.offset = 11;
  533. var->red.msb_right = 0;
  534. var->green.length = 6;
  535. var->green.offset = 5;
  536. var->green.msb_right = 0;
  537. var->blue.length = 5;
  538. var->blue.offset = 0;
  539. var->blue.msb_right = 0;
  540. var->transp.length = 0;
  541. var->transp.offset = 0;
  542. var->transp.msb_right = 0;
  543. break;
  544. case 24:
  545. var->red.length = 8;
  546. var->red.offset = 0;
  547. var->red.msb_right = 0;
  548. var->green.length = 8;
  549. var->green.offset = 8;
  550. var->green.msb_right = 0;
  551. var->blue.length = 8;
  552. var->blue.offset = 16;
  553. var->blue.msb_right = 0;
  554. var->transp.length = 0;
  555. var->transp.offset = 0;
  556. var->transp.msb_right = 0;
  557. break;
  558. case 32:
  559. var->red.length = 8;
  560. var->red.offset = 16;
  561. var->red.msb_right = 0;
  562. var->green.length = 8;
  563. var->green.offset = 8;
  564. var->green.msb_right = 0;
  565. var->blue.length = 8;
  566. var->blue.offset = 0;
  567. var->blue.msb_right = 0;
  568. var->transp.length = 8;
  569. var->transp.offset = 24;
  570. var->transp.msb_right = 0;
  571. break;
  572. }
  573. /* If the pixclock is below the minimum spec'd value then set to
  574. * refresh rate for 60Hz since this is supported by most monitors.
  575. * Refer to Documentation/fb/ for calculations.
  576. */
  577. if ((var->pixclock < MIN_PIX_CLK) || (var->pixclock > MAX_PIX_CLK)) {
  578. htotal = var->xres + var->right_margin + var->hsync_len +
  579. var->left_margin;
  580. vtotal = var->yres + var->lower_margin + var->vsync_len +
  581. var->upper_margin;
  582. var->pixclock = (vtotal * htotal * 6UL) / 100UL;
  583. var->pixclock = KHZ2PICOS(var->pixclock);
  584. pr_debug("pixclock set for 60Hz refresh = %u ps\n",
  585. var->pixclock);
  586. }
  587. var->height = -1;
  588. var->width = -1;
  589. var->grayscale = 0;
  590. /* Copy nonstd field to/from sync for fbset usage */
  591. var->sync |= var->nonstd;
  592. var->nonstd |= var->sync;
  593. adjust_aoi_size_position(var, info);
  594. return 0;
  595. }
  596. static void set_fix(struct fb_info *info)
  597. {
  598. struct fb_fix_screeninfo *fix = &info->fix;
  599. struct fb_var_screeninfo *var = &info->var;
  600. struct mfb_info *mfbi = info->par;
  601. strncpy(fix->id, mfbi->id, strlen(mfbi->id));
  602. fix->line_length = var->xres_virtual * var->bits_per_pixel / 8;
  603. fix->type = FB_TYPE_PACKED_PIXELS;
  604. fix->accel = FB_ACCEL_NONE;
  605. fix->visual = FB_VISUAL_TRUECOLOR;
  606. fix->xpanstep = 1;
  607. fix->ypanstep = 1;
  608. }
  609. static void update_lcdc(struct fb_info *info)
  610. {
  611. struct fb_var_screeninfo *var = &info->var;
  612. struct mfb_info *mfbi = info->par;
  613. struct fsl_diu_data *machine_data = mfbi->parent;
  614. struct diu *hw;
  615. int i, j;
  616. char __iomem *cursor_base, *gamma_table_base;
  617. u32 temp;
  618. hw = dr.diu_reg;
  619. if (mfbi->type == MFB_TYPE_OFF) {
  620. fsl_diu_disable_panel(info);
  621. return;
  622. }
  623. diu_ops.set_monitor_port(machine_data->monitor_port);
  624. gamma_table_base = pool.gamma.vaddr;
  625. cursor_base = pool.cursor.vaddr;
  626. /* Prep for DIU init - gamma table, cursor table */
  627. for (i = 0; i <= 2; i++)
  628. for (j = 0; j <= 255; j++)
  629. *gamma_table_base++ = j;
  630. diu_ops.set_gamma_table(machine_data->monitor_port, pool.gamma.vaddr);
  631. pr_debug("update-lcdc: HW - %p\n Disabling DIU\n", hw);
  632. disable_lcdc(info);
  633. /* Program DIU registers */
  634. out_be32(&hw->gamma, pool.gamma.paddr);
  635. out_be32(&hw->cursor, pool.cursor.paddr);
  636. out_be32(&hw->bgnd, 0x007F7F7F); /* BGND */
  637. out_be32(&hw->bgnd_wb, 0); /* BGND_WB */
  638. out_be32(&hw->disp_size, (var->yres << 16 | var->xres));
  639. /* DISP SIZE */
  640. pr_debug("DIU xres: %d\n", var->xres);
  641. pr_debug("DIU yres: %d\n", var->yres);
  642. out_be32(&hw->wb_size, 0); /* WB SIZE */
  643. out_be32(&hw->wb_mem_addr, 0); /* WB MEM ADDR */
  644. /* Horizontal and vertical configuration register */
  645. temp = var->left_margin << 22 | /* BP_H */
  646. var->hsync_len << 11 | /* PW_H */
  647. var->right_margin; /* FP_H */
  648. out_be32(&hw->hsyn_para, temp);
  649. temp = var->upper_margin << 22 | /* BP_V */
  650. var->vsync_len << 11 | /* PW_V */
  651. var->lower_margin; /* FP_V */
  652. out_be32(&hw->vsyn_para, temp);
  653. pr_debug("DIU right_margin - %d\n", var->right_margin);
  654. pr_debug("DIU left_margin - %d\n", var->left_margin);
  655. pr_debug("DIU hsync_len - %d\n", var->hsync_len);
  656. pr_debug("DIU upper_margin - %d\n", var->upper_margin);
  657. pr_debug("DIU lower_margin - %d\n", var->lower_margin);
  658. pr_debug("DIU vsync_len - %d\n", var->vsync_len);
  659. pr_debug("DIU HSYNC - 0x%08x\n", hw->hsyn_para);
  660. pr_debug("DIU VSYNC - 0x%08x\n", hw->vsyn_para);
  661. diu_ops.set_pixel_clock(var->pixclock);
  662. out_be32(&hw->syn_pol, 0); /* SYNC SIGNALS POLARITY */
  663. out_be32(&hw->thresholds, 0x00037800); /* The Thresholds */
  664. out_be32(&hw->int_status, 0); /* INTERRUPT STATUS */
  665. out_be32(&hw->plut, 0x01F5F666);
  666. /* Enable the DIU */
  667. enable_lcdc(info);
  668. }
  669. static int map_video_memory(struct fb_info *info)
  670. {
  671. phys_addr_t phys;
  672. pr_debug("info->var.xres_virtual = %d\n", info->var.xres_virtual);
  673. pr_debug("info->var.yres_virtual = %d\n", info->var.yres_virtual);
  674. pr_debug("info->fix.line_length = %d\n", info->fix.line_length);
  675. info->fix.smem_len = info->fix.line_length * info->var.yres_virtual;
  676. pr_debug("MAP_VIDEO_MEMORY: smem_len = %d\n", info->fix.smem_len);
  677. info->screen_base = fsl_diu_alloc(info->fix.smem_len, &phys);
  678. if (info->screen_base == NULL) {
  679. printk(KERN_ERR "Unable to allocate fb memory\n");
  680. return -ENOMEM;
  681. }
  682. info->fix.smem_start = (unsigned long) phys;
  683. info->screen_size = info->fix.smem_len;
  684. pr_debug("Allocated fb @ paddr=0x%08lx, size=%d.\n",
  685. info->fix.smem_start,
  686. info->fix.smem_len);
  687. pr_debug("screen base %p\n", info->screen_base);
  688. return 0;
  689. }
  690. static void unmap_video_memory(struct fb_info *info)
  691. {
  692. fsl_diu_free(info->screen_base, info->fix.smem_len);
  693. info->screen_base = NULL;
  694. info->fix.smem_start = 0;
  695. info->fix.smem_len = 0;
  696. }
  697. /*
  698. * Using the fb_var_screeninfo in fb_info we set the resolution of this
  699. * particular framebuffer. This function alters the fb_fix_screeninfo stored
  700. * in fb_info. It does not alter var in fb_info since we are using that
  701. * data. This means we depend on the data in var inside fb_info to be
  702. * supported by the hardware. fsl_diu_check_var is always called before
  703. * fsl_diu_set_par to ensure this.
  704. */
  705. static int fsl_diu_set_par(struct fb_info *info)
  706. {
  707. unsigned long len;
  708. struct fb_var_screeninfo *var = &info->var;
  709. struct mfb_info *mfbi = info->par;
  710. struct fsl_diu_data *machine_data = mfbi->parent;
  711. struct diu_ad *ad = mfbi->ad;
  712. struct diu *hw;
  713. hw = dr.diu_reg;
  714. set_fix(info);
  715. mfbi->cursor_reset = 1;
  716. len = info->var.yres_virtual * info->fix.line_length;
  717. /* Alloc & dealloc each time resolution/bpp change */
  718. if (len != info->fix.smem_len) {
  719. if (info->fix.smem_start)
  720. unmap_video_memory(info);
  721. pr_debug("SET PAR: smem_len = %d\n", info->fix.smem_len);
  722. /* Memory allocation for framebuffer */
  723. if (map_video_memory(info)) {
  724. printk(KERN_ERR "Unable to allocate fb memory 1\n");
  725. return -ENOMEM;
  726. }
  727. }
  728. ad->pix_fmt =
  729. diu_ops.get_pixel_format(var->bits_per_pixel,
  730. machine_data->monitor_port);
  731. ad->addr = cpu_to_le32(info->fix.smem_start);
  732. ad->src_size_g_alpha = cpu_to_le32((var->yres << 12) |
  733. var->xres) | mfbi->g_alpha;
  734. /* fix me. AOI should not be greater than display size */
  735. ad->aoi_size = cpu_to_le32((var->yres << 16) | var->xres);
  736. ad->offset_xyi = 0;
  737. ad->offset_xyd = cpu_to_le32((mfbi->y_aoi_d << 16) | mfbi->x_aoi_d);
  738. /* Disable chroma keying function */
  739. ad->ckmax_r = 0;
  740. ad->ckmax_g = 0;
  741. ad->ckmax_b = 0;
  742. ad->ckmin_r = 255;
  743. ad->ckmin_g = 255;
  744. ad->ckmin_b = 255;
  745. if (mfbi->index == 0)
  746. update_lcdc(info);
  747. return 0;
  748. }
  749. static inline __u32 CNVT_TOHW(__u32 val, __u32 width)
  750. {
  751. return ((val<<width) + 0x7FFF - val)>>16;
  752. }
  753. /*
  754. * Set a single color register. The values supplied have a 16 bit magnitude
  755. * which needs to be scaled in this function for the hardware. Things to take
  756. * into consideration are how many color registers, if any, are supported with
  757. * the current color visual. With truecolor mode no color palettes are
  758. * supported. Here a psuedo palette is created which we store the value in
  759. * pseudo_palette in struct fb_info. For pseudocolor mode we have a limited
  760. * color palette.
  761. */
  762. static int fsl_diu_setcolreg(unsigned regno, unsigned red, unsigned green,
  763. unsigned blue, unsigned transp, struct fb_info *info)
  764. {
  765. int ret = 1;
  766. /*
  767. * If greyscale is true, then we convert the RGB value
  768. * to greyscale no matter what visual we are using.
  769. */
  770. if (info->var.grayscale)
  771. red = green = blue = (19595 * red + 38470 * green +
  772. 7471 * blue) >> 16;
  773. switch (info->fix.visual) {
  774. case FB_VISUAL_TRUECOLOR:
  775. /*
  776. * 16-bit True Colour. We encode the RGB value
  777. * according to the RGB bitfield information.
  778. */
  779. if (regno < 16) {
  780. u32 *pal = info->pseudo_palette;
  781. u32 v;
  782. red = CNVT_TOHW(red, info->var.red.length);
  783. green = CNVT_TOHW(green, info->var.green.length);
  784. blue = CNVT_TOHW(blue, info->var.blue.length);
  785. transp = CNVT_TOHW(transp, info->var.transp.length);
  786. v = (red << info->var.red.offset) |
  787. (green << info->var.green.offset) |
  788. (blue << info->var.blue.offset) |
  789. (transp << info->var.transp.offset);
  790. pal[regno] = v;
  791. ret = 0;
  792. }
  793. break;
  794. case FB_VISUAL_STATIC_PSEUDOCOLOR:
  795. case FB_VISUAL_PSEUDOCOLOR:
  796. break;
  797. }
  798. return ret;
  799. }
  800. /*
  801. * Pan (or wrap, depending on the `vmode' field) the display using the
  802. * 'xoffset' and 'yoffset' fields of the 'var' structure. If the values
  803. * don't fit, return -EINVAL.
  804. */
  805. static int fsl_diu_pan_display(struct fb_var_screeninfo *var,
  806. struct fb_info *info)
  807. {
  808. if ((info->var.xoffset == var->xoffset) &&
  809. (info->var.yoffset == var->yoffset))
  810. return 0; /* No change, do nothing */
  811. if (var->xoffset < 0 || var->yoffset < 0
  812. || var->xoffset + info->var.xres > info->var.xres_virtual
  813. || var->yoffset + info->var.yres > info->var.yres_virtual)
  814. return -EINVAL;
  815. info->var.xoffset = var->xoffset;
  816. info->var.yoffset = var->yoffset;
  817. if (var->vmode & FB_VMODE_YWRAP)
  818. info->var.vmode |= FB_VMODE_YWRAP;
  819. else
  820. info->var.vmode &= ~FB_VMODE_YWRAP;
  821. return 0;
  822. }
  823. /*
  824. * Blank the screen if blank_mode != 0, else unblank. Return 0 if blanking
  825. * succeeded, != 0 if un-/blanking failed.
  826. * blank_mode == 2: suspend vsync
  827. * blank_mode == 3: suspend hsync
  828. * blank_mode == 4: powerdown
  829. */
  830. static int fsl_diu_blank(int blank_mode, struct fb_info *info)
  831. {
  832. struct mfb_info *mfbi = info->par;
  833. mfbi->blank = blank_mode;
  834. switch (blank_mode) {
  835. case FB_BLANK_VSYNC_SUSPEND:
  836. case FB_BLANK_HSYNC_SUSPEND:
  837. /* FIXME: fixes to enable_panel and enable lcdc needed */
  838. case FB_BLANK_NORMAL:
  839. /* fsl_diu_disable_panel(info);*/
  840. break;
  841. case FB_BLANK_POWERDOWN:
  842. /* disable_lcdc(info); */
  843. break;
  844. case FB_BLANK_UNBLANK:
  845. /* fsl_diu_enable_panel(info);*/
  846. break;
  847. }
  848. return 0;
  849. }
  850. static int fsl_diu_ioctl(struct fb_info *info, unsigned int cmd,
  851. unsigned long arg)
  852. {
  853. struct mfb_info *mfbi = info->par;
  854. struct diu_ad *ad = mfbi->ad;
  855. struct mfb_chroma_key ck;
  856. unsigned char global_alpha;
  857. struct aoi_display_offset aoi_d;
  858. __u32 pix_fmt;
  859. void __user *buf = (void __user *)arg;
  860. if (!arg)
  861. return -EINVAL;
  862. switch (cmd) {
  863. case MFB_SET_PIXFMT:
  864. if (copy_from_user(&pix_fmt, buf, sizeof(pix_fmt)))
  865. return -EFAULT;
  866. ad->pix_fmt = pix_fmt;
  867. pr_debug("Set pixel format to 0x%08x\n", ad->pix_fmt);
  868. break;
  869. case MFB_GET_PIXFMT:
  870. pix_fmt = ad->pix_fmt;
  871. if (copy_to_user(buf, &pix_fmt, sizeof(pix_fmt)))
  872. return -EFAULT;
  873. pr_debug("get pixel format 0x%08x\n", ad->pix_fmt);
  874. break;
  875. case MFB_SET_AOID:
  876. if (copy_from_user(&aoi_d, buf, sizeof(aoi_d)))
  877. return -EFAULT;
  878. mfbi->x_aoi_d = aoi_d.x_aoi_d;
  879. mfbi->y_aoi_d = aoi_d.y_aoi_d;
  880. pr_debug("set AOI display offset of index %d to (%d,%d)\n",
  881. mfbi->index, aoi_d.x_aoi_d, aoi_d.y_aoi_d);
  882. fsl_diu_check_var(&info->var, info);
  883. fsl_diu_set_par(info);
  884. break;
  885. case MFB_GET_AOID:
  886. aoi_d.x_aoi_d = mfbi->x_aoi_d;
  887. aoi_d.y_aoi_d = mfbi->y_aoi_d;
  888. if (copy_to_user(buf, &aoi_d, sizeof(aoi_d)))
  889. return -EFAULT;
  890. pr_debug("get AOI display offset of index %d (%d,%d)\n",
  891. mfbi->index, aoi_d.x_aoi_d, aoi_d.y_aoi_d);
  892. break;
  893. case MFB_GET_ALPHA:
  894. global_alpha = mfbi->g_alpha;
  895. if (copy_to_user(buf, &global_alpha, sizeof(global_alpha)))
  896. return -EFAULT;
  897. pr_debug("get global alpha of index %d\n", mfbi->index);
  898. break;
  899. case MFB_SET_ALPHA:
  900. /* set panel information */
  901. if (copy_from_user(&global_alpha, buf, sizeof(global_alpha)))
  902. return -EFAULT;
  903. ad->src_size_g_alpha = (ad->src_size_g_alpha & (~0xff)) |
  904. (global_alpha & 0xff);
  905. mfbi->g_alpha = global_alpha;
  906. pr_debug("set global alpha for index %d\n", mfbi->index);
  907. break;
  908. case MFB_SET_CHROMA_KEY:
  909. /* set panel winformation */
  910. if (copy_from_user(&ck, buf, sizeof(ck)))
  911. return -EFAULT;
  912. if (ck.enable &&
  913. (ck.red_max < ck.red_min ||
  914. ck.green_max < ck.green_min ||
  915. ck.blue_max < ck.blue_min))
  916. return -EINVAL;
  917. if (!ck.enable) {
  918. ad->ckmax_r = 0;
  919. ad->ckmax_g = 0;
  920. ad->ckmax_b = 0;
  921. ad->ckmin_r = 255;
  922. ad->ckmin_g = 255;
  923. ad->ckmin_b = 255;
  924. } else {
  925. ad->ckmax_r = ck.red_max;
  926. ad->ckmax_g = ck.green_max;
  927. ad->ckmax_b = ck.blue_max;
  928. ad->ckmin_r = ck.red_min;
  929. ad->ckmin_g = ck.green_min;
  930. ad->ckmin_b = ck.blue_min;
  931. }
  932. pr_debug("set chroma key\n");
  933. break;
  934. case FBIOGET_GWINFO:
  935. if (mfbi->type == MFB_TYPE_OFF)
  936. return -ENODEV;
  937. /* get graphic window information */
  938. if (copy_to_user(buf, ad, sizeof(*ad)))
  939. return -EFAULT;
  940. break;
  941. case FBIOGET_HWCINFO:
  942. pr_debug("FBIOGET_HWCINFO:0x%08x\n", FBIOGET_HWCINFO);
  943. break;
  944. case FBIOPUT_MODEINFO:
  945. pr_debug("FBIOPUT_MODEINFO:0x%08x\n", FBIOPUT_MODEINFO);
  946. break;
  947. case FBIOGET_DISPINFO:
  948. pr_debug("FBIOGET_DISPINFO:0x%08x\n", FBIOGET_DISPINFO);
  949. break;
  950. default:
  951. printk(KERN_ERR "Unknown ioctl command (0x%08X)\n", cmd);
  952. return -ENOIOCTLCMD;
  953. }
  954. return 0;
  955. }
  956. /* turn on fb if count == 1
  957. */
  958. static int fsl_diu_open(struct fb_info *info, int user)
  959. {
  960. struct mfb_info *mfbi = info->par;
  961. int res = 0;
  962. spin_lock(&diu_lock);
  963. mfbi->count++;
  964. if (mfbi->count == 1) {
  965. pr_debug("open plane index %d\n", mfbi->index);
  966. fsl_diu_check_var(&info->var, info);
  967. res = fsl_diu_set_par(info);
  968. if (res < 0)
  969. mfbi->count--;
  970. else {
  971. res = fsl_diu_enable_panel(info);
  972. if (res < 0)
  973. mfbi->count--;
  974. }
  975. }
  976. spin_unlock(&diu_lock);
  977. return res;
  978. }
  979. /* turn off fb if count == 0
  980. */
  981. static int fsl_diu_release(struct fb_info *info, int user)
  982. {
  983. struct mfb_info *mfbi = info->par;
  984. int res = 0;
  985. spin_lock(&diu_lock);
  986. mfbi->count--;
  987. if (mfbi->count == 0) {
  988. pr_debug("release plane index %d\n", mfbi->index);
  989. res = fsl_diu_disable_panel(info);
  990. if (res < 0)
  991. mfbi->count++;
  992. }
  993. spin_unlock(&diu_lock);
  994. return res;
  995. }
  996. static struct fb_ops fsl_diu_ops = {
  997. .owner = THIS_MODULE,
  998. .fb_check_var = fsl_diu_check_var,
  999. .fb_set_par = fsl_diu_set_par,
  1000. .fb_setcolreg = fsl_diu_setcolreg,
  1001. .fb_blank = fsl_diu_blank,
  1002. .fb_pan_display = fsl_diu_pan_display,
  1003. .fb_fillrect = cfb_fillrect,
  1004. .fb_copyarea = cfb_copyarea,
  1005. .fb_imageblit = cfb_imageblit,
  1006. .fb_ioctl = fsl_diu_ioctl,
  1007. .fb_open = fsl_diu_open,
  1008. .fb_release = fsl_diu_release,
  1009. };
  1010. static int init_fbinfo(struct fb_info *info)
  1011. {
  1012. struct mfb_info *mfbi = info->par;
  1013. info->device = NULL;
  1014. info->var.activate = FB_ACTIVATE_NOW;
  1015. info->fbops = &fsl_diu_ops;
  1016. info->flags = FBINFO_FLAG_DEFAULT;
  1017. info->pseudo_palette = &mfbi->pseudo_palette;
  1018. /* Allocate colormap */
  1019. fb_alloc_cmap(&info->cmap, 16, 0);
  1020. return 0;
  1021. }
  1022. static int __devinit install_fb(struct fb_info *info)
  1023. {
  1024. int rc;
  1025. struct mfb_info *mfbi = info->par;
  1026. const char *aoi_mode, *init_aoi_mode = "320x240";
  1027. if (init_fbinfo(info))
  1028. return -EINVAL;
  1029. if (mfbi->index == 0) /* plane 0 */
  1030. aoi_mode = fb_mode;
  1031. else
  1032. aoi_mode = init_aoi_mode;
  1033. pr_debug("mode used = %s\n", aoi_mode);
  1034. rc = fb_find_mode(&info->var, info, aoi_mode, fsl_diu_mode_db,
  1035. ARRAY_SIZE(fsl_diu_mode_db), &fsl_diu_default_mode, default_bpp);
  1036. switch (rc) {
  1037. case 1:
  1038. pr_debug("using mode specified in @mode\n");
  1039. break;
  1040. case 2:
  1041. pr_debug("using mode specified in @mode "
  1042. "with ignored refresh rate\n");
  1043. break;
  1044. case 3:
  1045. pr_debug("using mode default mode\n");
  1046. break;
  1047. case 4:
  1048. pr_debug("using mode from list\n");
  1049. break;
  1050. default:
  1051. pr_debug("rc = %d\n", rc);
  1052. pr_debug("failed to find mode\n");
  1053. return -EINVAL;
  1054. break;
  1055. }
  1056. pr_debug("xres_virtual %d\n", info->var.xres_virtual);
  1057. pr_debug("bits_per_pixel %d\n", info->var.bits_per_pixel);
  1058. pr_debug("info->var.yres_virtual = %d\n", info->var.yres_virtual);
  1059. pr_debug("info->fix.line_length = %d\n", info->fix.line_length);
  1060. if (mfbi->type == MFB_TYPE_OFF)
  1061. mfbi->blank = FB_BLANK_NORMAL;
  1062. else
  1063. mfbi->blank = FB_BLANK_UNBLANK;
  1064. if (fsl_diu_check_var(&info->var, info)) {
  1065. printk(KERN_ERR "fb_check_var failed");
  1066. fb_dealloc_cmap(&info->cmap);
  1067. return -EINVAL;
  1068. }
  1069. if (fsl_diu_set_par(info)) {
  1070. printk(KERN_ERR "fb_set_par failed");
  1071. fb_dealloc_cmap(&info->cmap);
  1072. return -EINVAL;
  1073. }
  1074. if (register_framebuffer(info) < 0) {
  1075. printk(KERN_ERR "register_framebuffer failed");
  1076. unmap_video_memory(info);
  1077. fb_dealloc_cmap(&info->cmap);
  1078. return -EINVAL;
  1079. }
  1080. mfbi->registered = 1;
  1081. printk(KERN_INFO "fb%d: %s fb device registered successfully.\n",
  1082. info->node, info->fix.id);
  1083. return 0;
  1084. }
  1085. static void uninstall_fb(struct fb_info *info)
  1086. {
  1087. struct mfb_info *mfbi = info->par;
  1088. if (!mfbi->registered)
  1089. return;
  1090. unregister_framebuffer(info);
  1091. unmap_video_memory(info);
  1092. if (&info->cmap)
  1093. fb_dealloc_cmap(&info->cmap);
  1094. mfbi->registered = 0;
  1095. }
  1096. static irqreturn_t fsl_diu_isr(int irq, void *dev_id)
  1097. {
  1098. struct diu *hw = dr.diu_reg;
  1099. unsigned int status = in_be32(&hw->int_status);
  1100. if (status) {
  1101. /* This is the workaround for underrun */
  1102. if (status & INT_UNDRUN) {
  1103. out_be32(&hw->diu_mode, 0);
  1104. pr_debug("Err: DIU occurs underrun!\n");
  1105. udelay(1);
  1106. out_be32(&hw->diu_mode, 1);
  1107. }
  1108. #if defined(CONFIG_NOT_COHERENT_CACHE)
  1109. else if (status & INT_VSYNC) {
  1110. unsigned int i;
  1111. for (i = 0; i < coherence_data_size;
  1112. i += d_cache_line_size)
  1113. __asm__ __volatile__ (
  1114. "dcbz 0, %[input]"
  1115. ::[input]"r"(&coherence_data[i]));
  1116. }
  1117. #endif
  1118. return IRQ_HANDLED;
  1119. }
  1120. return IRQ_NONE;
  1121. }
  1122. static int request_irq_local(int irq)
  1123. {
  1124. unsigned long status, ints;
  1125. struct diu *hw;
  1126. int ret;
  1127. hw = dr.diu_reg;
  1128. /* Read to clear the status */
  1129. status = in_be32(&hw->int_status);
  1130. ret = request_irq(irq, fsl_diu_isr, 0, "diu", NULL);
  1131. if (ret)
  1132. pr_info("Request diu IRQ failed.\n");
  1133. else {
  1134. ints = INT_PARERR | INT_LS_BF_VS;
  1135. #if !defined(CONFIG_NOT_COHERENT_CACHE)
  1136. ints |= INT_VSYNC;
  1137. #endif
  1138. if (dr.mode == MFB_MODE2 || dr.mode == MFB_MODE3)
  1139. ints |= INT_VSYNC_WB;
  1140. /* Read to clear the status */
  1141. status = in_be32(&hw->int_status);
  1142. out_be32(&hw->int_mask, ints);
  1143. }
  1144. return ret;
  1145. }
  1146. static void free_irq_local(int irq)
  1147. {
  1148. struct diu *hw = dr.diu_reg;
  1149. /* Disable all LCDC interrupt */
  1150. out_be32(&hw->int_mask, 0x1f);
  1151. free_irq(irq, NULL);
  1152. }
  1153. #ifdef CONFIG_PM
  1154. /*
  1155. * Power management hooks. Note that we won't be called from IRQ context,
  1156. * unlike the blank functions above, so we may sleep.
  1157. */
  1158. static int fsl_diu_suspend(struct of_device *ofdev, pm_message_t state)
  1159. {
  1160. struct fsl_diu_data *machine_data;
  1161. machine_data = dev_get_drvdata(&ofdev->dev);
  1162. disable_lcdc(machine_data->fsl_diu_info[0]);
  1163. return 0;
  1164. }
  1165. static int fsl_diu_resume(struct of_device *ofdev)
  1166. {
  1167. struct fsl_diu_data *machine_data;
  1168. machine_data = dev_get_drvdata(&ofdev->dev);
  1169. enable_lcdc(machine_data->fsl_diu_info[0]);
  1170. return 0;
  1171. }
  1172. #else
  1173. #define fsl_diu_suspend NULL
  1174. #define fsl_diu_resume NULL
  1175. #endif /* CONFIG_PM */
  1176. /* Align to 64-bit(8-byte), 32-byte, etc. */
  1177. static int allocate_buf(struct diu_addr *buf, u32 size, u32 bytes_align)
  1178. {
  1179. u32 offset, ssize;
  1180. u32 mask;
  1181. dma_addr_t paddr = 0;
  1182. ssize = size + bytes_align;
  1183. buf->vaddr = dma_alloc_coherent(NULL, ssize, &paddr, GFP_DMA |
  1184. __GFP_ZERO);
  1185. if (!buf->vaddr)
  1186. return -ENOMEM;
  1187. buf->paddr = (__u32) paddr;
  1188. mask = bytes_align - 1;
  1189. offset = (u32)buf->paddr & mask;
  1190. if (offset) {
  1191. buf->offset = bytes_align - offset;
  1192. buf->paddr = (u32)buf->paddr + offset;
  1193. } else
  1194. buf->offset = 0;
  1195. return 0;
  1196. }
  1197. static void free_buf(struct diu_addr *buf, u32 size, u32 bytes_align)
  1198. {
  1199. dma_free_coherent(NULL, size + bytes_align,
  1200. buf->vaddr, (buf->paddr - buf->offset));
  1201. return;
  1202. }
  1203. static ssize_t store_monitor(struct device *device,
  1204. struct device_attribute *attr, const char *buf, size_t count)
  1205. {
  1206. int old_monitor_port;
  1207. unsigned long val;
  1208. struct fsl_diu_data *machine_data =
  1209. container_of(attr, struct fsl_diu_data, dev_attr);
  1210. if (strict_strtoul(buf, 10, &val))
  1211. return 0;
  1212. old_monitor_port = machine_data->monitor_port;
  1213. machine_data->monitor_port = diu_ops.set_sysfs_monitor_port(val);
  1214. if (old_monitor_port != machine_data->monitor_port) {
  1215. /* All AOIs need adjust pixel format
  1216. * fsl_diu_set_par only change the pixsel format here
  1217. * unlikely to fail. */
  1218. fsl_diu_set_par(machine_data->fsl_diu_info[0]);
  1219. fsl_diu_set_par(machine_data->fsl_diu_info[1]);
  1220. fsl_diu_set_par(machine_data->fsl_diu_info[2]);
  1221. fsl_diu_set_par(machine_data->fsl_diu_info[3]);
  1222. fsl_diu_set_par(machine_data->fsl_diu_info[4]);
  1223. }
  1224. return count;
  1225. }
  1226. static ssize_t show_monitor(struct device *device,
  1227. struct device_attribute *attr, char *buf)
  1228. {
  1229. struct fsl_diu_data *machine_data =
  1230. container_of(attr, struct fsl_diu_data, dev_attr);
  1231. return diu_ops.show_monitor_port(machine_data->monitor_port, buf);
  1232. }
  1233. static int __devinit fsl_diu_probe(struct of_device *ofdev,
  1234. const struct of_device_id *match)
  1235. {
  1236. struct device_node *np = ofdev->node;
  1237. struct mfb_info *mfbi;
  1238. phys_addr_t dummy_ad_addr;
  1239. int ret, i, error = 0;
  1240. struct resource res;
  1241. struct fsl_diu_data *machine_data;
  1242. machine_data = kzalloc(sizeof(struct fsl_diu_data), GFP_KERNEL);
  1243. if (!machine_data)
  1244. return -ENOMEM;
  1245. for (i = 0; i < ARRAY_SIZE(machine_data->fsl_diu_info); i++) {
  1246. machine_data->fsl_diu_info[i] =
  1247. framebuffer_alloc(sizeof(struct mfb_info), &ofdev->dev);
  1248. if (!machine_data->fsl_diu_info[i]) {
  1249. dev_err(&ofdev->dev, "cannot allocate memory\n");
  1250. ret = -ENOMEM;
  1251. goto error2;
  1252. }
  1253. mfbi = machine_data->fsl_diu_info[i]->par;
  1254. memcpy(mfbi, &mfb_template[i], sizeof(struct mfb_info));
  1255. mfbi->parent = machine_data;
  1256. }
  1257. ret = of_address_to_resource(np, 0, &res);
  1258. if (ret) {
  1259. dev_err(&ofdev->dev, "could not obtain DIU address\n");
  1260. goto error;
  1261. }
  1262. if (!res.start) {
  1263. dev_err(&ofdev->dev, "invalid DIU address\n");
  1264. goto error;
  1265. }
  1266. dev_dbg(&ofdev->dev, "%s, res.start: 0x%08x\n", __func__, res.start);
  1267. dr.diu_reg = ioremap(res.start, sizeof(struct diu));
  1268. if (!dr.diu_reg) {
  1269. dev_err(&ofdev->dev, "Err: can't map DIU registers!\n");
  1270. ret = -EFAULT;
  1271. goto error2;
  1272. }
  1273. out_be32(&dr.diu_reg->diu_mode, 0); /* disable DIU anyway*/
  1274. /* Get the IRQ of the DIU */
  1275. machine_data->irq = irq_of_parse_and_map(np, 0);
  1276. if (!machine_data->irq) {
  1277. dev_err(&ofdev->dev, "could not get DIU IRQ\n");
  1278. ret = -EINVAL;
  1279. goto error;
  1280. }
  1281. machine_data->monitor_port = monitor_port;
  1282. /* Area descriptor memory pool aligns to 64-bit boundary */
  1283. if (allocate_buf(&pool.ad, sizeof(struct diu_ad) * FSL_AOI_NUM, 8))
  1284. return -ENOMEM;
  1285. /* Get memory for Gamma Table - 32-byte aligned memory */
  1286. if (allocate_buf(&pool.gamma, 768, 32)) {
  1287. ret = -ENOMEM;
  1288. goto error;
  1289. }
  1290. /* For performance, cursor bitmap buffer aligns to 32-byte boundary */
  1291. if (allocate_buf(&pool.cursor, MAX_CURS * MAX_CURS * 2, 32)) {
  1292. ret = -ENOMEM;
  1293. goto error;
  1294. }
  1295. i = ARRAY_SIZE(machine_data->fsl_diu_info);
  1296. machine_data->dummy_ad = (struct diu_ad *)
  1297. ((u32)pool.ad.vaddr + pool.ad.offset) + i;
  1298. machine_data->dummy_ad->paddr = pool.ad.paddr +
  1299. i * sizeof(struct diu_ad);
  1300. machine_data->dummy_aoi_virt = fsl_diu_alloc(64, &dummy_ad_addr);
  1301. if (!machine_data->dummy_aoi_virt) {
  1302. ret = -ENOMEM;
  1303. goto error;
  1304. }
  1305. machine_data->dummy_ad->addr = cpu_to_le32(dummy_ad_addr);
  1306. machine_data->dummy_ad->pix_fmt = 0x88882317;
  1307. machine_data->dummy_ad->src_size_g_alpha = cpu_to_le32((4 << 12) | 4);
  1308. machine_data->dummy_ad->aoi_size = cpu_to_le32((4 << 16) | 2);
  1309. machine_data->dummy_ad->offset_xyi = 0;
  1310. machine_data->dummy_ad->offset_xyd = 0;
  1311. machine_data->dummy_ad->next_ad = 0;
  1312. out_be32(&dr.diu_reg->desc[0], machine_data->dummy_ad->paddr);
  1313. out_be32(&dr.diu_reg->desc[1], machine_data->dummy_ad->paddr);
  1314. out_be32(&dr.diu_reg->desc[2], machine_data->dummy_ad->paddr);
  1315. for (i = 0; i < ARRAY_SIZE(machine_data->fsl_diu_info); i++) {
  1316. machine_data->fsl_diu_info[i]->fix.smem_start = 0;
  1317. mfbi = machine_data->fsl_diu_info[i]->par;
  1318. mfbi->ad = (struct diu_ad *)((u32)pool.ad.vaddr
  1319. + pool.ad.offset) + i;
  1320. mfbi->ad->paddr = pool.ad.paddr + i * sizeof(struct diu_ad);
  1321. ret = install_fb(machine_data->fsl_diu_info[i]);
  1322. if (ret) {
  1323. dev_err(&ofdev->dev,
  1324. "Failed to register framebuffer %d\n",
  1325. i);
  1326. goto error;
  1327. }
  1328. }
  1329. if (request_irq_local(machine_data->irq)) {
  1330. dev_err(machine_data->fsl_diu_info[0]->dev,
  1331. "could not request irq for diu.");
  1332. goto error;
  1333. }
  1334. machine_data->dev_attr.attr.name = "monitor";
  1335. machine_data->dev_attr.attr.mode = S_IRUGO|S_IWUSR;
  1336. machine_data->dev_attr.show = show_monitor;
  1337. machine_data->dev_attr.store = store_monitor;
  1338. error = device_create_file(machine_data->fsl_diu_info[0]->dev,
  1339. &machine_data->dev_attr);
  1340. if (error) {
  1341. dev_err(machine_data->fsl_diu_info[0]->dev,
  1342. "could not create sysfs %s file\n",
  1343. machine_data->dev_attr.attr.name);
  1344. }
  1345. dev_set_drvdata(&ofdev->dev, machine_data);
  1346. return 0;
  1347. error:
  1348. for (i = ARRAY_SIZE(machine_data->fsl_diu_info);
  1349. i > 0; i--)
  1350. uninstall_fb(machine_data->fsl_diu_info[i - 1]);
  1351. if (pool.ad.vaddr)
  1352. free_buf(&pool.ad, sizeof(struct diu_ad) * FSL_AOI_NUM, 8);
  1353. if (pool.gamma.vaddr)
  1354. free_buf(&pool.gamma, 768, 32);
  1355. if (pool.cursor.vaddr)
  1356. free_buf(&pool.cursor, MAX_CURS * MAX_CURS * 2, 32);
  1357. if (machine_data->dummy_aoi_virt)
  1358. fsl_diu_free(machine_data->dummy_aoi_virt, 64);
  1359. iounmap(dr.diu_reg);
  1360. error2:
  1361. for (i = 0; i < ARRAY_SIZE(machine_data->fsl_diu_info); i++)
  1362. if (machine_data->fsl_diu_info[i])
  1363. framebuffer_release(machine_data->fsl_diu_info[i]);
  1364. kfree(machine_data);
  1365. return ret;
  1366. }
  1367. static int fsl_diu_remove(struct of_device *ofdev)
  1368. {
  1369. struct fsl_diu_data *machine_data;
  1370. int i;
  1371. machine_data = dev_get_drvdata(&ofdev->dev);
  1372. disable_lcdc(machine_data->fsl_diu_info[0]);
  1373. free_irq_local(machine_data->irq);
  1374. for (i = ARRAY_SIZE(machine_data->fsl_diu_info); i > 0; i--)
  1375. uninstall_fb(machine_data->fsl_diu_info[i - 1]);
  1376. if (pool.ad.vaddr)
  1377. free_buf(&pool.ad, sizeof(struct diu_ad) * FSL_AOI_NUM, 8);
  1378. if (pool.gamma.vaddr)
  1379. free_buf(&pool.gamma, 768, 32);
  1380. if (pool.cursor.vaddr)
  1381. free_buf(&pool.cursor, MAX_CURS * MAX_CURS * 2, 32);
  1382. if (machine_data->dummy_aoi_virt)
  1383. fsl_diu_free(machine_data->dummy_aoi_virt, 64);
  1384. iounmap(dr.diu_reg);
  1385. for (i = 0; i < ARRAY_SIZE(machine_data->fsl_diu_info); i++)
  1386. if (machine_data->fsl_diu_info[i])
  1387. framebuffer_release(machine_data->fsl_diu_info[i]);
  1388. kfree(machine_data);
  1389. return 0;
  1390. }
  1391. #ifndef MODULE
  1392. static int __init fsl_diu_setup(char *options)
  1393. {
  1394. char *opt;
  1395. unsigned long val;
  1396. if (!options || !*options)
  1397. return 0;
  1398. while ((opt = strsep(&options, ",")) != NULL) {
  1399. if (!*opt)
  1400. continue;
  1401. if (!strncmp(opt, "monitor=", 8)) {
  1402. if (!strict_strtoul(opt + 8, 10, &val) && (val <= 2))
  1403. monitor_port = val;
  1404. } else if (!strncmp(opt, "bpp=", 4)) {
  1405. if (!strict_strtoul(opt + 4, 10, &val))
  1406. default_bpp = val;
  1407. } else
  1408. fb_mode = opt;
  1409. }
  1410. return 0;
  1411. }
  1412. #endif
  1413. static struct of_device_id fsl_diu_match[] = {
  1414. {
  1415. .compatible = "fsl,diu",
  1416. },
  1417. {}
  1418. };
  1419. MODULE_DEVICE_TABLE(of, fsl_diu_match);
  1420. static struct of_platform_driver fsl_diu_driver = {
  1421. .owner = THIS_MODULE,
  1422. .name = "fsl_diu",
  1423. .match_table = fsl_diu_match,
  1424. .probe = fsl_diu_probe,
  1425. .remove = fsl_diu_remove,
  1426. .suspend = fsl_diu_suspend,
  1427. .resume = fsl_diu_resume,
  1428. };
  1429. static int __init fsl_diu_init(void)
  1430. {
  1431. #ifdef CONFIG_NOT_COHERENT_CACHE
  1432. struct device_node *np;
  1433. const u32 *prop;
  1434. #endif
  1435. int ret;
  1436. #ifndef MODULE
  1437. char *option;
  1438. /*
  1439. * For kernel boot options (in 'video=xxxfb:<options>' format)
  1440. */
  1441. if (fb_get_options("fslfb", &option))
  1442. return -ENODEV;
  1443. fsl_diu_setup(option);
  1444. #endif
  1445. printk(KERN_INFO "Freescale DIU driver\n");
  1446. #ifdef CONFIG_NOT_COHERENT_CACHE
  1447. np = of_find_node_by_type(NULL, "cpu");
  1448. if (!np) {
  1449. printk(KERN_ERR "Err: can't find device node 'cpu'\n");
  1450. return -ENODEV;
  1451. }
  1452. prop = of_get_property(np, "d-cache-size", NULL);
  1453. if (prop == NULL) {
  1454. of_node_put(np);
  1455. return -ENODEV;
  1456. }
  1457. /* Freescale PLRU requires 13/8 times the cache size to do a proper
  1458. displacement flush
  1459. */
  1460. coherence_data_size = *prop * 13;
  1461. coherence_data_size /= 8;
  1462. prop = of_get_property(np, "d-cache-line-size", NULL);
  1463. if (prop == NULL) {
  1464. of_node_put(np);
  1465. return -ENODEV;
  1466. }
  1467. d_cache_line_size = *prop;
  1468. of_node_put(np);
  1469. coherence_data = vmalloc(coherence_data_size);
  1470. if (!coherence_data)
  1471. return -ENOMEM;
  1472. #endif
  1473. ret = of_register_platform_driver(&fsl_diu_driver);
  1474. if (ret) {
  1475. printk(KERN_ERR
  1476. "fsl-diu: failed to register platform driver\n");
  1477. #if defined(CONFIG_NOT_COHERENT_CACHE)
  1478. vfree(coherence_data);
  1479. #endif
  1480. iounmap(dr.diu_reg);
  1481. }
  1482. return ret;
  1483. }
  1484. static void __exit fsl_diu_exit(void)
  1485. {
  1486. of_unregister_platform_driver(&fsl_diu_driver);
  1487. #if defined(CONFIG_NOT_COHERENT_CACHE)
  1488. vfree(coherence_data);
  1489. #endif
  1490. }
  1491. module_init(fsl_diu_init);
  1492. module_exit(fsl_diu_exit);
  1493. MODULE_AUTHOR("York Sun <yorksun@freescale.com>");
  1494. MODULE_DESCRIPTION("Freescale DIU framebuffer driver");
  1495. MODULE_LICENSE("GPL");
  1496. module_param_named(mode, fb_mode, charp, 0);
  1497. MODULE_PARM_DESC(mode,
  1498. "Specify resolution as \"<xres>x<yres>[-<bpp>][@<refresh>]\" ");
  1499. module_param_named(bpp, default_bpp, ulong, 0);
  1500. MODULE_PARM_DESC(bpp, "Specify bit-per-pixel if not specified mode");
  1501. module_param_named(monitor, monitor_port, int, 0);
  1502. MODULE_PARM_DESC(monitor,
  1503. "Specify the monitor port (0, 1 or 2) if supported by the platform");