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

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

嵌入式Linux

开发平台：

Unix_Linux

pxafb.c：源码内容
  1. /*
  2.  *  linux/drivers/video/pxafb.c
  3.  *
  4.  *  Copyright (C) 1999 Eric A. Thomas
  5.  *   Based on acornfb.c Copyright (C) Russell King.
  6.  *
  7.  * This file is subject to the terms and conditions of the GNU General Public
  8.  * License.  See the file COPYING in the main directory of this archive for
  9.  * more details.
  10.  *
  11.  *         Intel PXA250/210 LCD Controller Frame Buffer Driver
  12.  *
  13.  * Please direct your questions and comments on this driver to the following
  14.  * email address:
  15.  *
  16.  * linux-arm-kernel@lists.arm.linux.org.uk
  17.  *
  18.  * Clean patches should be sent to the ARM Linux Patch System.  Please see the
  19.  * following web page for more information:
  20.  *
  21.  * http://www.arm.linux.org.uk/developer/patches/info.shtml
  22.  *
  23.  * Thank you.
  24.  *
  25.  *
  26.  * Code Status:
  27.  * 1999/04/01:
  28.  * - Driver appears to be working for Brutus 320x200x8bpp mode.  Other
  29.  *   resolutions are working, but only the 8bpp mode is supported.
  30.  *   Changes need to be made to the palette encode and decode routines
  31.  *   to support 4 and 16 bpp modes.  
  32.  *   Driver is not designed to be a module.  The FrameBuffer is statically
  33.  *   allocated since dynamic allocation of a 300k buffer cannot be 
  34.  *   guaranteed. 
  35.  *
  36.  * 1999/06/17:
  37.  * - FrameBuffer memory is now allocated at run-time when the
  38.  *   driver is initialized.    
  39.  *
  40.  * 2000/04/10: Nicolas Pitre <nico@cam.org>
  41.  * - Big cleanup for dynamic selection of machine type at run time.
  42.  *
  43.  * 2000/07/19: Jamey Hicks <jamey@crl.dec.com>
  44.  * - Support for Bitsy aka Compaq iPAQ H3600 added.
  45.  *
  46.  * 2000/08/07: Tak-Shing Chan <tchan.rd@idthk.com>
  47.  *        Jeff Sutherland <jsutherland@accelent.com>
  48.  * - Resolved an issue caused by a change made to the Assabet's PLD 
  49.  *   earlier this year which broke the framebuffer driver for newer 
  50.  *   Phase 4 Assabets.  Some other parameters were changed to optimize
  51.  *   for the Sharp display.
  52.  *
  53.  * 2000/08/09: Cliff Brake <cbrake@accelent.com>
  54.  *      - modified for Accelent
  55.  * 
  56.  * 2000/08/09: Kunihiko IMAI <imai@vasara.co.jp>
  57.  * - XP860 support added
  58.  *
  59.  * 2000/08/19: Mark Huang <mhuang@livetoy.com>
  60.  * - Allows standard options to be passed on the kernel command line
  61.  *   for most common passive displays.
  62.  *
  63.  * 2000/08/29:
  64.  * - s/save_flags_cli/local_irq_save/
  65.  * - remove unneeded extra save_flags_cli in sa1100fb_enable_lcd_controller
  66.  *
  67.  * 2000/10/10: Erik Mouw <J.A.K.Mouw@its.tudelft.nl>
  68.  * - Updated LART stuff. Fixed some minor bugs.
  69.  *
  70.  * 2000/10/30: Murphy Chen <murphy@mail.dialogue.com.tw>
  71.  * - Pangolin support added
  72.  *
  73.  * 2000/10/31: Roman Jordan <jor@hoeft-wessel.de>
  74.  * - Huw Webpanel support added
  75.  *
  76.  * 2000/11/23: Eric Peng <ericpeng@coventive.com>
  77.  * - Freebird add
  78.  *
  79.  * 2001/02/07: Jamey Hicks <jamey.hicks@compaq.com> 
  80.  *        Cliff Brake <cbrake@accelent.com>
  81.  * - Added PM callback
  82.  *
  83.  * 2001/05/26: <rmk@arm.linux.org.uk>
  84.  * - Fix 16bpp so that (a) we use the right colours rather than some
  85.  *   totally random colour depending on what was in page 0, and (b)
  86.  *   we don't de-reference a NULL pointer.
  87.  * - remove duplicated implementation of consistent_alloc()
  88.  * - convert dma address types to dma_addr_t
  89.  * - remove unused 'montype' stuff
  90.  * - remove redundant zero inits of init_var after the initial
  91.  *   memzero.
  92.  * - remove allow_modeset (acornfb idea does not belong here)
  93.  *
  94.  * 2001/05/28: <rmk@arm.linux.org.uk>
  95.  * - massive cleanup - move machine dependent data into structures
  96.  * - I've left various #warnings in - if you see one, and know
  97.  *   the hardware concerned, please get in contact with me.
  98.  *
  99.  * 2001/05/31: <rmk@arm.linux.org.uk>
  100.  * - Fix LCCR1 HSW value, fix all machine type specifications to
  101.  *   keep values in line.  (Please check your machine type specs)
  102.  *
  103.  * 2001/06/10: <rmk@arm.linux.org.uk>
  104.  * - Fiddle with the LCD controller from task context only; mainly
  105.  *   so that we can run with interrupts on, and sleep.
  106.  * - Convert #warnings into #errors.  No pain, no gain. ;)
  107.  *
  108.  * 2001/06/14: <rmk@arm.linux.org.uk>
  109.  * - Make the palette BPS value for 12bpp come out correctly.
  110.  * - Take notice of "greyscale" on any colour depth.
  111.  * - Make truecolor visuals use the RGB channel encoding information.
  112.  *
  113.  * 2001/07/02: <rmk@arm.linux.org.uk>
  114.  * - Fix colourmap problems.
  115.  *
  116.  * 2001/08/03: <cbrake@accelent.com>
  117.  *      - Ported from SA1100 to PXA250
  118.  */
  120. #include <linux/config.h>
  121. #include <linux/module.h>
  122. #include <linux/kernel.h>
  123. #include <linux/sched.h>
  124. #include <linux/errno.h>
  125. #include <linux/string.h>
  126. #include <linux/interrupt.h>
  127. #include <linux/slab.h>
  128. #include <linux/fb.h>
  129. #include <linux/delay.h>
  130. #include <linux/pm.h>
  131. #include <linux/init.h>
  133. #include <asm/hardware.h>
  134. #include <asm/io.h>
  135. #include <asm/irq.h>
  136. #include <asm/mach-types.h>
  137. #include <asm/uaccess.h>
  139. #include <video/fbcon.h>
  140. #include <video/fbcon-mfb.h>
  141. #include <video/fbcon-cfb4.h>
  142. #include <video/fbcon-cfb8.h>
  143. #include <video/fbcon-cfb16.h>
  145. /*
  146.  * debugging?
  147.  */
  148. #define DEBUG 0
  149. /*
  150.  * Complain if VAR is out of range.
  151.  */
  152. #define DEBUG_VAR 1
  154. #undef ASSABET_PAL_VIDEO
  156. #include "pxafb.h"
  158. void (*pxafb_blank_helper)(int blank);
  159. EXPORT_SYMBOL(pxafb_blank_helper);
  162. /*
  163.  * IMHO this looks wrong.  In 8BPP, length should be 8.
  164.  */
  165. static struct pxafb_rgb rgb_8 = {
  166. red: { offset: 0,  length: 4, },
  167. green: { offset: 0,  length: 4, },
  168. blue: { offset: 0,  length: 4, },
  169. transp: { offset: 0,  length: 0, },
  170. };
  172. static struct pxafb_rgb def_rgb_16 = {
  173. red: { offset: 11, length: 5, },
  174. green: { offset: 5,  length: 6, },
  175. blue: { offset: 0,  length: 5, },
  176. transp: { offset: 0,  length: 0, },
  177. };
  179. static struct pxafb_mach_info lubbock_info __initdata = {
  180. pixclock: 150000, /* clock period in ps */
  181. bpp: 8,
  182. xres: 640,
  183. yres: 480,
  184. hsync_len: 1, // LCD_HORIZONTAL_SYNC_PULSE_WIDTH,
  185. vsync_len: 1, // LCD_VERTICAL_SYNC_PULSE_WIDTH,
  186. left_margin: 3, // LCD_BEGIN_OF_LINE_WAIT_COUNT,
  187. upper_margin: 0, //LCD_BEGIN_FRAME_WAIT_COUNT,
  188. right_margin: 3, //LCD_END_OF_LINE_WAIT_COUNT,
  189. lower_margin: 0, //LCD_END_OF_FRAME_WAIT_COUNT,
  190. sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  191. lccr0: 0x0030087C, //LCD_CTL0_VALUE,
  192. lccr3: 0x0340FF0C  //LCD_CTL3_VALUE,
  193. };
  195. static struct pxafb_mach_info idp_info __initdata = {
  196. pixclock: 150000, /* clock period in ps */
  197. bpp: 8,
  198. xres: 640,
  199. yres: 480,
  200. hsync_len: 1, // LCD_HORIZONTAL_SYNC_PULSE_WIDTH,
  201. vsync_len: 1, // LCD_VERTICAL_SYNC_PULSE_WIDTH,
  202. left_margin: 3, // LCD_BEGIN_OF_LINE_WAIT_COUNT,
  203. upper_margin: 0, //LCD_BEGIN_FRAME_WAIT_COUNT,
  204. right_margin: 3, //LCD_END_OF_LINE_WAIT_COUNT,
  205. lower_margin: 0, //LCD_END_OF_FRAME_WAIT_COUNT,
  206. sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  207. lccr0: 0x0030087C, //LCD_CTL0_VALUE,
  208. lccr3: 0x0340FF0C  //LCD_CTL3_VALUE,
  209. };
  211. static struct pxafb_mach_info * __init
  212. pxafb_get_machine_info(struct pxafb_info *fbi)
  213. {
  214. struct pxafb_mach_info *inf = NULL;
  216. /*
  217.  *            R        G       B       T
  218.  * default  {11,5}, { 5,6}, { 0,5}, { 0,0}
  219.  * bitsy    {12,4}, { 7,4}, { 1,4}, { 0,0}
  220.  * freebird { 8,4}, { 4,4}, { 0,4}, {12,4}
  221.  */
  222. if (machine_is_lubbock()) {
  223. inf = &lubbock_info;
  224. } else if (machine_is_pxa_idp()) {
  225. inf = &idp_info;
  226. }
  227. return inf;
  228. }
  230. static int pxafb_activate_var(struct fb_var_screeninfo *var, struct pxafb_info *);
  231. static void set_ctrlr_state(struct pxafb_info *fbi, u_int state);
  233. static inline void pxafb_schedule_task(struct pxafb_info *fbi, u_int state)
  234. {
  235. unsigned long flags;
  237. local_irq_save(flags);
  238. /*
  239.  * We need to handle two requests being made at the same time.
  240.  * There are two important cases:
  241.  *  1. When we are changing VT (C_REENABLE) while unblanking (C_ENABLE)
  242.  *     We must perform the unblanking, which will do our REENABLE for us.
  243.  *  2. When we are blanking, but immediately unblank before we have
  244.  *     blanked.  We do the "REENABLE" thing here as well, just to be sure.
  245.  */
  246. if (fbi->task_state == C_ENABLE && state == C_REENABLE)
  247. state = (u_int) -1;
  248. if (fbi->task_state == C_DISABLE && state == C_ENABLE)
  249. state = C_REENABLE;
  251. if (state != (u_int)-1) {
  252. fbi->task_state = state;
  253. schedule_task(&fbi->task);
  254. }
  255. local_irq_restore(flags);
  256. }
  258. /*
  259.  * Get the VAR structure pointer for the specified console
  260.  */
  261. static inline struct fb_var_screeninfo *get_con_var(struct fb_info *info, int con)
  262. {
  263. struct pxafb_info *fbi = (struct pxafb_info *)info;
  264. return (con == fbi->currcon || con == -1) ? &fbi->fb.var : &fb_display[con].var;
  265. }
  267. /*
  268.  * Get the DISPLAY structure pointer for the specified console
  269.  */
  270. static inline struct display *get_con_display(struct fb_info *info, int con)
  271. {
  272. struct pxafb_info *fbi = (struct pxafb_info *)info;
  273. return (con < 0) ? fbi->fb.disp : &fb_display[con];
  274. }
  276. /*
  277.  * Get the CMAP pointer for the specified console
  278.  */
  279. static inline struct fb_cmap *get_con_cmap(struct fb_info *info, int con)
  280. {
  281. struct pxafb_info *fbi = (struct pxafb_info *)info;
  282. return (con == fbi->currcon || con == -1) ? &fbi->fb.cmap : &fb_display[con].cmap;
  283. }
  285. static inline u_int
  286. chan_to_field(u_int chan, struct fb_bitfield *bf)
  287. {
  288. chan &= 0xffff;
  289. chan >>= 16 - bf->length;
  290. return chan << bf->offset;
  291. }
  293. static int
  294. pxafb_setpalettereg(u_int regno, u_int red, u_int green, u_int blue,
  295.        u_int trans, struct fb_info *info)
  296. {
  297. struct pxafb_info *fbi = (struct pxafb_info *)info;
  298. u_int val, ret = 1;
  300. if (regno < fbi->palette_size) {
  301. val = ((red >> 0) & 0xf800);
  302. val |= ((green >> 5) & 0x07e0);
  303. val |= ((blue >> 11) & 0x001f);
  305. fbi->palette_cpu[regno] = val;
  306. ret = 0;
  307. }
  308. return ret;
  309. }
  311. static int
  312. pxafb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  313.    u_int trans, struct fb_info *info)
  314. {
  315. struct pxafb_info *fbi = (struct pxafb_info *)info;
  316. u_int val;
  317. int ret = 1;
  319. /*
  320.  * If greyscale is true, then we convert the RGB value
  321.  * to greyscale no mater what visual we are using.
  322.  */
  323. if (fbi->fb.var.grayscale)
  324. red = green = blue = (19595 * red + 38470 * green +
  325. 7471 * blue) >> 16;
  327. switch (fbi->fb.disp->visual) {
  328. case FB_VISUAL_TRUECOLOR:
  329. /*
  330.  * 12 or 16-bit True Colour.  We encode the RGB value
  331.  * according to the RGB bitfield information.
  332.  */
  333. if (regno < 16) {
  334. u16 *pal = fbi->fb.pseudo_palette;
  336. val  = chan_to_field(red, &fbi->fb.var.red);
  337. val |= chan_to_field(green, &fbi->fb.var.green);
  338. val |= chan_to_field(blue, &fbi->fb.var.blue);
  340. pal[regno] = val;
  341. ret = 0;
  342. }
  343. break;
  345. case FB_VISUAL_PSEUDOCOLOR:
  346. ret = pxafb_setpalettereg(regno, red, green, blue, trans, info);
  347. break;
  348. }
  350. return ret;
  351. }
  353. /*
  354.  *  pxafb_decode_var():
  355.  *    Get the video params out of 'var'. If a value doesn't fit, round it up,
  356.  *    if it's too big, return -EINVAL.
  357.  *
  358.  *    Suggestion: Round up in the following order: bits_per_pixel, xres,
  359.  *    yres, xres_virtual, yres_virtual, xoffset, yoffset, grayscale,
  360.  *    bitfields, horizontal timing, vertical timing.
  361.  */
  362. static int pxafb_validate_var(struct fb_var_screeninfo *var,
  363.  struct pxafb_info *fbi)
  364. {
  365. int ret = -EINVAL;
  367. if (var->xres < MIN_XRES)
  368. var->xres = MIN_XRES;
  369. if (var->yres < MIN_YRES)
  370. var->yres = MIN_YRES;
  371. if (var->xres > fbi->max_xres)
  372. var->xres = fbi->max_xres;
  373. if (var->yres > fbi->max_yres)
  374. var->yres = fbi->max_yres;
  375. var->xres_virtual =
  376.     var->xres_virtual < var->xres ? var->xres : var->xres_virtual;
  377. var->yres_virtual =
  378.     var->yres_virtual < var->yres ? var->yres : var->yres_virtual;
  380. DPRINTK("var->bits_per_pixel=%dn", var->bits_per_pixel);
  381. switch (var->bits_per_pixel) {
  382. #ifdef FBCON_HAS_CFB4
  383. case 4:  ret = 0; break;
  384. #endif
  385. #ifdef FBCON_HAS_CFB8
  386. case 8:  ret = 0; break;
  387. #endif
  388. #ifdef FBCON_HAS_CFB16
  389. case 12:
  390. /* make sure we are in passive mode */
  391. if (!(fbi->lccr0 & LCCR0_PAS))
  392. ret = 0;
  393. break;
  395. case 16:
  396. /* make sure we are in active mode */
  397. if ((fbi->lccr0 & LCCR0_PAS))
  398. ret = 0;
  399. break;
  400. #endif
  401. default:
  402. break;
  403. }
  405. return ret;
  406. }
  408. static inline void pxafb_set_truecolor(u_int is_true_color)
  409. {
  410. DPRINTK("true_color = %dn", is_true_color);
  411. #ifdef CONFIG_SA1100_ASSABET
  412. if (machine_is_assabet()) {
  413. #if 1
  414. // phase 4 or newer Assabet's
  415. if (is_true_color)
  416. BCR_set(BCR_LCD_12RGB);
  417. else
  418. BCR_clear(BCR_LCD_12RGB);
  419. #else
  420. // older Assabet's
  421. if (is_true_color)
  422. BCR_clear(BCR_LCD_12RGB);
  423. else
  424. BCR_set(BCR_LCD_12RGB);
  425. #endif
  426. }
  427. #endif
  428. }
  430. static void
  431. pxafb_hw_set_var(struct fb_var_screeninfo *var, struct pxafb_info *fbi)
  432. {
  434. fb_set_cmap(&fbi->fb.cmap, 1, pxafb_setcolreg, &fbi->fb);
  436. /* Set board control register to handle new color depth */
  437. pxafb_set_truecolor(var->bits_per_pixel >= 16);
  439. pxafb_activate_var(var, fbi);
  441. }
  443. /*
  444.  * pxafb_set_var():
  445.  * Set the user defined part of the display for the specified console
  446.  */
  447. static int
  448. pxafb_set_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
  449. {
  450. struct pxafb_info *fbi = (struct pxafb_info *)info;
  451. struct fb_var_screeninfo *dvar = get_con_var(&fbi->fb, con);
  452. struct display *display = get_con_display(&fbi->fb, con);
  453. int err, chgvar = 0, rgbidx;
  455. DPRINTK("set_varn");
  457. /*
  458.  * Decode var contents into a par structure, adjusting any
  459.  * out of range values.
  460.  */
  461. err = pxafb_validate_var(var, fbi);
  462. if (err)
  463. return err;
  465. if (var->activate & FB_ACTIVATE_TEST)
  466. return 0;
  468. if ((var->activate & FB_ACTIVATE_MASK) != FB_ACTIVATE_NOW)
  469. return -EINVAL;
  471. if (dvar->xres != var->xres)
  472. chgvar = 1;
  473. if (dvar->yres != var->yres)
  474. chgvar = 1;
  475. if (dvar->xres_virtual != var->xres_virtual)
  476. chgvar = 1;
  477. if (dvar->yres_virtual != var->yres_virtual)
  478. chgvar = 1;
  479. if (dvar->bits_per_pixel != var->bits_per_pixel)
  480. chgvar = 1;
  481. if (con < 0)
  482. chgvar = 0;
  484. switch (var->bits_per_pixel) {
  485. #ifdef FBCON_HAS_CFB4
  486. case 4:
  487. if (fbi->cmap_static)
  488. display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
  489. else
  490. display->visual = FB_VISUAL_PSEUDOCOLOR;
  491. display->line_length = var->xres / 2;
  492. display->dispsw = &fbcon_cfb4;
  493. rgbidx = RGB_8;
  494. break;
  495. #endif
  496. #ifdef FBCON_HAS_CFB8
  497. case 8:
  498. if (fbi->cmap_static)
  499. display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
  500. else
  501. display->visual = FB_VISUAL_PSEUDOCOLOR;
  502. display->line_length = var->xres;
  503. display->dispsw = &fbcon_cfb8;
  504. rgbidx = RGB_8;
  505. break;
  506. #endif
  507. #ifdef FBCON_HAS_CFB16
  508. case 12:
  509. case 16:
  510. display->visual = FB_VISUAL_TRUECOLOR;
  511. display->line_length = var->xres * 2;
  512. display->dispsw = &fbcon_cfb16;
  513. display->dispsw_data = fbi->fb.pseudo_palette;
  514. rgbidx = RGB_16;
  515. break;
  516. #endif
  517. default:
  518. rgbidx = 0;
  519. display->dispsw = &fbcon_dummy;
  520. break;
  521. }
  523. display->screen_base = fbi->screen_cpu;
  524. display->next_line = display->line_length;
  525. display->type = fbi->fb.fix.type;
  526. display->type_aux = fbi->fb.fix.type_aux;
  527. display->ypanstep = fbi->fb.fix.ypanstep;
  528. display->ywrapstep = fbi->fb.fix.ywrapstep;
  529. display->can_soft_blank = 1;
  530. display->inverse = 0;
  532. *dvar = *var;
  533. dvar->activate &= ~FB_ACTIVATE_ALL;
  535. /*
  536.  * Copy the RGB parameters for this display
  537.  * from the machine specific parameters.
  538.  */
  539. dvar->red = fbi->rgb[rgbidx]->red;
  540. dvar->green = fbi->rgb[rgbidx]->green;
  541. dvar->blue = fbi->rgb[rgbidx]->blue;
  542. dvar->transp = fbi->rgb[rgbidx]->transp;
  544. DPRINTK("RGBT length = %d:%d:%d:%dn",
  545. dvar->red.length, dvar->green.length, dvar->blue.length,
  546. dvar->transp.length);
  548. DPRINTK("RGBT offset = %d:%d:%d:%dn",
  549. dvar->red.offset, dvar->green.offset, dvar->blue.offset,
  550. dvar->transp.offset);
  552. /*
  553.  * Update the old var.  The fbcon drivers still use this.
  554.  * Once they are using fbi->fb.var, this can be dropped.
  555.  */
  556. display->var = *dvar;
  558. /*
  559.  * If we are setting all the virtual consoles, also set the
  560.  * defaults used to create new consoles.
  561.  */
  562. if (var->activate & FB_ACTIVATE_ALL)
  563. fbi->fb.disp->var = *dvar;
  565. /*
  566.  * If the console has changed and the console has defined
  567.  * a changevar function, call that function.
  568.  */
  569. if (chgvar && info && fbi->fb.changevar)
  570. fbi->fb.changevar(con);
  572. /* If the current console is selected, activate the new var. */
  573. if (con != fbi->currcon)
  574. return 0;
  576. pxafb_hw_set_var(dvar, fbi);
  578. return 0;
  579. }
  581. static int
  582. __do_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  583.       struct fb_info *info)
  584. {
  585. struct pxafb_info *fbi = (struct pxafb_info *)info;
  586. struct fb_cmap *dcmap = get_con_cmap(info, con);
  587. int err = 0;
  589. if (con == -1)
  590. con = fbi->currcon;
  592. /* no colormap allocated? (we always have "this" colour map allocated) */
  593. if (con >= 0)
  594. err = fb_alloc_cmap(&fb_display[con].cmap, fbi->palette_size, 0);
  596. if (!err && con == fbi->currcon)
  597. err = fb_set_cmap(cmap, kspc, pxafb_setcolreg, info);
  599. if (!err)
  600. fb_copy_cmap(cmap, dcmap, kspc ? 0 : 1);
  602. return err;
  603. }
  605. static int
  606. pxafb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  607.   struct fb_info *info)
  608. {
  609. struct display *disp = get_con_display(info, con);
  611. if (disp->visual == FB_VISUAL_TRUECOLOR)
  612. return -EINVAL;
  614. return __do_set_cmap(cmap, kspc, con, info);
  615. }
  617. static int
  618. pxafb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
  619. {
  620. struct display *display = get_con_display(info, con);
  622. *fix = info->fix;
  624. fix->line_length = display->line_length;
  625. fix->visual  = display->visual;
  626. return 0;
  627. }
  629. static int
  630. pxafb_get_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
  631. {
  632. *var = *get_con_var(info, con);
  633. return 0;
  634. }
  636. static int
  637. pxafb_get_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
  638. {
  639. struct fb_cmap *dcmap = get_con_cmap(info, con);
  640. fb_copy_cmap(dcmap, cmap, kspc ? 0 : 2);
  641. return 0;
  642. }
  644. static struct fb_ops pxafb_ops = {
  645. owner: THIS_MODULE,
  646. fb_get_fix: pxafb_get_fix,
  647. fb_get_var: pxafb_get_var,
  648. fb_set_var: pxafb_set_var,
  649. fb_get_cmap: pxafb_get_cmap,
  650. fb_set_cmap: pxafb_set_cmap,
  651. };
  653. /*
  654.  *  pxafb_switch():       
  655.  * Change to the specified console.  Palette and video mode
  656.  *      are changed to the console's stored parameters.
  657.  *
  658.  * Uh oh, this can be called from a tasklet (IRQ)
  659.  */
  660. static int pxafb_switch(int con, struct fb_info *info)
  661. {
  662. struct pxafb_info *fbi = (struct pxafb_info *)info;
  663. struct display *disp;
  664. struct fb_cmap *cmap;
  666. DPRINTK("con=%d info->modename=%sn", con, fbi->fb.modename);
  668. if (con == fbi->currcon)
  669. return 0;
  671. if (fbi->currcon >= 0) {
  672. disp = fb_display + fbi->currcon;
  674. /*
  675.  * Save the old colormap and video mode.
  676.  */
  677. disp->var = fbi->fb.var;
  679. if (disp->cmap.len)
  680. fb_copy_cmap(&fbi->fb.cmap, &disp->cmap, 0);
  681. }
  683. fbi->currcon = con;
  684. disp = fb_display + con;
  686. /*
  687.  * Make sure that our colourmap contains 256 entries.
  688.  */
  689. fb_alloc_cmap(&fbi->fb.cmap, 256, 0);
  691. if (disp->cmap.len)
  692. cmap = &disp->cmap;
  693. else
  694. cmap = fb_default_cmap(1 << disp->var.bits_per_pixel);
  696. fb_copy_cmap(cmap, &fbi->fb.cmap, 0);
  698. fbi->fb.var = disp->var;
  699. fbi->fb.var.activate = FB_ACTIVATE_NOW;
  701. pxafb_set_var(&fbi->fb.var, con, info);
  702. return 0;
  703. }
  705. /*
  706.  * Formal definition of the VESA spec:
  707.  *  On
  708.  *   This refers to the state of the display when it is in full operation
  709.  *  Stand-By
  710.  *   This defines an optional operating state of minimal power reduction with
  711.  *   the shortest recovery time
  712.  *  Suspend
  713.  *   This refers to a level of power management in which substantial power
  714.  *   reduction is achieved by the display.  The display can have a longer 
  715.  *   recovery time from this state than from the Stand-by state
  716.  *  Off
  717.  *   This indicates that the display is consuming the lowest level of power
  718.  *   and is non-operational. Recovery from this state may optionally require
  719.  *   the user to manually power on the monitor
  720.  *
  721.  *  Now, the fbdev driver adds an additional state, (blank), where they
  722.  *  turn off the video (maybe by colormap tricks), but don't mess with the
  723.  *  video itself: think of it semantically between on and Stand-By.
  724.  *
  725.  *  So here's what we should do in our fbdev blank routine:
  726.  *
  727.  *   VESA_NO_BLANKING (mode 0) Video on,  front/back light on
  728.  *   VESA_VSYNC_SUSPEND (mode 1)   Video on,  front/back light off
  729.  *   VESA_HSYNC_SUSPEND (mode 2)   Video on,  front/back light off
  730.  *   VESA_POWERDOWN (mode 3) Video off, front/back light off
  731.  *
  732.  *  This will match the matrox implementation.
  733.  */
  734. /*
  735.  * pxafb_blank():
  736.  * Blank the display by setting all palette values to zero.  Note, the 
  737.  *  12 and 16 bpp modes don't really use the palette, so this will not
  738.  *      blank the display in all modes.  
  739.  */
  740. static void pxafb_blank(int blank, struct fb_info *info)
  741. {
  742. struct pxafb_info *fbi = (struct pxafb_info *)info;
  743. int i;
  745. DPRINTK("pxafb_blank: blank=%d info->modename=%sn", blank,
  746. fbi->fb.modename);
  748. switch (blank) {
  749. case VESA_POWERDOWN:
  750. case VESA_VSYNC_SUSPEND:
  751. case VESA_HSYNC_SUSPEND:
  752. if (fbi->fb.disp->visual == FB_VISUAL_PSEUDOCOLOR ||
  753.     fbi->fb.disp->visual == FB_VISUAL_STATIC_PSEUDOCOLOR)
  754. for (i = 0; i < fbi->palette_size; i++)
  755. pxafb_setpalettereg(i, 0, 0, 0, 0, info);
  756. pxafb_schedule_task(fbi, C_DISABLE);
  757. if (pxafb_blank_helper)
  758. pxafb_blank_helper(blank);
  759. break;
  761. case VESA_NO_BLANKING:
  762. if (pxafb_blank_helper)
  763. pxafb_blank_helper(blank);
  764. if (fbi->fb.disp->visual == FB_VISUAL_PSEUDOCOLOR ||
  765.     fbi->fb.disp->visual == FB_VISUAL_STATIC_PSEUDOCOLOR)
  766. fb_set_cmap(&fbi->fb.cmap, 1, pxafb_setcolreg, info);
  767. pxafb_schedule_task(fbi, C_ENABLE);
  768. }
  769. }
  771. static int pxafb_updatevar(int con, struct fb_info *info)
  772. {
  773. DPRINTK("enteredn");
  774. return 0;
  775. }
  777. /*
  778.  * Calculate the PCD value from the clock rate (in picoseconds).
  779.  * We take account of the PPCR clock setting.
  780.  */
  781. static inline int get_pcd(unsigned int pixclock)
  782. {
  783. unsigned int pcd;
  785. if (pixclock) {
  786. pcd = get_lclk_frequency_10khz() * pixclock;
  787. pcd /= 100000000;
  788. pcd += 1; /* make up for integer math truncations */
  789. } else {
  790. printk(KERN_WARNING "Please convert me to use the PCD calculationsn");
  791. pcd = 0;
  792. }
  793. return pcd;
  794. }
  796. /*
  797.  * pxafb_activate_var():
  798.  * Configures LCD Controller based on entries in var parameter.  Settings are      
  799.  *      only written to the controller if changes were made.  
  800.  */
  801. static int pxafb_activate_var(struct fb_var_screeninfo *var, struct pxafb_info *fbi)
  802. {
  803. struct pxafb_lcd_reg new_regs;
  804. u_int pcd = get_pcd(var->pixclock);
  805. u_long flags;
  807. DPRINTK("Configuring PXA LCDn");
  809. DPRINTK("var: xres=%d hslen=%d lm=%d rm=%dn",
  810. var->xres, var->hsync_len,
  811. var->left_margin, var->right_margin);
  812. DPRINTK("var: yres=%d vslen=%d um=%d bm=%dn",
  813. var->yres, var->vsync_len,
  814. var->upper_margin, var->lower_margin);
  816. #if DEBUG_VAR
  817. if (var->xres < 16        || var->xres > 1024)
  818. printk(KERN_ERR "%s: invalid xres %dn",
  819. fbi->fb.fix.id, var->xres);
  820. if (var->hsync_len < 1    || var->hsync_len > 64)
  821. printk(KERN_ERR "%s: invalid hsync_len %dn",
  822. fbi->fb.fix.id, var->hsync_len);
  823. if (var->left_margin < 1  || var->left_margin > 255)
  824. printk(KERN_ERR "%s: invalid left_margin %dn",
  825. fbi->fb.fix.id, var->left_margin);
  826. if (var->right_margin < 1 || var->right_margin > 255)
  827. printk(KERN_ERR "%s: invalid right_margin %dn",
  828. fbi->fb.fix.id, var->right_margin);
  829. if (var->yres < 1         || var->yres > 1024)
  830. printk(KERN_ERR "%s: invalid yres %dn",
  831. fbi->fb.fix.id, var->yres);
  832. if (var->vsync_len < 1    || var->vsync_len > 64)
  833. printk(KERN_ERR "%s: invalid vsync_len %dn",
  834. fbi->fb.fix.id, var->vsync_len);
  835. if (var->upper_margin < 0 || var->upper_margin > 255)
  836. printk(KERN_ERR "%s: invalid upper_margin %dn",
  837. fbi->fb.fix.id, var->upper_margin);
  838. if (var->lower_margin < 0 || var->lower_margin > 255)
  839. printk(KERN_ERR "%s: invalid lower_margin %dn",
  840. fbi->fb.fix.id, var->lower_margin);
  841. #endif
  843. // FIXME using hardcoded values for now
  844. new_regs.lccr0 = fbi->lccr0;
  845. // |
  846. // LCCR0_LEN | LCCR0_LDM | LCCR0_BAM |
  847. // LCCR0_ERM | LCCR0_LtlEnd | LCCR0_DMADel(0);
  849. new_regs.lccr1 = 0x3030A7F;
  850. // LCCR1_DisWdth(var->xres) +
  851. // LCCR1_HorSnchWdth(var->hsync_len) +
  852. // LCCR1_BegLnDel(var->left_margin) +
  853. // LCCR1_EndLnDel(var->right_margin);
  855. new_regs.lccr2 = 0x4EF;
  856. // LCCR2_DisHght(var->yres) +
  857. // LCCR2_VrtSnchWdth(var->vsync_len) +
  858. // LCCR2_BegFrmDel(var->upper_margin) +
  859. // LCCR2_EndFrmDel(var->lower_margin);
  861. new_regs.lccr3 = fbi->lccr3;
  862. // |
  863. // (var->sync & FB_SYNC_HOR_HIGH_ACT ? LCCR3_HorSnchH : LCCR3_HorSnchL) |
  864. // (var->sync & FB_SYNC_VERT_HIGH_ACT ? LCCR3_VrtSnchH : LCCR3_VrtSnchL) |
  865. // LCCR3_ACBsCntOff;
  867. // if (pcd)
  868. // new_regs.lccr3 |= LCCR3_PixClkDiv(pcd);
  870. DPRINTK("nlccr0 = 0x%08xn", new_regs.lccr0);
  871. DPRINTK("nlccr1 = 0x%08xn", new_regs.lccr1);
  872. DPRINTK("nlccr2 = 0x%08xn", new_regs.lccr2);
  873. DPRINTK("nlccr3 = 0x%08xn", new_regs.lccr3);
  875. /* Update shadow copy atomically */
  876. local_irq_save(flags);
  878. /* setup dma descriptors */
  879. fbi->dmadesc_fblow_cpu = (struct pxafb_dma_descriptor *)((unsigned int)fbi->palette_cpu - 3*16);
  880. fbi->dmadesc_fbhigh_cpu = (struct pxafb_dma_descriptor *)((unsigned int)fbi->palette_cpu - 2*16);
  881. fbi->dmadesc_palette_cpu = (struct pxafb_dma_descriptor *)((unsigned int)fbi->palette_cpu - 1*16);
  883. fbi->dmadesc_fblow_dma = fbi->palette_dma - 3*16;
  884. fbi->dmadesc_fbhigh_dma = fbi->palette_dma - 2*16;
  885. fbi->dmadesc_palette_dma = fbi->palette_dma - 1*16;
  888. DPRINTK("fbi->dmadesc_fblow_cpu = 0x%xn", fbi->dmadesc_fblow_cpu);
  889. DPRINTK("fbi->dmadesc_fbhigh_cpu = 0x%xn", fbi->dmadesc_fbhigh_cpu);
  890. DPRINTK("fbi->dmadesc_palette_cpu = 0x%xn", fbi->dmadesc_palette_cpu);
  891. DPRINTK("fbi->dmadesc_fblow_dma = 0x%xn", fbi->dmadesc_fblow_dma);
  892. DPRINTK("fbi->dmadesc_fbhigh_dma = 0x%xn", fbi->dmadesc_fbhigh_dma);
  893. DPRINTK("fbi->dmadesc_palette_dma = 0x%xn", fbi->dmadesc_palette_dma);
  895. DPRINTK("fbi->dmadesc_fblow_cpu->fdadr = 0x%xn", fbi->dmadesc_fblow_cpu->fdadr);
  896. DPRINTK("fbi->dmadesc_fbhigh_cpu->fdadr = 0x%xn", fbi->dmadesc_fbhigh_cpu->fdadr);
  897. DPRINTK("fbi->dmadesc_palette_cpu->fdadr = 0x%xn", fbi->dmadesc_palette_cpu->fdadr);
  899. DPRINTK("fbi->dmadesc_fblow_cpu->fsadr = 0x%xn", fbi->dmadesc_fblow_cpu->fsadr);
  900. DPRINTK("fbi->dmadesc_fbhigh_cpu->fsadr = 0x%xn", fbi->dmadesc_fbhigh_cpu->fsadr);
  901. DPRINTK("fbi->dmadesc_palette_cpu->fsadr = 0x%xn", fbi->dmadesc_palette_cpu->fsadr);
  903. DPRINTK("fbi->dmadesc_fblow_cpu->ldcmd = 0x%xn", fbi->dmadesc_fblow_cpu->ldcmd);
  904. DPRINTK("fbi->dmadesc_fbhigh_cpu->ldcmd = 0x%xn", fbi->dmadesc_fbhigh_cpu->ldcmd);
  905. DPRINTK("fbi->dmadesc_palette_cpu->ldcmd = 0x%xn", fbi->dmadesc_palette_cpu->ldcmd);
  907. #define BYTES_PER_PANEL ((fbi->lccr0 & LCCR0_SDS) ? (var->xres * var->yres * var->bits_per_pixel / 8 / 2) : 
  908.                                     (var->xres * var->yres * var->bits_per_pixel / 8))
  910. /* populate descriptors */
  911. fbi->dmadesc_fblow_cpu->fdadr = fbi->dmadesc_fblow_dma;
  912. fbi->dmadesc_fblow_cpu->fsadr = fbi->screen_dma + BYTES_PER_PANEL;
  913. fbi->dmadesc_fblow_cpu->ldcmd = BYTES_PER_PANEL;
  915. fbi->dmadesc_fbhigh_cpu->fdadr = fbi->dmadesc_palette_dma;
  916. fbi->dmadesc_fbhigh_cpu->fsadr = fbi->screen_dma;
  917. fbi->dmadesc_fbhigh_cpu->ldcmd = BYTES_PER_PANEL;
  919. fbi->dmadesc_palette_cpu->fdadr = fbi->dmadesc_fbhigh_dma;
  920. fbi->dmadesc_palette_cpu->fsadr = fbi->palette_dma;
  921. fbi->dmadesc_palette_cpu->ldcmd = (fbi->palette_size * 2) | LDCMD_PAL;
  923. fbi->fdadr0 = fbi->dmadesc_palette_dma;
  924. fbi->fdadr1 = fbi->dmadesc_fblow_dma;
  926. fbi->reg_lccr0 = new_regs.lccr0;
  927. fbi->reg_lccr1 = new_regs.lccr1;
  928. fbi->reg_lccr2 = new_regs.lccr2;
  929. fbi->reg_lccr3 = new_regs.lccr3;
  930. local_irq_restore(flags);
  932. /*
  933.  * Only update the registers if the controller is enabled
  934.  * and something has changed.
  935.  */
  936. if ((LCCR0 != fbi->reg_lccr0)       || (LCCR1 != fbi->reg_lccr1) ||
  937.     (LCCR2 != fbi->reg_lccr2)       || (LCCR3 != fbi->reg_lccr3) ||
  938.     (FDADR0 != fbi->fdadr0) || (FDADR1 != fbi->fdadr1))
  939. pxafb_schedule_task(fbi, C_REENABLE);
  941. return 0;
  942. }
  944. /*
  945.  * NOTE!  The following functions are purely helpers for set_ctrlr_state.
  946.  * Do not call them directly; set_ctrlr_state does the correct serialisation
  947.  * to ensure that things happen in the right way 100% of time time.
  948.  * -- rmk
  949.  */
  951. /*
  952.  * FIXME: move LCD power stuff into pxafb_power_up_lcd()
  953.  * Also, I'm expecting that the backlight stuff should
  954.  * be handled differently.
  955.  */
  956. static void pxafb_backlight_on(struct pxafb_info *fbi)
  957. {
  958. DPRINTK("backlight onn");
  960. #ifdef CONFIG_ARCH_PXA_IDP
  961. if(machine_is_pxa_idp()) {
  962. FB_BACKLIGHT_ON();
  963. }
  964. #endif
  965. }
  967. /*
  968.  * FIXME: move LCD power stuf into pxafb_power_down_lcd()
  969.  * Also, I'm expecting that the backlight stuff should
  970.  * be handled differently.
  971.  */
  972. static void pxafb_backlight_off(struct pxafb_info *fbi)
  973. {
  974. DPRINTK("backlight offn");
  976. #ifdef CONFIG_ARCH_PXA_IDP
  977. if(machine_is_pxa_idp()) {
  978. FB_BACKLIGHT_OFF();
  979. }
  980. #endif
  982. }
  984. static void pxafb_power_up_lcd(struct pxafb_info *fbi)
  985. {
  986. DPRINTK("LCD power onn");
  987. CKEN |= CKEN16_LCD;
  989. #if CONFIG_ARCH_PXA_IDP
  990. /* set GPIOs, etc */
  991. if(machine_is_pxa_idp()) {
  992. // FIXME need to add proper delays
  993. FB_PWR_ON();
  994. FB_VLCD_ON(); // FIXME this should be after scanning starts
  995. }
  996. #endif
  997. }
  999. static void pxafb_power_down_lcd(struct pxafb_info *fbi)
  1000. {
  1001. DPRINTK("LCD power offn");
  1002. CKEN &= ~CKEN16_LCD;
  1004. /* set GPIOs, etc */
  1005. #if CONFIG_ARCH_PXA_IDP
  1006. if(machine_is_pxa_idp()) {
  1007. // FIXME need to add proper delays
  1008. FB_PWR_OFF();
  1009. FB_VLCD_OFF(); // FIXME this should be before scanning stops
  1010. }
  1011. #endif
  1013. }
  1015. static void pxafb_setup_gpio(struct pxafb_info *fbi)
  1016. {
  1017. unsigned int lccr0;
  1019. /*
  1020.  * setup is based on type of panel supported
  1021.  */
  1023. lccr0 = fbi->lccr0;
  1025. /* 4 bit interface */
  1026. if ((lccr0 & LCCR0_CMS) && (lccr0 & LCCR0_SDS) && !(lccr0 & LCCR0_DPD))
  1027. {
  1028. // bits 58-61
  1029. GPDR1 |= (0xf << 26);
  1030. GAFR1_U = (GAFR1_U & (0xff << 20)) | (0xaa << 20);
  1032. // bits 74-77
  1033. GPDR2 |= (0xf << 10);
  1034. GAFR2_L = (0xaa << 20);
  1035. }
  1037. /* 8 bit interface */
  1038. else if (((lccr0 & LCCR0_CMS) && ((lccr0 & LCCR0_SDS) || (lccr0 & LCCR0_DPD))) ||
  1039.  (!(lccr0 & LCCR0_CMS) && !(lccr0 & LCCR0_PAS) && !(lccr0 & LCCR0_SDS)))
  1040. {
  1041. GPDR1 |= (0x3f << 26);
  1042. GPDR2 |= (0x3);
  1044. GAFR1_U = (GAFR1_U & (0xfff << 20)) | (0x2aa << 20);
  1045. GAFR2_L = (GAFR2_L & 0xf) + (0xa);
  1047. // bits 74-77
  1048. GPDR2 |= (0xf << 10);
  1049. GAFR2_L |= (0xaa << 20);
  1050. }
  1052. /* 16 bit interface */
  1053. else if (!(lccr0 & LCCR0_CMS) && ((lccr0 & LCCR0_SDS) || (lccr0 & LCCR0_PAS)))
  1054. {
  1055. GPDR1 |= 0xFC000000;
  1056. GPDR2 |= 0x00003FFF;
  1058. GAFR1_U = (GAFR1_U & 0x000FFFFF) | 0xAAA00000;
  1059. GAFR2_L = (GAFR2_L & 0xF0000000) | 0x0AAAAAAA;
  1060. }
  1061. }
  1063. static void pxafb_enable_controller(struct pxafb_info *fbi)
  1064. {
  1065. DPRINTK("Enabling LCD controllern");
  1067. /* Sequence from 11.7.10 */
  1068. LCCR3 = fbi->reg_lccr3;
  1069. LCCR2 = fbi->reg_lccr2;
  1070. LCCR1 = fbi->reg_lccr1;
  1071. LCCR0 = fbi->reg_lccr0 & ~LCCR0_ENB;
  1073. /* FIXME we used to have LCD power control here */
  1075. FDADR0 = fbi->fdadr0;
  1076. FDADR1 = fbi->fdadr1;
  1077. LCCR0 |= LCCR0_ENB;
  1079. DPRINTK("FDADR0 = 0x%08xn", (unsigned int)FDADR0);
  1080. DPRINTK("FDADR1 = 0x%08xn", (unsigned int)FDADR1);
  1081. DPRINTK("LCCR0 = 0x%08xn", (unsigned int)LCCR0);
  1082. DPRINTK("LCCR1 = 0x%08xn", (unsigned int)LCCR1);
  1083. DPRINTK("LCCR2 = 0x%08xn", (unsigned int)LCCR2);
  1084. DPRINTK("LCCR3 = 0x%08xn", (unsigned int)LCCR3);
  1085. }
  1087. static void pxafb_disable_controller(struct pxafb_info *fbi)
  1088. {
  1089. DECLARE_WAITQUEUE(wait, current);
  1091. DPRINTK("Disabling LCD controllern");
  1093. /* FIXME add power down GPIO stuff here */
  1095. add_wait_queue(&fbi->ctrlr_wait, &wait);
  1096. set_current_state(TASK_UNINTERRUPTIBLE);
  1098. LCSR = 0xffffffff; /* Clear LCD Status Register */
  1099. LCCR0 &= ~LCCR0_LDM; /* Enable LCD Disable Done Interrupt */
  1100. enable_irq(IRQ_LCD); /* Enable LCD IRQ */
  1101. LCCR0 &= ~LCCR0_ENB; /* Disable LCD Controller */
  1103. schedule_timeout(20 * HZ / 1000);
  1104. current->state = TASK_RUNNING;
  1105. remove_wait_queue(&fbi->ctrlr_wait, &wait);
  1106. }
  1108. /*
  1109.  *  pxafb_handle_irq: Handle 'LCD DONE' interrupts.
  1110.  */
  1111. static void pxafb_handle_irq(int irq, void *dev_id, struct pt_regs *regs)
  1112. {
  1113. struct pxafb_info *fbi = dev_id;
  1114. unsigned int lcsr = LCSR;
  1116. if (lcsr & LCSR_LDD) {
  1117. LCCR0 |= LCCR0_LDM;
  1118. wake_up(&fbi->ctrlr_wait);
  1119. }
  1121. LCSR = lcsr;
  1122. }
  1124. /*
  1125.  * This function must be called from task context only, since it will
  1126.  * sleep when disabling the LCD controller, or if we get two contending
  1127.  * processes trying to alter state.
  1128.  */
  1129. static void set_ctrlr_state(struct pxafb_info *fbi, u_int state)
  1130. {
  1131. u_int old_state;
  1133. down(&fbi->ctrlr_sem);
  1135. old_state = fbi->state;
  1137. switch (state) {
  1138. case C_DISABLE_CLKCHANGE:
  1139. /*
  1140.  * Disable controller for clock change.  If the
  1141.  * controller is already disabled, then do nothing.
  1142.  */
  1143. if (old_state != C_DISABLE) {
  1144. fbi->state = state;
  1145. pxafb_disable_controller(fbi);
  1146. }
  1147. break;
  1149. case C_DISABLE:
  1150. /*
  1151.  * Disable controller
  1152.  */
  1153. if (old_state != C_DISABLE) {
  1154. fbi->state = state;
  1156. pxafb_backlight_off(fbi);
  1157. if (old_state != C_DISABLE_CLKCHANGE)
  1158. pxafb_disable_controller(fbi);
  1159. pxafb_power_down_lcd(fbi);
  1160. }
  1161. break;
  1163. case C_ENABLE_CLKCHANGE:
  1164. /*
  1165.  * Enable the controller after clock change.  Only
  1166.  * do this if we were disabled for the clock change.
  1167.  */
  1168. if (old_state == C_DISABLE_CLKCHANGE) {
  1169. fbi->state = C_ENABLE;
  1170. pxafb_enable_controller(fbi);
  1171. }
  1172. break;
  1174. case C_REENABLE:
  1175. /*
  1176.  * Re-enable the controller only if it was already
  1177.  * enabled.  This is so we reprogram the control
  1178.  * registers.
  1179.  */
  1180. if (old_state == C_ENABLE) {
  1181. pxafb_disable_controller(fbi);
  1182. pxafb_setup_gpio(fbi);
  1183. pxafb_enable_controller(fbi);
  1184. }
  1185. break;
  1187. case C_ENABLE:
  1188. /*
  1189.  * Power up the LCD screen, enable controller, and
  1190.  * turn on the backlight.
  1191.  */
  1192. if (old_state != C_ENABLE) {
  1193. fbi->state = C_ENABLE;
  1194. pxafb_setup_gpio(fbi);
  1195. pxafb_power_up_lcd(fbi);
  1196. pxafb_enable_controller(fbi);
  1197. pxafb_backlight_on(fbi);
  1198. }
  1199. break;
  1200. }
  1201. up(&fbi->ctrlr_sem);
  1202. }
  1204. /*
  1205.  * Our LCD controller task (which is called when we blank or unblank)
  1206.  * via keventd.
  1207.  */
  1208. static void pxafb_task(void *dummy)
  1209. {
  1210. struct pxafb_info *fbi = dummy;
  1211. u_int state = xchg(&fbi->task_state, -1);
  1213. set_ctrlr_state(fbi, state);
  1214. }
  1216. #ifdef CONFIG_CPU_FREQ
  1217. /*
  1218.  * CPU clock speed change handler.  We need to adjust the LCD timing
  1219.  * parameters when the CPU clock is adjusted by the power management
  1220.  * subsystem.
  1221.  */
  1222. static int
  1223. pxafb_clkchg_notifier(struct notifier_block *nb, unsigned long val,
  1224.  void *data)
  1225. {
  1226. struct pxafb_info *fbi = TO_INF(nb, clockchg);
  1227. u_int pcd;
  1229. switch (val) {
  1230. case CPUFREQ_MINMAX:
  1231. /* todo: fill in min/max values */
  1232. break;
  1234. case CPUFREQ_PRECHANGE:
  1235. set_ctrlr_state(fbi, C_DISABLE_CLKCHANGE);
  1236. break;
  1238. case CPUFREQ_POSTCHANGE:
  1239. pcd = get_pcd(fbi->fb.var.pixclock);
  1240. fbi->reg_lccr3 = (fbi->reg_lccr3 & ~0xff) | LCCR3_PixClkDiv(pcd);
  1241. set_ctrlr_state(fbi, C_ENABLE_CLKCHANGE);
  1242. break;
  1243. }
  1244. return 0;
  1245. }
  1246. #endif
  1248. #ifdef CONFIG_PM
  1249. /*
  1250.  * Power management hook.  Note that we won't be called from IRQ context,
  1251.  * unlike the blank functions above, so we may sleep.
  1252.  */
  1253. static int
  1254. pxafb_pm_callback(struct pm_dev *pm_dev, pm_request_t req, void *data)
  1255. {
  1256. struct pxafb_info *fbi = pm_dev->data;
  1258. DPRINTK("pm_callback: %dn", req);
  1260. if (req == PM_SUSPEND || req == PM_RESUME) {
  1261. int state = (int)data;
  1263. if (state == 0) {
  1264. /* Enter D0. */
  1265. set_ctrlr_state(fbi, C_ENABLE);
  1266. } else {
  1267. /* Enter D1-D3.  Disable the LCD controller.  */
  1268. set_ctrlr_state(fbi, C_DISABLE);
  1269. }
  1270. }
  1271. DPRINTK("donen");
  1272. return 0;
  1273. }
  1274. #endif
  1276. /*
  1277.  * pxafb_map_video_memory():
  1278.  *      Allocates the DRAM memory for the frame buffer.  This buffer is  
  1279.  * remapped into a non-cached, non-buffered, memory region to  
  1280.  *      allow palette and pixel writes to occur without flushing the 
  1281.  *      cache.  Once this area is remapped, all virtual memory
  1282.  *      access to the video memory should occur at the new region.
  1283.  */
  1284. static int __init pxafb_map_video_memory(struct pxafb_info *fbi)
  1285. {
  1286. u_long palette_mem_size;
  1288. /*
  1289.  * We reserve one page for the palette, plus the size
  1290.  * of the framebuffer.
  1291.  *
  1292.  * layout of stuff in memory
  1293.  *
  1294.  *                fblow descriptor
  1295.  *                fbhigh descriptor
  1296.  *                palette descriptor
  1297.  *                palette
  1298.  *   page boundary->
  1299.  *                frame buffer
  1300.  */
  1301. fbi->map_size = PAGE_ALIGN(fbi->fb.fix.smem_len + PAGE_SIZE);
  1302. fbi->map_cpu = consistent_alloc(GFP_KERNEL, fbi->map_size,
  1303. &fbi->map_dma);
  1305. if (fbi->map_cpu) {
  1306. fbi->screen_cpu = fbi->map_cpu + PAGE_SIZE;
  1307. fbi->screen_dma = fbi->map_dma + PAGE_SIZE;
  1308. fbi->fb.fix.smem_start = fbi->screen_dma;
  1310. fbi->palette_size = fbi->fb.var.bits_per_pixel == 8 ? 256 : 16;
  1312. palette_mem_size = fbi->palette_size * sizeof(u16);
  1314. DPRINTK("palette_mem_size = 0x%08lxn", (u_long) palette_mem_size);
  1316. fbi->palette_cpu = (u16 *)(fbi->map_cpu + PAGE_SIZE - palette_mem_size);
  1317. fbi->palette_dma = fbi->map_dma + PAGE_SIZE - palette_mem_size;
  1319. }
  1321. return fbi->map_cpu ? 0 : -ENOMEM;
  1322. }
  1324. /* Fake monspecs to fill in fbinfo structure */
  1325. static struct fb_monspecs monspecs __initdata = {
  1326. 30000, 70000, 50, 65, 0 /* Generic */
  1327. };
  1330. static struct pxafb_info * __init pxafb_init_fbinfo(void)
  1331. {
  1332. struct pxafb_mach_info *inf;
  1333. struct pxafb_info *fbi;
  1335. fbi = kmalloc(sizeof(struct pxafb_info) + sizeof(struct display) +
  1336.       sizeof(u16) * 16, GFP_KERNEL);
  1337. if (!fbi)
  1338. return NULL;
  1340. memset(fbi, 0, sizeof(struct pxafb_info) + sizeof(struct display));
  1342. fbi->currcon = -1;
  1344. strcpy(fbi->fb.fix.id, PXA_NAME);
  1346. fbi->fb.fix.type = FB_TYPE_PACKED_PIXELS;
  1347. fbi->fb.fix.type_aux = 0;
  1348. fbi->fb.fix.xpanstep = 0;
  1349. fbi->fb.fix.ypanstep = 0;
  1350. fbi->fb.fix.ywrapstep = 0;
  1351. fbi->fb.fix.accel = FB_ACCEL_NONE;
  1353. fbi->fb.var.nonstd = 0;
  1354. fbi->fb.var.activate = FB_ACTIVATE_NOW;
  1355. fbi->fb.var.height = -1;
  1356. fbi->fb.var.width = -1;
  1357. fbi->fb.var.accel_flags = 0;
  1358. fbi->fb.var.vmode = FB_VMODE_NONINTERLACED;
  1360. strcpy(fbi->fb.modename, PXA_NAME);
  1361. strcpy(fbi->fb.fontname, "Acorn8x8");
  1363. fbi->fb.fbops = &pxafb_ops;
  1364. fbi->fb.changevar = NULL;
  1365. fbi->fb.switch_con = pxafb_switch;
  1366. fbi->fb.updatevar = pxafb_updatevar;
  1367. fbi->fb.blank = pxafb_blank;
  1368. fbi->fb.flags = FBINFO_FLAG_DEFAULT;
  1369. fbi->fb.node = -1;
  1370. fbi->fb.monspecs = monspecs;
  1371. fbi->fb.disp = (struct display *)(fbi + 1);
  1372. fbi->fb.pseudo_palette = (void *)(fbi->fb.disp + 1);
  1374. fbi->rgb[RGB_8] = &rgb_8;
  1375. fbi->rgb[RGB_16] = &def_rgb_16;
  1377. inf = pxafb_get_machine_info(fbi);
  1379. fbi->max_xres = inf->xres;
  1380. fbi->fb.var.xres = inf->xres;
  1381. fbi->fb.var.xres_virtual = inf->xres;
  1382. fbi->max_yres = inf->yres;
  1383. fbi->fb.var.yres = inf->yres;
  1384. fbi->fb.var.yres_virtual = inf->yres;
  1385. fbi->max_bpp = inf->bpp;
  1386. fbi->fb.var.bits_per_pixel = inf->bpp;
  1387. fbi->fb.var.pixclock = inf->pixclock;
  1388. fbi->fb.var.hsync_len = inf->hsync_len;
  1389. fbi->fb.var.left_margin = inf->left_margin;
  1390. fbi->fb.var.right_margin = inf->right_margin;
  1391. fbi->fb.var.vsync_len = inf->vsync_len;
  1392. fbi->fb.var.upper_margin = inf->upper_margin;
  1393. fbi->fb.var.lower_margin = inf->lower_margin;
  1394. fbi->fb.var.sync = inf->sync;
  1395. fbi->fb.var.grayscale = inf->cmap_greyscale;
  1396. fbi->cmap_inverse = inf->cmap_inverse;
  1397. fbi->cmap_static = inf->cmap_static;
  1398. fbi->lccr0 = inf->lccr0;
  1399. fbi->lccr3 = inf->lccr3;
  1400. fbi->state = C_DISABLE;
  1401. fbi->task_state = (u_char)-1;
  1402. fbi->fb.fix.smem_len = fbi->max_xres * fbi->max_yres *
  1403.   fbi->max_bpp / 8;
  1405. init_waitqueue_head(&fbi->ctrlr_wait);
  1406. INIT_TQUEUE(&fbi->task, pxafb_task, fbi);
  1407. init_MUTEX(&fbi->ctrlr_sem);
  1409. return fbi;
  1410. }
  1412. int __init pxafb_init(void)
  1413. {
  1414. struct pxafb_info *fbi;
  1415. int ret;
  1417. fbi = pxafb_init_fbinfo();
  1418. ret = -ENOMEM;
  1419. if (!fbi)
  1420. goto failed;
  1422. /* Initialize video memory */
  1423. ret = pxafb_map_video_memory(fbi);
  1424. if (ret)
  1425. goto failed;
  1427. ret = request_irq(IRQ_LCD, pxafb_handle_irq, SA_INTERRUPT,
  1428.   "LCD", fbi);
  1429. if (ret) {
  1430. printk(KERN_ERR "pxafb: failed in request_irq: %dn", ret);
  1431. goto failed;
  1432. }
  1434. pxafb_set_var(&fbi->fb.var, -1, &fbi->fb);
  1436. ret = register_framebuffer(&fbi->fb);
  1437. if (ret < 0)
  1438. goto failed;
  1440. #ifdef CONFIG_PM
  1441. /*
  1442.  * Note that the console registers this as well, but we want to
  1443.  * power down the display prior to sleeping.
  1444.  */
  1445. fbi->pm = pm_register(PM_SYS_DEV, PM_SYS_VGA, pxafb_pm_callback);
  1446. if (fbi->pm)
  1447. fbi->pm->data = fbi;
  1448. #endif
  1449. #ifdef CONFIG_CPU_FREQ
  1450. fbi->clockchg.notifier_call = pxafb_clkchg_notifier;
  1451. cpufreq_register_notifier(&fbi->clockchg);
  1452. #endif
  1454. /*
  1455.  * Ok, now enable the LCD controller
  1456.  */
  1457. set_ctrlr_state(fbi, C_ENABLE);
  1459. /* This driver cannot be unloaded at the moment */
  1460. MOD_INC_USE_COUNT;
  1462. return 0;
  1464. failed:
  1465. if (fbi)
  1466. kfree(fbi);
  1467. return ret;
  1468. }
  1470. int __init pxafb_setup(char *options)
  1471. {
  1472. #if 0
  1473. char *this_opt;
  1475. if (!options || !*options)
  1476. return 0;
  1478. for (this_opt = strtok(options, ","); this_opt;
  1479.      this_opt = strtok(NULL, ",")) {
  1481. if (!strncmp(this_opt, "bpp:", 4))
  1482. current_par.max_bpp =
  1483.     simple_strtoul(this_opt + 4, NULL, 0);
  1485. if (!strncmp(this_opt, "lccr0:", 6))
  1486. lcd_shadow.lccr0 =
  1487.     simple_strtoul(this_opt + 6, NULL, 0);
  1488. if (!strncmp(this_opt, "lccr1:", 6)) {
  1489. lcd_shadow.lccr1 =
  1490.     simple_strtoul(this_opt + 6, NULL, 0);
  1491. current_par.max_xres =
  1492.     (lcd_shadow.lccr1 & 0x3ff) + 16;
  1493. }
  1494. if (!strncmp(this_opt, "lccr2:", 6)) {
  1495. lcd_shadow.lccr2 =
  1496.     simple_strtoul(this_opt + 6, NULL, 0);
  1497. current_par.max_yres =
  1498.     (lcd_shadow.
  1499.      lccr0 & LCCR0_SDS) ? ((lcd_shadow.
  1500.     lccr2 & 0x3ff) +
  1501.    1) *
  1502.     2 : ((lcd_shadow.lccr2 & 0x3ff) + 1);
  1503. }
  1504. if (!strncmp(this_opt, "lccr3:", 6))
  1505. lcd_shadow.lccr3 =
  1506.     simple_strtoul(this_opt + 6, NULL, 0);
  1507. }
  1508. #endif
  1509. return 0;
  1511. }