1 /*
2 * linux/drivers/video/sa1100fb.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 * StrongARM 1100 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 * Known problems:
26 * - With the Neponset plugged into an Assabet, LCD powerdown
27 * doesn't work (LCD stays powered up). Therefore we shouldn't
28 * blank the screen.
29 * - We don't limit the CPU clock rate nor the mode selection
30 * according to the available SDRAM bandwidth.
31 *
32 * Other notes:
33 * - Linear grayscale palettes and the kernel.
34 * Such code does not belong in the kernel. The kernel frame buffer
35 * drivers do not expect a linear colourmap, but a colourmap based on
36 * the VT100 standard mapping.
37 *
38 * If your _userspace_ requires a linear colourmap, then the setup of
39 * such a colourmap belongs _in userspace_, not in the kernel. Code
40 * to set the colourmap correctly from user space has been sent to
41 * David Neuer. It's around 8 lines of C code, plus another 4 to
42 * detect if we are using grayscale.
43 *
44 * Code Status:
45 * 1999/04/01:
46 * - Driver appears to be working for Brutus 320x200x8bpp mode. Other
47 * resolutions are working, but only the 8bpp mode is supported.
48 * Changes need to be made to the palette encode and decode routines
49 * to support 4 and 16 bpp modes.
50 * Driver is not designed to be a module. The FrameBuffer is statically
51 * allocated since dynamic allocation of a 300k buffer cannot be
52 * guaranteed.
53 *
54 * 1999/06/17:
55 * - FrameBuffer memory is now allocated at run-time when the
56 * driver is initialized.
57 *
58 * 2000/04/10: Nicolas Pitre <nico@cam.org>
59 * - Big cleanup for dynamic selection of machine type at run time.
60 *
61 * 2000/07/19: Jamey Hicks <jamey@crl.dec.com>
62 * - Support for Bitsy aka Compaq iPAQ H3600 added.
63 *
64 * 2000/08/07: Tak-Shing Chan <tchan.rd@idthk.com>
65 * Jeff Sutherland <jsutherland@accelent.com>
66 * - Resolved an issue caused by a change made to the Assabet's PLD
67 * earlier this year which broke the framebuffer driver for newer
68 * Phase 4 Assabets. Some other parameters were changed to optimize
69 * for the Sharp display.
70 *
71 * 2000/08/09: Kunihiko IMAI <imai@vasara.co.jp>
72 * - XP860 support added
73 *
74 * 2000/08/19: Mark Huang <mhuang@livetoy.com>
75 * - Allows standard options to be passed on the kernel command line
76 * for most common passive displays.
77 *
78 * 2000/08/29:
79 * - s/save_flags_cli/local_irq_save/
80 * - remove unneeded extra save_flags_cli in sa1100fb_enable_lcd_controller
81 *
82 * 2000/10/10: Erik Mouw <J.A.K.Mouw@its.tudelft.nl>
83 * - Updated LART stuff. Fixed some minor bugs.
84 *
85 * 2000/10/30: Murphy Chen <murphy@mail.dialogue.com.tw>
86 * - Pangolin support added
87 *
88 * 2000/10/31: Roman Jordan <jor@hoeft-wessel.de>
89 * - Huw Webpanel support added
90 *
91 * 2000/11/23: Eric Peng <ericpeng@coventive.com>
92 * - Freebird add
93 *
94 * 2001/02/07: Jamey Hicks <jamey.hicks@compaq.com>
95 * Cliff Brake <cbrake@accelent.com>
96 * - Added PM callback
97 *
98 * 2001/05/26: <rmk@arm.linux.org.uk>
99 * - Fix 16bpp so that (a) we use the right colours rather than some
100 * totally random colour depending on what was in page 0, and (b)
101 * we don't de-reference a NULL pointer.
102 * - remove duplicated implementation of consistent_alloc()
103 * - convert dma address types to dma_addr_t
104 * - remove unused 'montype' stuff
105 * - remove redundant zero inits of init_var after the initial
106 * memzero.
107 * - remove allow_modeset (acornfb idea does not belong here)
108 *
109 * 2001/05/28: <rmk@arm.linux.org.uk>
110 * - massive cleanup - move machine dependent data into structures
111 * - I've left various #warnings in - if you see one, and know
112 * the hardware concerned, please get in contact with me.
113 *
114 * 2001/05/31: <rmk@arm.linux.org.uk>
115 * - Fix LCCR1 HSW value, fix all machine type specifications to
116 * keep values in line. (Please check your machine type specs)
117 *
118 * 2001/06/10: <rmk@arm.linux.org.uk>
119 * - Fiddle with the LCD controller from task context only; mainly
120 * so that we can run with interrupts on, and sleep.
121 * - Convert #warnings into #errors. No pain, no gain. ;)
122 *
123 * 2001/06/14: <rmk@arm.linux.org.uk>
124 * - Make the palette BPS value for 12bpp come out correctly.
125 * - Take notice of "greyscale" on any colour depth.
126 * - Make truecolor visuals use the RGB channel encoding information.
127 *
128 * 2001/07/02: <rmk@arm.linux.org.uk>
129 * - Fix colourmap problems.
130 *
131 * 2001/07/13: <abraham@2d3d.co.za>
132 * - Added support for the ICP LCD-Kit01 on LART. This LCD is
133 * manufactured by Prime View, model no V16C6448AB
134 *
135 * 2001/07/23: <rmk@arm.linux.org.uk>
136 * - Hand merge version from handhelds.org CVS tree. See patch
137 * notes for 595/1 for more information.
138 * - Drop 12bpp (it's 16bpp with different colour register mappings).
139 * - This hardware can not do direct colour. Therefore we don't
140 * support it.
141 *
142 * 2001/07/27: <rmk@arm.linux.org.uk>
143 * - Halve YRES on dual scan LCDs.
144 *
145 * 2001/08/22: <rmk@arm.linux.org.uk>
146 * - Add b/w iPAQ pixclock value.
147 *
148 * 2001/10/12: <rmk@arm.linux.org.uk>
149 * - Add patch 681/1 and clean up stork definitions.
150 */
151
152 #include <linux/config.h>
153 #include <linux/module.h>
154 #include <linux/kernel.h>
155 #include <linux/sched.h>
156 #include <linux/errno.h>
157 #include <linux/string.h>
158 #include <linux/interrupt.h>
159 #include <linux/slab.h>
160 #include <linux/fb.h>
161 #include <linux/delay.h>
162 #include <linux/pm.h>
163 #include <linux/init.h>
164 #include <linux/cpufreq.h>
165
166 #include <asm/hardware.h>
167 #include <asm/io.h>
168 #include <asm/irq.h>
169 #include <asm/mach-types.h>
170 #include <asm/uaccess.h>
171 #include <asm/arch/assabet.h>
172
173 #include <video/fbcon.h>
174 #include <video/fbcon-mfb.h>
175 #include <video/fbcon-cfb4.h>
176 #include <video/fbcon-cfb8.h>
177 #include <video/fbcon-cfb16.h>
178
179 /*
180 * enable this if your panel appears to have broken
181 */
182 #undef CHECK_COMPAT
183
184 /*
185 * debugging?
186 */
187 #define DEBUG 0
188 /*
189 * Complain if VAR is out of range.
190 */
191 #define DEBUG_VAR 1
192
193 #undef ASSABET_PAL_VIDEO
194
195 #include "sa1100fb.h"
196
197 void (*sa1100fb_blank_helper)(int blank);
198 EXPORT_SYMBOL(sa1100fb_blank_helper);
199
200
201 #ifdef CHECK_COMPAT
202 static void
sa1100fb_check_shadow(struct sa1100fb_lcd_reg * new_regs,struct fb_var_screeninfo * var,u_int pcd)203 sa1100fb_check_shadow(struct sa1100fb_lcd_reg *new_regs,
204 struct fb_var_screeninfo *var, u_int pcd)
205 {
206 struct sa1100fb_lcd_reg shadow;
207 int different = 0;
208
209 /*
210 * These machines are good machines!
211 */
212 if (machine_is_assabet() || machine_is_h3600())
213 return;
214
215 /*
216 * The following ones are bad, bad, bad.
217 * Please make yours good!
218 */
219 if (machine_is_pangolin()) {
220 DPRINTK("Configuring Pangolin LCD\n");
221 shadow.lccr0 =
222 LCCR0_LEN + LCCR0_Color + LCCR0_LDM +
223 LCCR0_BAM + LCCR0_ERM + LCCR0_Act +
224 LCCR0_LtlEnd + LCCR0_DMADel(0);
225 shadow.lccr1 =
226 LCCR1_DisWdth(var->xres) + LCCR1_HorSnchWdth(64) +
227 LCCR1_BegLnDel(160) + LCCR1_EndLnDel(24);
228 shadow.lccr2 =
229 LCCR2_DisHght(var->yres) + LCCR2_VrtSnchWdth(7) +
230 LCCR2_BegFrmDel(7) + LCCR2_EndFrmDel(1);
231 shadow.lccr3 =
232 LCCR3_PixClkDiv(pcd) + LCCR3_HorSnchH +
233 LCCR3_VrtSnchH + LCCR3_PixFlEdg + LCCR3_OutEnH;
234
235 DPRINTK("pcd = %x, PixCldDiv(pcd)=%x\n",
236 pcd, LCCR3_PixClkDiv(pcd));
237 }
238 if (machine_is_freebird()) {
239 DPRINTK("Configuring Freebird LCD\n");
240 #if 1
241 shadow.lccr0 = 0x00000038;
242 shadow.lccr1 = 0x010108e0;
243 shadow.lccr2 = 0x0000053f;
244 shadow.lccr3 = 0x00000c20;
245 #else
246 shadow.lccr0 =
247 LCCR0_LEN + LCCR0_Color + LCCR0_Sngl +
248 LCCR0_LDM + LCCR0_BAM + LCCR0_ERM + LCCR0_Pas +
249 LCCR0_LtlEnd + LCCR0_DMADel(0);
250 /* Check ,Chester */
251 shadow.lccr1 =
252 LCCR1_DisWdth(var->xres) + LCCR1_HorSnchWdth(5) +
253 LCCR1_BegLnDel(61) + LCCR1_EndLnDel(9);
254 /* Check ,Chester */
255 shadow.lccr2 =
256 LCCR2_DisHght(var->yres) + LCCR2_VrtSnchWdth(1) +
257 LCCR2_BegFrmDel(3) + LCCR2_EndFrmDel(0);
258 /* Check ,Chester */
259 shadow.lccr3 =
260 LCCR3_OutEnH + LCCR3_PixFlEdg + LCCR3_VrtSnchH +
261 LCCR3_HorSnchH + LCCR3_ACBsCntOff +
262 LCCR3_ACBsDiv(2) + LCCR3_PixClkDiv(pcd);
263 #endif
264 }
265 if (machine_is_brutus()) {
266 DPRINTK("Configuring Brutus LCD\n");
267 shadow.lccr0 =
268 LCCR0_LEN + LCCR0_Color + LCCR0_Sngl + LCCR0_Pas +
269 LCCR0_LtlEnd + LCCR0_LDM + LCCR0_BAM + LCCR0_ERM +
270 LCCR0_DMADel(0);
271 shadow.lccr1 =
272 LCCR1_DisWdth(var->xres) + LCCR1_HorSnchWdth(3) +
273 LCCR1_BegLnDel(41) + LCCR1_EndLnDel(101);
274 shadow.lccr2 =
275 LCCR2_DisHght(var->yres) + LCCR2_VrtSnchWdth(1) +
276 LCCR2_BegFrmDel(0) + LCCR2_EndFrmDel(0);
277 shadow.lccr3 =
278 LCCR3_OutEnH + LCCR3_PixRsEdg + LCCR3_VrtSnchH +
279 LCCR3_HorSnchH + LCCR3_ACBsCntOff +
280 LCCR3_ACBsDiv(2) + LCCR3_PixClkDiv(44);
281 }
282 if (machine_is_huw_webpanel()) {
283 DPRINTK("Configuring HuW LCD\n");
284 shadow.lccr0 = LCCR0_LEN + LCCR0_Dual + LCCR0_LDM;
285 shadow.lccr1 = LCCR1_DisWdth(var->xres) +
286 LCCR1_HorSnchWdth(3) +
287 LCCR1_BegLnDel(41) + LCCR1_EndLnDel(101);
288 shadow.lccr2 = 239 + LCCR2_VrtSnchWdth(1);
289 shadow.lccr3 = 8 + LCCR3_OutEnH +
290 LCCR3_PixRsEdg + LCCR3_VrtSnchH +
291 LCCR3_HorSnchH + LCCR3_ACBsCntOff + LCCR3_ACBsDiv(2);
292 }
293 if (machine_is_lart()) {
294 DPRINTK("Configuring LART LCD\n");
295 #if defined LART_GREY_LCD
296 shadow.lccr0 =
297 LCCR0_LEN + LCCR0_Mono + LCCR0_Sngl + LCCR0_Pas +
298 LCCR0_LtlEnd + LCCR0_LDM + LCCR0_BAM + LCCR0_ERM +
299 LCCR0_DMADel(0);
300 shadow.lccr1 =
301 LCCR1_DisWdth(var->xres) + LCCR1_HorSnchWdth(1) +
302 LCCR1_BegLnDel(4) + LCCR1_EndLnDel(2);
303 shadow.lccr2 =
304 LCCR2_DisHght(var->yres) + LCCR2_VrtSnchWdth(1) +
305 LCCR2_BegFrmDel(0) + LCCR2_EndFrmDel(0);
306 shadow.lccr3 =
307 LCCR3_PixClkDiv(34) + LCCR3_ACBsDiv(512) +
308 LCCR3_ACBsCntOff + LCCR3_HorSnchH + LCCR3_VrtSnchH;
309 #endif
310 #if defined LART_COLOR_LCD
311 shadow.lccr0 =
312 LCCR0_LEN + LCCR0_Color + LCCR0_Sngl + LCCR0_Act +
313 LCCR0_LtlEnd + LCCR0_LDM + LCCR0_BAM + LCCR0_ERM +
314 LCCR0_DMADel(0);
315 shadow.lccr1 =
316 LCCR1_DisWdth(var->xres) + LCCR1_HorSnchWdth(2) +
317 LCCR1_BegLnDel(69) + LCCR1_EndLnDel(8);
318 shadow.lccr2 =
319 LCCR2_DisHght(var->yres) + LCCR2_VrtSnchWdth(3) +
320 LCCR2_BegFrmDel(14) + LCCR2_EndFrmDel(4);
321 shadow.lccr3 =
322 LCCR3_PixClkDiv(34) + LCCR3_ACBsDiv(512) +
323 LCCR3_ACBsCntOff + LCCR3_HorSnchL + LCCR3_VrtSnchL +
324 LCCR3_PixFlEdg;
325 #endif
326 #if defined LART_VIDEO_OUT
327 shadow.lccr0 =
328 LCCR0_LEN + LCCR0_Color + LCCR0_Sngl + LCCR0_Act +
329 LCCR0_LtlEnd + LCCR0_LDM + LCCR0_BAM + LCCR0_ERM +
330 LCCR0_DMADel(0);
331 shadow.lccr1 =
332 LCCR1_DisWdth(640) + LCCR1_HorSnchWdth(95) +
333 LCCR1_BegLnDel(40) + LCCR1_EndLnDel(24);
334 shadow.lccr2 =
335 LCCR2_DisHght(480) + LCCR2_VrtSnchWdth(2) +
336 LCCR2_BegFrmDel(32) + LCCR2_EndFrmDel(11);
337 shadow.lccr3 =
338 LCCR3_PixClkDiv(8) + LCCR3_ACBsDiv(512) +
339 LCCR3_ACBsCntOff + LCCR3_HorSnchH + LCCR3_VrtSnchH +
340 LCCR3_PixFlEdg + LCCR3_OutEnL;
341 #endif
342 }
343 if (machine_is_graphicsclient()) {
344 DPRINTK("Configuring GraphicsClient LCD\n");
345 shadow.lccr0 =
346 LCCR0_LEN + LCCR0_Color + LCCR0_Sngl + LCCR0_Act;
347 shadow.lccr1 =
348 LCCR1_DisWdth(var->xres) + LCCR1_HorSnchWdth(9) +
349 LCCR1_EndLnDel(54) + LCCR1_BegLnDel(54);
350 shadow.lccr2 =
351 LCCR2_DisHght(var->yres) + LCCR2_VrtSnchWdth(9) +
352 LCCR2_EndFrmDel(32) + LCCR2_BegFrmDel(24);
353 shadow.lccr3 =
354 LCCR3_PixClkDiv(10) + LCCR3_ACBsDiv(2) +
355 LCCR3_ACBsCntOff + LCCR3_HorSnchL + LCCR3_VrtSnchL;
356 }
357 if (machine_is_omnimeter()) {
358 DPRINTK("Configuring OMNI LCD\n");
359 shadow.lccr0 = LCCR0_LEN | LCCR0_CMS | LCCR0_DPD;
360 shadow.lccr1 =
361 LCCR1_BegLnDel(10) + LCCR1_EndLnDel(10) +
362 LCCR1_HorSnchWdth(1) + LCCR1_DisWdth(var->xres);
363 shadow.lccr2 = LCCR2_DisHght(var->yres);
364 shadow.lccr3 =
365 LCCR3_ACBsDiv(0xFF) + LCCR3_PixClkDiv(44);
366 //jca (GetPCD(25) << LCD3_V_PCD);
367 }
368 if (machine_is_xp860()) {
369 DPRINTK("Configuring XP860 LCD\n");
370 shadow.lccr0 =
371 LCCR0_LEN + LCCR0_Color + LCCR0_Sngl + LCCR0_Act +
372 LCCR0_LtlEnd + LCCR0_LDM + LCCR0_ERM + LCCR0_DMADel(0);
373 shadow.lccr1 =
374 LCCR1_DisWdth(var->xres) +
375 LCCR1_HorSnchWdth(var->hsync_len) +
376 LCCR1_BegLnDel(var->left_margin) +
377 LCCR1_EndLnDel(var->right_margin);
378 shadow.lccr2 =
379 LCCR2_DisHght(var->yres) +
380 LCCR2_VrtSnchWdth(var->vsync_len) +
381 LCCR2_BegFrmDel(var->upper_margin) +
382 LCCR2_EndFrmDel(var->lower_margin);
383 shadow.lccr3 =
384 LCCR3_PixClkDiv(6) + LCCR3_HorSnchL + LCCR3_VrtSnchL;
385 }
386
387 /*
388 * Ok, since we're calculating these values, we want to know
389 * if the calculation is correct. If you see any of these
390 * messages _PLEASE_ report the incident to me for diagnosis,
391 * including details about what was happening when the
392 * messages appeared. --rmk, 30 March 2001
393 */
394 if (shadow.lccr0 != new_regs->lccr0) {
395 printk(KERN_ERR "LCCR1 mismatch: 0x%08x != 0x%08x\n",
396 shadow.lccr1, new_regs->lccr1);
397 different = 1;
398 }
399 if (shadow.lccr1 != new_regs->lccr1) {
400 printk(KERN_ERR "LCCR1 mismatch: 0x%08x != 0x%08x\n",
401 shadow.lccr1, new_regs->lccr1);
402 different = 1;
403 }
404 if (shadow.lccr2 != new_regs->lccr2) {
405 printk(KERN_ERR "LCCR2 mismatch: 0x%08x != 0x%08x\n",
406 shadow.lccr2, new_regs->lccr2);
407 different = 1;
408 }
409 if (shadow.lccr3 != new_regs->lccr3) {
410 printk(KERN_ERR "LCCR3 mismatch: 0x%08x != 0x%08x\n",
411 shadow.lccr3, new_regs->lccr3);
412 different = 1;
413 }
414 if (different) {
415 printk(KERN_ERR "var: xres=%d hslen=%d lm=%d rm=%d\n",
416 var->xres, var->hsync_len,
417 var->left_margin, var->right_margin);
418 printk(KERN_ERR "var: yres=%d vslen=%d um=%d bm=%d\n",
419 var->yres, var->vsync_len,
420 var->upper_margin, var->lower_margin);
421
422 printk(KERN_ERR "Please report this to Russell King "
423 "<rmk@arm.linux.org.uk>\n");
424 }
425
426 DPRINTK("olccr0 = 0x%08x\n", shadow.lccr0);
427 DPRINTK("olccr1 = 0x%08x\n", shadow.lccr1);
428 DPRINTK("olccr2 = 0x%08x\n", shadow.lccr2);
429 DPRINTK("olccr3 = 0x%08x\n", shadow.lccr3);
430 }
431 #else
432 #define sa1100fb_check_shadow(regs,var,pcd)
433 #endif
434
435
436
437 /*
438 * IMHO this looks wrong. In 8BPP, length should be 8.
439 */
440 static struct sa1100fb_rgb rgb_8 = {
441 red: { offset: 0, length: 4, },
442 green: { offset: 0, length: 4, },
443 blue: { offset: 0, length: 4, },
444 transp: { offset: 0, length: 0, },
445 };
446
447 static struct sa1100fb_rgb def_rgb_16 = {
448 red: { offset: 11, length: 5, },
449 green: { offset: 5, length: 6, },
450 blue: { offset: 0, length: 5, },
451 transp: { offset: 0, length: 0, },
452 };
453
454 #ifdef CONFIG_SA1100_ASSABET
455 #ifndef ASSABET_PAL_VIDEO
456 /*
457 * The assabet uses a sharp LQ039Q2DS54 LCD module. It is actually
458 * takes an RGB666 signal, but we provide it with an RGB565 signal
459 * instead (def_rgb_16).
460 */
461 static struct sa1100fb_mach_info lq039q2ds54_info __initdata = {
462 pixclock: 171521, bpp: 16,
463 xres: 320, yres: 240,
464
465 hsync_len: 5, vsync_len: 1,
466 left_margin: 61, upper_margin: 3,
467 right_margin: 9, lower_margin: 0,
468
469 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
470
471 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
472 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2),
473 };
474 #else
475 static struct sa1100fb_mach_info pal_info __initdata = {
476 pixclock: 67797, bpp: 16,
477 xres: 640, yres: 512,
478
479 hsync_len: 64, vsync_len: 6,
480 left_margin: 125, upper_margin: 70,
481 right_margin: 115, lower_margin: 36,
482
483 sync: 0,
484
485 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
486 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(512),
487 };
488 #endif
489 #endif
490
491 #ifdef CONFIG_SA1100_H3600
492 static struct sa1100fb_mach_info h3600_info __initdata = {
493 #ifdef CONFIG_IPAQ_H3100
494 pixclock: 407766, bpp: 4,
495 xres: 320, yres: 240,
496
497 hsync_len: 26, vsync_len: 41,
498 left_margin: 4, upper_margin: 0,
499 right_margin: 4, lower_margin: 0,
500
501 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
502 cmap_greyscale: 1, cmap_static: 1,
503 cmap_inverse: 1,
504
505 lccr0: LCCR0_Mono | LCCR0_4PixMono | LCCR0_Sngl | LCCR0_Pas,
506 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2),
507 #else
508 pixclock: 174757, bpp: 16,
509 xres: 320, yres: 240,
510
511 hsync_len: 3, vsync_len: 3,
512 left_margin: 12, upper_margin: 10,
513 right_margin: 17, lower_margin: 1,
514
515 sync: 0,
516
517 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
518 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2),
519 #endif
520 };
521
522 static struct sa1100fb_rgb h3600_rgb_16 = {
523 red: { offset: 12, length: 4, },
524 green: { offset: 7, length: 4, },
525 blue: { offset: 1, length: 4, },
526 transp: { offset: 0, length: 0, },
527 };
528 #endif
529
530 #ifdef CONFIG_SA1100_BRUTUS
531 static struct sa1100fb_mach_info brutus_info __initdata = {
532 pixclock: 0, bpp: 8,
533 xres: 320, yres: 240,
534
535 hsync_len: 3, vsync_len: 1,
536 left_margin: 41, upper_margin: 0,
537 right_margin: 101, lower_margin: 0,
538
539 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
540
541 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Pas,
542 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2) |
543 LCCR3_PixClkDiv(44),
544 };
545 #endif
546
547 #ifdef CONFIG_SA1100_CERF
548 static struct sa1100fb_mach_info cerf_info __initdata = {
549 #if defined(CONFIG_CERF_LCD_72_A)
550 pixclock: 171521, bpp: 8,
551 xres: 640, yres: 480,
552 lccr0: LCCR0_Color | LCCR0_Dual | LCCR0_Pas,
553 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2) |
554 LCCR3_PixClkDiv(38),
555 #elif defined(CONFIG_CERF_LCD_57_A)
556 pixclock: 171521, bpp: 8,
557 xres: 320, yres: 240,
558 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Pas,
559 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2) |
560 LCCR3_PixClkDiv(38),
561 #elif defined(CONFIG_CERF_LCD_38_A)
562 pixclock: 171521, bpp: 8,
563 xres: 240, yres: 320,
564 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Pas,
565 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(56) |
566 LCCR3_PixClkDiv(38),
567 #elif defined(CONFIG_CERF_LCD_38_B)
568 pixclock: 171521, bpp: 4,
569 xres: 320, yres: 240,
570 lccr0: LCCR0_Mono | LCCR0_4PixMono | LCCR0_Sngl | LCCR0_Pas,
571 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(56) |
572 LCCR3_PixClkDiv(38),
573 #else
574 #error "Must have a CerfBoard LCD form factor selected"
575 #endif
576
577 hsync_len: 5, vsync_len: 1,
578 left_margin: 61, upper_margin: 3,
579 right_margin: 9, lower_margin: 0,
580
581 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
582
583 };
584
585 #if 0
586 static struct sa1100fb_rgb cerf_rgb_16 = {
587 red: { offset: 8, length: 4, },
588 green: { offset: 4, length: 4, },
589 blue: { offset: 0, length: 4, },
590 transp: { offset: 0, length: 0, },
591 };
592 #endif
593 #endif
594
595 #ifdef CONFIG_SA1100_FREEBIRD
596 #warning Please check this carefully
597 static struct sa1100fb_mach_info freebird_info __initdata = {
598 pixclock: 171521, bpp: 16,
599 xres: 240, yres: 320,
600
601 hsync_len: 3, vsync_len: 2,
602 left_margin: 2, upper_margin: 0,
603 right_margin: 2, lower_margin: 0,
604
605 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
606
607 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Pas,
608 lccr3: LCCR3_OutEnH | LCCR3_PixFlEdg | LCCR3_ACBsDiv(2),
609 };
610
611 static struct sa1100fb_rgb freebird_rgb_16 = {
612 red: { offset: 8, length: 4, },
613 green: { offset: 4, length: 4, },
614 blue: { offset: 0, length: 4, },
615 transp: { offset: 12, length: 4, },
616 };
617 #endif
618
619 #ifdef CONFIG_SA1100_GRAPHICSCLIENT
620 static struct sa1100fb_mach_info graphicsclient_info __initdata = {
621 pixclock: 53500, bpp: 8,
622 xres: 640, yres: 480,
623
624 hsync_len: 9, vsync_len: 9,
625 left_margin: 54, upper_margin: 24,
626 right_margin: 54, lower_margin: 32,
627
628 sync: 0,
629
630 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
631 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2),
632 };
633 #endif
634
635 #ifdef CONFIG_SA1100_HUW_WEBPANEL
636 static struct sa1100fb_mach_info huw_webpanel_info __initdata = {
637 pixclock: 0, bpp: 8,
638 xres: 640, yres: 480,
639
640 hsync_len: 3, vsync_len: 1,
641 left_margin: 41, upper_margin: 0,
642 right_margin: 101, lower_margin: 0,
643
644 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
645
646 lccr0: LCCR0_Color | LCCR0_Dual | LCCR0_Pas,
647 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2) | 8,
648 #error FIXME
649 /*
650 * FIXME: please get rid of the '| 8' in preference to an
651 * LCCR3_PixClkDiv() version. --rmk
652 */
653 };
654 #endif
655
656 #ifdef LART_GREY_LCD
657 static struct sa1100fb_mach_info lart_grey_info __initdata = {
658 pixclock: 150000, bpp: 4,
659 xres: 320, yres: 240,
660
661 hsync_len: 1, vsync_len: 1,
662 left_margin: 4, upper_margin: 0,
663 right_margin: 2, lower_margin: 0,
664
665 cmap_greyscale: 1,
666 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
667
668 lccr0: LCCR0_Mono | LCCR0_Sngl | LCCR0_Pas | LCCR0_4PixMono,
669 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(512),
670 };
671 #endif
672 #ifdef LART_COLOR_LCD
673 static struct sa1100fb_mach_info lart_color_info __initdata = {
674 pixclock: 150000, bpp: 16,
675 xres: 320, yres: 240,
676
677 hsync_len: 2, vsync_len: 3,
678 left_margin: 69, upper_margin: 14,
679 right_margin: 8, lower_margin: 4,
680
681 sync: 0,
682
683 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
684 lccr3: LCCR3_OutEnH | LCCR3_PixFlEdg | LCCR3_ACBsDiv(512),
685 };
686 #endif
687 #ifdef LART_VIDEO_OUT
688 static struct sa1100fb_mach_info lart_video_info __initdata = {
689 pixclock: 39721, bpp: 16,
690 xres: 640, yres: 480,
691
692 hsync_len: 95, vsync_len: 2,
693 left_margin: 40, upper_margin: 32,
694 right_margin: 24, lower_margin: 11,
695
696 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
697
698 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
699 lccr3: LCCR3_OutEnL | LCCR3_PixFlEdg | LCCR3_ACBsDiv(512),
700 };
701 #endif
702
703 #ifdef LART_KIT01_LCD
704 static struct sa1100fb_mach_info lart_kit01_info __initdata =
705 {
706 pixclock: 63291, bpp: 16,
707 xres: 640, yres: 480,
708
709 hsync_len: 64, vsync_len: 3,
710 left_margin: 122, upper_margin: 45,
711 right_margin: 10, lower_margin: 10,
712
713 sync: 0,
714
715 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
716 lccr3: LCCR3_OutEnH | LCCR3_PixFlEdg
717 };
718 #endif
719
720 #ifdef CONFIG_SA1100_OMNIMETER
721 static struct sa1100fb_mach_info omnimeter_info __initdata = {
722 pixclock: 0, bpp: 4,
723 xres: 480, yres: 320,
724
725 hsync_len: 1, vsync_len: 1,
726 left_margin: 10, upper_margin: 0,
727 right_margin: 10, lower_margin: 0,
728
729 cmap_greyscale: 1,
730 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
731
732 lccr0: LCCR0_Mono | LCCR0_Sngl | LCCR0_Pas | LCCR0_8PixMono,
733 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(255) |
734 LCCR3_PixClkDiv(44),
735 #error FIXME: fix pixclock, ACBsDiv
736 /*
737 * FIXME: I think ACBsDiv is wrong above - should it be 512 (disabled)?
738 * - rmk
739 */
740 };
741 #endif
742
743 #ifdef CONFIG_SA1100_PANGOLIN
744 static struct sa1100fb_mach_info pangolin_info __initdata = {
745 pixclock: 341521, bpp: 16,
746 xres: 800, yres: 600,
747
748 hsync_len: 64, vsync_len: 7,
749 left_margin: 160, upper_margin: 7,
750 right_margin: 24, lower_margin: 1,
751
752 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
753
754 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
755 lccr3: LCCR3_OutEnH | LCCR3_PixFlEdg,
756 };
757 #endif
758
759 #ifdef CONFIG_SA1100_STORK
760 #if STORK_TFT /* ie the NEC TFT */
761 /*
762 * pixclock is ps per clock. say 72Hz, 800x600 clocks => (1/72)/(800*600)
763 * = 28935 and a bit
764 * NB likely to be increased to ease bus timings wrt pcmcia interface
765 */
766 static struct sa1100fb_mach_info stork_tft_info __initdata = {
767 pixclock: 28935, bpp: 16,
768 xres: 640, yres: 480,
769
770 hsync_len: 64, vsync_len: 2,
771 left_margin: 48, upper_margin: 12,
772 right_margin: 48, lower_margin: 31,
773
774 sync: 0,
775
776 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
777 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg,
778 };
779
780 static struct sa1100fb_rgb stork_tft_rgb_16 = {
781 red: { offset: 11, length: 5, },
782 green: { offset: 5, length: 6, },
783 blue: { offset: 0, length: 5, },
784 transp: { offset: 0, length: 0, },
785 };
786
787 #else /* Kyocera DSTN */
788
789 static struct sa1100fb_mach_info stork_dstn_info __initdata = {
790 pixclock: 0, bpp: 16,
791 xres: 640, yres: 480,
792
793 hsync_len: 2, vsync_len: 2,
794 left_margin: 2, upper_margin: 0,
795 right_margin: 2, lower_margin: 0,
796
797 sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT ,
798
799 lccr0: LCCR0_Color | LCCR0_Dual | LCCR0_Pas,
800 #error Fixme
801 lccr3: 0xff00 |
802 0x18 /* ought to be 0x14 but DMA isn't up to that as yet */
803 };
804
805 static struct sa1100fb_rgb stork_dstn_rgb_16 = {
806 red: { offset: 8, length: 4, },
807 green: { offset: 4, length: 4, },
808 blue: { offset: 0, length: 4, },
809 transp: { offset: 0, length: 0, },
810 };
811 #endif
812 #endif
813
814 #ifdef CONFIG_SA1100_XP860
815 static struct sa1100fb_mach_info xp860_info __initdata = {
816 pixclock: 0, bpp: 8,
817 xres: 1024, yres: 768,
818
819 hsync_len: 3, vsync_len: 3,
820 left_margin: 3, upper_margin: 2,
821 right_margin: 2, lower_margin: 1,
822
823 sync: 0,
824
825 lccr0: LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
826 lccr3: LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_PixClkDiv(6),
827 };
828 #endif
829
830
831
832 static struct sa1100fb_mach_info * __init
sa1100fb_get_machine_info(struct sa1100fb_info * fbi)833 sa1100fb_get_machine_info(struct sa1100fb_info *fbi)
834 {
835 struct sa1100fb_mach_info *inf = NULL;
836
837 /*
838 * R G B T
839 * default {11,5}, { 5,6}, { 0,5}, { 0,0}
840 * h3600 {12,4}, { 7,4}, { 1,4}, { 0,0}
841 * freebird { 8,4}, { 4,4}, { 0,4}, {12,4}
842 */
843 #ifdef CONFIG_SA1100_ASSABET
844 if (machine_is_assabet()) {
845 #ifndef ASSABET_PAL_VIDEO
846 inf = &lq039q2ds54_info;
847 #else
848 inf = &pal_info;
849 #endif
850 }
851 #endif
852 #ifdef CONFIG_SA1100_H3600
853 if (machine_is_h3600()) {
854 inf = &h3600_info;
855 fbi->rgb[RGB_16] = &h3600_rgb_16;
856 }
857 #endif
858 #ifdef CONFIG_SA1100_BRUTUS
859 if (machine_is_brutus()) {
860 inf = &brutus_info;
861 }
862 #endif
863 #ifdef CONFIG_SA1100_CERF
864 if (machine_is_cerf()) {
865 inf = &cerf_info;
866 }
867 #endif
868 #ifdef CONFIG_SA1100_FREEBIRD
869 if (machine_is_freebird()) {
870 inf = &freebird_info;
871 fbi->rgb[RGB_16] = &freebird_rgb16;
872 }
873 #endif
874 #ifdef CONFIG_SA1100_GRAPHICSCLIENT
875 if (machine_is_graphicsclient()) {
876 inf = &graphicsclient_info;
877 }
878 #endif
879 #ifdef CONFIG_SA1100_HUW_WEBPANEL
880 if (machine_is_huw_webpanel()) {
881 inf = &huw_webpanel_info;
882 }
883 #endif
884 #ifdef CONFIG_SA1100_LART
885 if (machine_is_lart()) {
886 #ifdef LART_GREY_LCD
887 inf = &lart_grey_info;
888 #endif
889 #ifdef LART_COLOR_LCD
890 inf = &lart_color_info;
891 #endif
892 #ifdef LART_VIDEO_OUT
893 inf = &lart_video_info;
894 #endif
895 #ifdef LART_KIT01_LCD
896 inf = &lart_kit01_info;
897 #endif
898 }
899 #endif
900 #ifdef CONFIG_SA1100_OMNIMETER
901 if (machine_is_omnimeter()) {
902 inf = &omnimeter_info;
903 }
904 #endif
905 #ifdef CONFIG_SA1100_PANGOLIN
906 if (machine_is_pangolin()) {
907 inf = &pangolin_info;
908 }
909 #endif
910 #ifdef CONFIG_SA1100_XP860
911 if (machine_is_xp860()) {
912 inf = &xp860_info;
913 }
914 #endif
915 #ifdef CONFIG_SA1100_STORK
916 if (machine_is_stork()) {
917 #if STORK_TFT
918 inf = &stork_tft_info;
919 fbi->rgb[RGB_16] = &stork_tft_rgb_16;
920 #else
921 inf = &stork_dstn_info;
922 fbi->rgb[RGB_16] = &stork_dstn_rgb_16;
923 #endif
924 }
925 #endif
926 return inf;
927 }
928
929 static int sa1100fb_activate_var(struct fb_var_screeninfo *var, struct sa1100fb_info *);
930 static void set_ctrlr_state(struct sa1100fb_info *fbi, u_int state);
931
sa1100fb_schedule_task(struct sa1100fb_info * fbi,u_int state)932 static inline void sa1100fb_schedule_task(struct sa1100fb_info *fbi, u_int state)
933 {
934 unsigned long flags;
935
936 local_irq_save(flags);
937 /*
938 * We need to handle two requests being made at the same time.
939 * There are two important cases:
940 * 1. When we are changing VT (C_REENABLE) while unblanking (C_ENABLE)
941 * We must perform the unblanking, which will do our REENABLE for us.
942 * 2. When we are blanking, but immediately unblank before we have
943 * blanked. We do the "REENABLE" thing here as well, just to be sure.
944 */
945 if (fbi->task_state == C_ENABLE && state == C_REENABLE)
946 state = (u_int) -1;
947 if (fbi->task_state == C_DISABLE && state == C_ENABLE)
948 state = C_REENABLE;
949
950 if (state != (u_int)-1) {
951 fbi->task_state = state;
952 schedule_task(&fbi->task);
953 }
954 local_irq_restore(flags);
955 }
956
957 /*
958 * Get the VAR structure pointer for the specified console
959 */
get_con_var(struct fb_info * info,int con)960 static inline struct fb_var_screeninfo *get_con_var(struct fb_info *info, int con)
961 {
962 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
963 return (con == fbi->currcon || con == -1) ? &fbi->fb.var : &fb_display[con].var;
964 }
965
966 /*
967 * Get the DISPLAY structure pointer for the specified console
968 */
get_con_display(struct fb_info * info,int con)969 static inline struct display *get_con_display(struct fb_info *info, int con)
970 {
971 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
972 return (con < 0) ? fbi->fb.disp : &fb_display[con];
973 }
974
975 /*
976 * Get the CMAP pointer for the specified console
977 */
get_con_cmap(struct fb_info * info,int con)978 static inline struct fb_cmap *get_con_cmap(struct fb_info *info, int con)
979 {
980 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
981 return (con == fbi->currcon || con == -1) ? &fbi->fb.cmap : &fb_display[con].cmap;
982 }
983
984 static inline u_int
chan_to_field(u_int chan,struct fb_bitfield * bf)985 chan_to_field(u_int chan, struct fb_bitfield *bf)
986 {
987 chan &= 0xffff;
988 chan >>= 16 - bf->length;
989 return chan << bf->offset;
990 }
991
992 /*
993 * Convert bits-per-pixel to a hardware palette PBS value.
994 */
995 static inline u_int
palette_pbs(struct fb_var_screeninfo * var)996 palette_pbs(struct fb_var_screeninfo *var)
997 {
998 int ret = 0;
999 switch (var->bits_per_pixel) {
1000 #ifdef FBCON_HAS_CFB4
1001 case 4: ret = 0 << 12; break;
1002 #endif
1003 #ifdef FBCON_HAS_CFB8
1004 case 8: ret = 1 << 12; break;
1005 #endif
1006 #ifdef FBCON_HAS_CFB16
1007 case 16: ret = 2 << 12; break;
1008 #endif
1009 }
1010 return ret;
1011 }
1012
1013 static int
sa1100fb_setpalettereg(u_int regno,u_int red,u_int green,u_int blue,u_int trans,struct fb_info * info)1014 sa1100fb_setpalettereg(u_int regno, u_int red, u_int green, u_int blue,
1015 u_int trans, struct fb_info *info)
1016 {
1017 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
1018 u_int val, ret = 1;
1019
1020 if (regno < fbi->palette_size) {
1021 val = ((red >> 4) & 0xf00);
1022 val |= ((green >> 8) & 0x0f0);
1023 val |= ((blue >> 12) & 0x00f);
1024
1025 if (regno == 0)
1026 val |= palette_pbs(&fbi->fb.var);
1027
1028 fbi->palette_cpu[regno] = val;
1029 ret = 0;
1030 }
1031 return ret;
1032 }
1033
1034 static int
sa1100fb_setcolreg(u_int regno,u_int red,u_int green,u_int blue,u_int trans,struct fb_info * info)1035 sa1100fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
1036 u_int trans, struct fb_info *info)
1037 {
1038 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
1039 struct display *disp = get_con_display(info, fbi->currcon);
1040 u_int val;
1041 int ret = 1;
1042
1043 /*
1044 * If inverse mode was selected, invert all the colours
1045 * rather than the register number. The register number
1046 * is what you poke into the framebuffer to produce the
1047 * colour you requested.
1048 */
1049 if (disp->inverse) {
1050 red = 0xffff - red;
1051 green = 0xffff - green;
1052 blue = 0xffff - blue;
1053 }
1054
1055 /*
1056 * If greyscale is true, then we convert the RGB value
1057 * to greyscale no mater what visual we are using.
1058 */
1059 if (fbi->fb.var.grayscale)
1060 red = green = blue = (19595 * red + 38470 * green +
1061 7471 * blue) >> 16;
1062
1063 switch (fbi->fb.disp->visual) {
1064 case FB_VISUAL_TRUECOLOR:
1065 /*
1066 * 12 or 16-bit True Colour. We encode the RGB value
1067 * according to the RGB bitfield information.
1068 */
1069 if (regno < 16) {
1070 u16 *pal = fbi->fb.pseudo_palette;
1071
1072 val = chan_to_field(red, &fbi->fb.var.red);
1073 val |= chan_to_field(green, &fbi->fb.var.green);
1074 val |= chan_to_field(blue, &fbi->fb.var.blue);
1075
1076 pal[regno] = val;
1077 ret = 0;
1078 }
1079 break;
1080
1081 case FB_VISUAL_STATIC_PSEUDOCOLOR:
1082 case FB_VISUAL_PSEUDOCOLOR:
1083 ret = sa1100fb_setpalettereg(regno, red, green, blue, trans, info);
1084 break;
1085 }
1086
1087 return ret;
1088 }
1089
1090 /*
1091 * sa1100fb_display_dma_period()
1092 * Calculate the minimum period (in picoseconds) between two DMA
1093 * requests for the LCD controller.
1094 */
1095 static unsigned int
sa1100fb_display_dma_period(struct fb_var_screeninfo * var)1096 sa1100fb_display_dma_period(struct fb_var_screeninfo *var)
1097 {
1098 unsigned int mem_bits_per_pixel;
1099
1100 mem_bits_per_pixel = var->bits_per_pixel;
1101 if (mem_bits_per_pixel == 12)
1102 mem_bits_per_pixel = 16;
1103
1104 /*
1105 * Period = pixclock * bits_per_byte * bytes_per_transfer
1106 * / memory_bits_per_pixel;
1107 */
1108 return var->pixclock * 8 * 16 / mem_bits_per_pixel;
1109 }
1110
1111 /*
1112 * sa1100fb_decode_var():
1113 * Get the video params out of 'var'. If a value doesn't fit, round it up,
1114 * if it's too big, return -EINVAL.
1115 *
1116 * Suggestion: Round up in the following order: bits_per_pixel, xres,
1117 * yres, xres_virtual, yres_virtual, xoffset, yoffset, grayscale,
1118 * bitfields, horizontal timing, vertical timing.
1119 */
1120 static int
sa1100fb_validate_var(struct fb_var_screeninfo * var,struct sa1100fb_info * fbi)1121 sa1100fb_validate_var(struct fb_var_screeninfo *var,
1122 struct sa1100fb_info *fbi)
1123 {
1124 int ret = -EINVAL;
1125
1126 if (var->xres < MIN_XRES)
1127 var->xres = MIN_XRES;
1128 if (var->yres < MIN_YRES)
1129 var->yres = MIN_YRES;
1130 if (var->xres > fbi->max_xres)
1131 var->xres = fbi->max_xres;
1132 if (var->yres > fbi->max_yres)
1133 var->yres = fbi->max_yres;
1134 var->xres_virtual =
1135 var->xres_virtual < var->xres ? var->xres : var->xres_virtual;
1136 var->yres_virtual =
1137 var->yres_virtual < var->yres ? var->yres : var->yres_virtual;
1138
1139 DPRINTK("var->bits_per_pixel=%d\n", var->bits_per_pixel);
1140 switch (var->bits_per_pixel) {
1141 #ifdef FBCON_HAS_CFB4
1142 case 4: ret = 0; break;
1143 #endif
1144 #ifdef FBCON_HAS_CFB8
1145 case 8: ret = 0; break;
1146 #endif
1147 #ifdef FBCON_HAS_CFB16
1148 case 16: ret = 0; break;
1149 #endif
1150 default:
1151 break;
1152 }
1153
1154 #ifdef CONFIG_CPU_FREQ
1155 printk(KERN_DEBUG "dma period = %d ps, clock = %d kHz\n",
1156 sa1100fb_display_dma_period(var),
1157 cpufreq_get(smp_processor_id()));
1158 #endif
1159
1160 return ret;
1161 }
1162
sa1100fb_set_truecolor(u_int is_true_color)1163 static inline void sa1100fb_set_truecolor(u_int is_true_color)
1164 {
1165 DPRINTK("true_color = %d\n", is_true_color);
1166
1167 if (machine_is_assabet()) {
1168 #if 1
1169 // phase 4 or newer Assabet's
1170 if (is_true_color)
1171 ASSABET_BCR_set(ASSABET_BCR_LCD_12RGB);
1172 else
1173 ASSABET_BCR_clear(ASSABET_BCR_LCD_12RGB);
1174 #else
1175 // older Assabet's
1176 if (is_true_color)
1177 ASSABET_BCR_clear(ASSABET_BCR_LCD_12RGB);
1178 else
1179 ASSABET_BCR_set(ASSABET_BCR_LCD_12RGB);
1180 #endif
1181 }
1182 }
1183
1184 static void
sa1100fb_hw_set_var(struct fb_var_screeninfo * var,struct sa1100fb_info * fbi)1185 sa1100fb_hw_set_var(struct fb_var_screeninfo *var, struct sa1100fb_info *fbi)
1186 {
1187 u_long palette_mem_size;
1188
1189 fbi->palette_size = var->bits_per_pixel == 8 ? 256 : 16;
1190
1191 palette_mem_size = fbi->palette_size * sizeof(u16);
1192
1193 DPRINTK("palette_mem_size = 0x%08lx\n", (u_long) palette_mem_size);
1194
1195 fbi->palette_cpu = (u16 *)(fbi->map_cpu + PAGE_SIZE - palette_mem_size);
1196 fbi->palette_dma = fbi->map_dma + PAGE_SIZE - palette_mem_size;
1197
1198 fb_set_cmap(&fbi->fb.cmap, 1, sa1100fb_setcolreg, &fbi->fb);
1199
1200 /* Set board control register to handle new color depth */
1201 sa1100fb_set_truecolor(var->bits_per_pixel >= 16);
1202
1203 #ifdef CONFIG_SA1100_OMNIMETER
1204 #error Do we have to do this here? We already do it at init time.
1205 if (machine_is_omnimeter())
1206 SetLCDContrast(DefaultLCDContrast);
1207 #endif
1208
1209 sa1100fb_activate_var(var, fbi);
1210
1211 fbi->palette_cpu[0] = (fbi->palette_cpu[0] &
1212 0xcfff) | palette_pbs(var);
1213
1214 }
1215
1216 /*
1217 * sa1100fb_set_var():
1218 * Set the user defined part of the display for the specified console
1219 */
1220 static int
sa1100fb_set_var(struct fb_var_screeninfo * var,int con,struct fb_info * info)1221 sa1100fb_set_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
1222 {
1223 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
1224 struct fb_var_screeninfo *dvar = get_con_var(&fbi->fb, con);
1225 struct display *display = get_con_display(&fbi->fb, con);
1226 int err, chgvar = 0, rgbidx;
1227
1228 DPRINTK("set_var\n");
1229
1230 /*
1231 * Decode var contents into a par structure, adjusting any
1232 * out of range values.
1233 */
1234 err = sa1100fb_validate_var(var, fbi);
1235 if (err)
1236 return err;
1237
1238 if (var->activate & FB_ACTIVATE_TEST)
1239 return 0;
1240
1241 if ((var->activate & FB_ACTIVATE_MASK) != FB_ACTIVATE_NOW)
1242 return -EINVAL;
1243
1244 if (dvar->xres != var->xres)
1245 chgvar = 1;
1246 if (dvar->yres != var->yres)
1247 chgvar = 1;
1248 if (dvar->xres_virtual != var->xres_virtual)
1249 chgvar = 1;
1250 if (dvar->yres_virtual != var->yres_virtual)
1251 chgvar = 1;
1252 if (dvar->bits_per_pixel != var->bits_per_pixel)
1253 chgvar = 1;
1254 if (con < 0)
1255 chgvar = 0;
1256
1257 switch (var->bits_per_pixel) {
1258 #ifdef FBCON_HAS_CFB4
1259 case 4:
1260 if (fbi->cmap_static)
1261 display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
1262 else
1263 display->visual = FB_VISUAL_PSEUDOCOLOR;
1264 display->line_length = var->xres / 2;
1265 display->dispsw = &fbcon_cfb4;
1266 rgbidx = RGB_8;
1267 break;
1268 #endif
1269 #ifdef FBCON_HAS_CFB8
1270 case 8:
1271 if (fbi->cmap_static)
1272 display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
1273 else
1274 display->visual = FB_VISUAL_PSEUDOCOLOR;
1275 display->line_length = var->xres;
1276 display->dispsw = &fbcon_cfb8;
1277 rgbidx = RGB_8;
1278 break;
1279 #endif
1280 #ifdef FBCON_HAS_CFB16
1281 case 16:
1282 display->visual = FB_VISUAL_TRUECOLOR;
1283 display->line_length = var->xres * 2;
1284 display->dispsw = &fbcon_cfb16;
1285 display->dispsw_data = fbi->fb.pseudo_palette;
1286 rgbidx = RGB_16;
1287 break;
1288 #endif
1289 default:
1290 rgbidx = 0;
1291 display->dispsw = &fbcon_dummy;
1292 break;
1293 }
1294
1295 display->screen_base = fbi->screen_cpu;
1296 display->next_line = display->line_length;
1297 display->type = fbi->fb.fix.type;
1298 display->type_aux = fbi->fb.fix.type_aux;
1299 display->ypanstep = fbi->fb.fix.ypanstep;
1300 display->ywrapstep = fbi->fb.fix.ywrapstep;
1301 display->can_soft_blank = 1;
1302 display->inverse = fbi->cmap_inverse;
1303
1304 *dvar = *var;
1305 dvar->activate &= ~FB_ACTIVATE_ALL;
1306
1307 /*
1308 * Copy the RGB parameters for this display
1309 * from the machine specific parameters.
1310 */
1311 dvar->red = fbi->rgb[rgbidx]->red;
1312 dvar->green = fbi->rgb[rgbidx]->green;
1313 dvar->blue = fbi->rgb[rgbidx]->blue;
1314 dvar->transp = fbi->rgb[rgbidx]->transp;
1315
1316 DPRINTK("RGBT length = %d:%d:%d:%d\n",
1317 dvar->red.length, dvar->green.length, dvar->blue.length,
1318 dvar->transp.length);
1319
1320 DPRINTK("RGBT offset = %d:%d:%d:%d\n",
1321 dvar->red.offset, dvar->green.offset, dvar->blue.offset,
1322 dvar->transp.offset);
1323
1324 /*
1325 * Update the old var. The fbcon drivers still use this.
1326 * Once they are using fbi->fb.var, this can be dropped.
1327 */
1328 display->var = *dvar;
1329
1330 /*
1331 * If we are setting all the virtual consoles, also set the
1332 * defaults used to create new consoles.
1333 */
1334 if (var->activate & FB_ACTIVATE_ALL)
1335 fbi->fb.disp->var = *dvar;
1336
1337 /*
1338 * If the console has changed and the console has defined
1339 * a changevar function, call that function.
1340 */
1341 if (chgvar && info && fbi->fb.changevar)
1342 fbi->fb.changevar(con);
1343
1344 /* If the current console is selected, activate the new var. */
1345 if (con != fbi->currcon)
1346 return 0;
1347
1348 sa1100fb_hw_set_var(dvar, fbi);
1349
1350 return 0;
1351 }
1352
1353 static int
__do_set_cmap(struct fb_cmap * cmap,int kspc,int con,struct fb_info * info)1354 __do_set_cmap(struct fb_cmap *cmap, int kspc, int con,
1355 struct fb_info *info)
1356 {
1357 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
1358 struct fb_cmap *dcmap = get_con_cmap(info, con);
1359 int err = 0;
1360
1361 if (con == -1)
1362 con = fbi->currcon;
1363
1364 /* no colormap allocated? (we always have "this" colour map allocated) */
1365 if (con >= 0)
1366 err = fb_alloc_cmap(&fb_display[con].cmap, fbi->palette_size, 0);
1367
1368 if (!err && con == fbi->currcon)
1369 err = fb_set_cmap(cmap, kspc, sa1100fb_setcolreg, info);
1370
1371 if (!err)
1372 fb_copy_cmap(cmap, dcmap, kspc ? 0 : 1);
1373
1374 return err;
1375 }
1376
1377 static int
sa1100fb_set_cmap(struct fb_cmap * cmap,int kspc,int con,struct fb_info * info)1378 sa1100fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
1379 struct fb_info *info)
1380 {
1381 struct display *disp = get_con_display(info, con);
1382
1383 if (disp->visual == FB_VISUAL_TRUECOLOR ||
1384 disp->visual == FB_VISUAL_STATIC_PSEUDOCOLOR)
1385 return -EINVAL;
1386
1387 return __do_set_cmap(cmap, kspc, con, info);
1388 }
1389
1390 static int
sa1100fb_get_fix(struct fb_fix_screeninfo * fix,int con,struct fb_info * info)1391 sa1100fb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
1392 {
1393 struct display *display = get_con_display(info, con);
1394
1395 *fix = info->fix;
1396
1397 fix->line_length = display->line_length;
1398 fix->visual = display->visual;
1399 return 0;
1400 }
1401
1402 static int
sa1100fb_get_var(struct fb_var_screeninfo * var,int con,struct fb_info * info)1403 sa1100fb_get_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
1404 {
1405 *var = *get_con_var(info, con);
1406 return 0;
1407 }
1408
1409 static int
sa1100fb_get_cmap(struct fb_cmap * cmap,int kspc,int con,struct fb_info * info)1410 sa1100fb_get_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
1411 {
1412 struct fb_cmap *dcmap = get_con_cmap(info, con);
1413 fb_copy_cmap(dcmap, cmap, kspc ? 0 : 2);
1414 return 0;
1415 }
1416
1417 static struct fb_ops sa1100fb_ops = {
1418 owner: THIS_MODULE,
1419 fb_get_fix: sa1100fb_get_fix,
1420 fb_get_var: sa1100fb_get_var,
1421 fb_set_var: sa1100fb_set_var,
1422 fb_get_cmap: sa1100fb_get_cmap,
1423 fb_set_cmap: sa1100fb_set_cmap,
1424 };
1425
1426 /*
1427 * sa1100fb_switch():
1428 * Change to the specified console. Palette and video mode
1429 * are changed to the console's stored parameters.
1430 *
1431 * Uh oh, this can be called from a tasklet (IRQ)
1432 */
sa1100fb_switch(int con,struct fb_info * info)1433 static int sa1100fb_switch(int con, struct fb_info *info)
1434 {
1435 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
1436 struct display *disp;
1437 struct fb_cmap *cmap;
1438
1439 DPRINTK("con=%d info->modename=%s\n", con, fbi->fb.modename);
1440
1441 if (con == fbi->currcon)
1442 return 0;
1443
1444 if (fbi->currcon >= 0) {
1445 disp = fb_display + fbi->currcon;
1446
1447 /*
1448 * Save the old colormap and video mode.
1449 */
1450 disp->var = fbi->fb.var;
1451
1452 if (disp->cmap.len)
1453 fb_copy_cmap(&fbi->fb.cmap, &disp->cmap, 0);
1454 }
1455
1456 fbi->currcon = con;
1457 disp = fb_display + con;
1458
1459 /*
1460 * Make sure that our colourmap contains 256 entries.
1461 */
1462 fb_alloc_cmap(&fbi->fb.cmap, 256, 0);
1463
1464 if (disp->cmap.len)
1465 cmap = &disp->cmap;
1466 else
1467 cmap = fb_default_cmap(1 << disp->var.bits_per_pixel);
1468
1469 fb_copy_cmap(cmap, &fbi->fb.cmap, 0);
1470
1471 fbi->fb.var = disp->var;
1472 fbi->fb.var.activate = FB_ACTIVATE_NOW;
1473
1474 sa1100fb_set_var(&fbi->fb.var, con, info);
1475 return 0;
1476 }
1477
1478 /*
1479 * Formal definition of the VESA spec:
1480 * On
1481 * This refers to the state of the display when it is in full operation
1482 * Stand-By
1483 * This defines an optional operating state of minimal power reduction with
1484 * the shortest recovery time
1485 * Suspend
1486 * This refers to a level of power management in which substantial power
1487 * reduction is achieved by the display. The display can have a longer
1488 * recovery time from this state than from the Stand-by state
1489 * Off
1490 * This indicates that the display is consuming the lowest level of power
1491 * and is non-operational. Recovery from this state may optionally require
1492 * the user to manually power on the monitor
1493 *
1494 * Now, the fbdev driver adds an additional state, (blank), where they
1495 * turn off the video (maybe by colormap tricks), but don't mess with the
1496 * video itself: think of it semantically between on and Stand-By.
1497 *
1498 * So here's what we should do in our fbdev blank routine:
1499 *
1500 * VESA_NO_BLANKING (mode 0) Video on, front/back light on
1501 * VESA_VSYNC_SUSPEND (mode 1) Video on, front/back light off
1502 * VESA_HSYNC_SUSPEND (mode 2) Video on, front/back light off
1503 * VESA_POWERDOWN (mode 3) Video off, front/back light off
1504 *
1505 * This will match the matrox implementation.
1506 */
1507 /*
1508 * sa1100fb_blank():
1509 * Blank the display by setting all palette values to zero. Note, the
1510 * 12 and 16 bpp modes don't really use the palette, so this will not
1511 * blank the display in all modes.
1512 */
sa1100fb_blank(int blank,struct fb_info * info)1513 static void sa1100fb_blank(int blank, struct fb_info *info)
1514 {
1515 struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
1516 int i;
1517
1518 DPRINTK("sa1100fb_blank: blank=%d info->modename=%s\n", blank,
1519 fbi->fb.modename);
1520
1521 switch (blank) {
1522 case VESA_POWERDOWN:
1523 case VESA_VSYNC_SUSPEND:
1524 case VESA_HSYNC_SUSPEND:
1525 if (fbi->fb.disp->visual == FB_VISUAL_PSEUDOCOLOR ||
1526 fbi->fb.disp->visual == FB_VISUAL_STATIC_PSEUDOCOLOR)
1527 for (i = 0; i < fbi->palette_size; i++)
1528 sa1100fb_setpalettereg(i, 0, 0, 0, 0, info);
1529 sa1100fb_schedule_task(fbi, C_DISABLE);
1530 if (sa1100fb_blank_helper)
1531 sa1100fb_blank_helper(blank);
1532 break;
1533
1534 case VESA_NO_BLANKING:
1535 if (sa1100fb_blank_helper)
1536 sa1100fb_blank_helper(blank);
1537 if (fbi->fb.disp->visual == FB_VISUAL_PSEUDOCOLOR ||
1538 fbi->fb.disp->visual == FB_VISUAL_STATIC_PSEUDOCOLOR)
1539 fb_set_cmap(&fbi->fb.cmap, 1, sa1100fb_setcolreg, info);
1540 sa1100fb_schedule_task(fbi, C_ENABLE);
1541 }
1542 }
1543
sa1100fb_updatevar(int con,struct fb_info * info)1544 static int sa1100fb_updatevar(int con, struct fb_info *info)
1545 {
1546 DPRINTK("entered\n");
1547 return 0;
1548 }
1549
1550 /*
1551 * Calculate the PCD value from the clock rate (in picoseconds).
1552 * We take account of the PPCR clock setting.
1553 */
get_pcd(unsigned int pixclock)1554 static inline int get_pcd(unsigned int pixclock)
1555 {
1556 unsigned int pcd;
1557
1558 if (pixclock) {
1559 pcd = get_cclk_frequency() * pixclock;
1560 pcd /= 10000000;
1561 pcd += 1; /* make up for integer math truncations */
1562 } else {
1563 /*
1564 * People seem to be missing this message. Make it big.
1565 * Make it stand out. Make sure people see it.
1566 */
1567 printk(KERN_WARNING "******************************************************\n");
1568 printk(KERN_WARNING "** ZERO PIXEL CLOCK DETECTED **\n");
1569 printk(KERN_WARNING "** You are using a zero pixclock. This means that **\n");
1570 printk(KERN_WARNING "** clock scaling will not be able to adjust your **\n");
1571 printk(KERN_WARNING "** your timing parameters appropriately, and the **\n");
1572 printk(KERN_WARNING "** bandwidth calculations will fail to work. This **\n");
1573 printk(KERN_WARNING "** will shortly become an error condition, which **\n");
1574 printk(KERN_WARNING "** will prevent your LCD display working. Please **\n");
1575 printk(KERN_WARNING "** send your patches in as soon as possible to shut **\n");
1576 printk(KERN_WARNING "** this message up. **\n");
1577 printk(KERN_WARNING "******************************************************\n");
1578 pcd = 0;
1579 }
1580 return pcd;
1581 }
1582
1583 /*
1584 * sa1100fb_activate_var():
1585 * Configures LCD Controller based on entries in var parameter. Settings are
1586 * only written to the controller if changes were made.
1587 */
sa1100fb_activate_var(struct fb_var_screeninfo * var,struct sa1100fb_info * fbi)1588 static int sa1100fb_activate_var(struct fb_var_screeninfo *var, struct sa1100fb_info *fbi)
1589 {
1590 struct sa1100fb_lcd_reg new_regs;
1591 u_int half_screen_size, yres, pcd = get_pcd(var->pixclock);
1592 u_long flags;
1593
1594 DPRINTK("Configuring SA1100 LCD\n");
1595
1596 DPRINTK("var: xres=%d hslen=%d lm=%d rm=%d\n",
1597 var->xres, var->hsync_len,
1598 var->left_margin, var->right_margin);
1599 DPRINTK("var: yres=%d vslen=%d um=%d bm=%d\n",
1600 var->yres, var->vsync_len,
1601 var->upper_margin, var->lower_margin);
1602
1603 #if DEBUG_VAR
1604 if (var->xres < 16 || var->xres > 1024)
1605 printk(KERN_ERR "%s: invalid xres %d\n",
1606 fbi->fb.fix.id, var->xres);
1607 if (var->hsync_len < 1 || var->hsync_len > 64)
1608 printk(KERN_ERR "%s: invalid hsync_len %d\n",
1609 fbi->fb.fix.id, var->hsync_len);
1610 if (var->left_margin < 1 || var->left_margin > 255)
1611 printk(KERN_ERR "%s: invalid left_margin %d\n",
1612 fbi->fb.fix.id, var->left_margin);
1613 if (var->right_margin < 1 || var->right_margin > 255)
1614 printk(KERN_ERR "%s: invalid right_margin %d\n",
1615 fbi->fb.fix.id, var->right_margin);
1616 if (var->yres < 1 || var->yres > 1024)
1617 printk(KERN_ERR "%s: invalid yres %d\n",
1618 fbi->fb.fix.id, var->yres);
1619 if (var->vsync_len < 1 || var->vsync_len > 64)
1620 printk(KERN_ERR "%s: invalid vsync_len %d\n",
1621 fbi->fb.fix.id, var->vsync_len);
1622 if (var->upper_margin < 0 || var->upper_margin > 255)
1623 printk(KERN_ERR "%s: invalid upper_margin %d\n",
1624 fbi->fb.fix.id, var->upper_margin);
1625 if (var->lower_margin < 0 || var->lower_margin > 255)
1626 printk(KERN_ERR "%s: invalid lower_margin %d\n",
1627 fbi->fb.fix.id, var->lower_margin);
1628 #endif
1629
1630 new_regs.lccr0 = fbi->lccr0 |
1631 LCCR0_LEN | LCCR0_LDM | LCCR0_BAM |
1632 LCCR0_ERM | LCCR0_LtlEnd | LCCR0_DMADel(0);
1633
1634 new_regs.lccr1 =
1635 LCCR1_DisWdth(var->xres) +
1636 LCCR1_HorSnchWdth(var->hsync_len) +
1637 LCCR1_BegLnDel(var->left_margin) +
1638 LCCR1_EndLnDel(var->right_margin);
1639
1640 /*
1641 * If we have a dual scan LCD, then we need to halve
1642 * the YRES parameter.
1643 */
1644 yres = var->yres;
1645 if (fbi->lccr0 & LCCR0_Dual)
1646 yres /= 2;
1647
1648 new_regs.lccr2 =
1649 LCCR2_DisHght(yres) +
1650 LCCR2_VrtSnchWdth(var->vsync_len) +
1651 LCCR2_BegFrmDel(var->upper_margin) +
1652 LCCR2_EndFrmDel(var->lower_margin);
1653
1654 new_regs.lccr3 = fbi->lccr3 |
1655 (var->sync & FB_SYNC_HOR_HIGH_ACT ? LCCR3_HorSnchH : LCCR3_HorSnchL) |
1656 (var->sync & FB_SYNC_VERT_HIGH_ACT ? LCCR3_VrtSnchH : LCCR3_VrtSnchL) |
1657 LCCR3_ACBsCntOff;
1658
1659 if (pcd)
1660 new_regs.lccr3 |= LCCR3_PixClkDiv(pcd);
1661
1662 sa1100fb_check_shadow(&new_regs, var, pcd);
1663
1664 DPRINTK("nlccr0 = 0x%08x\n", new_regs.lccr0);
1665 DPRINTK("nlccr1 = 0x%08x\n", new_regs.lccr1);
1666 DPRINTK("nlccr2 = 0x%08x\n", new_regs.lccr2);
1667 DPRINTK("nlccr3 = 0x%08x\n", new_regs.lccr3);
1668
1669 half_screen_size = var->bits_per_pixel;
1670 half_screen_size = half_screen_size * var->xres * var->yres / 16;
1671
1672 /* Update shadow copy atomically */
1673 local_irq_save(flags);
1674 fbi->dbar1 = fbi->palette_dma;
1675 fbi->dbar2 = fbi->screen_dma + half_screen_size;
1676
1677 fbi->reg_lccr0 = new_regs.lccr0;
1678 fbi->reg_lccr1 = new_regs.lccr1;
1679 fbi->reg_lccr2 = new_regs.lccr2;
1680 fbi->reg_lccr3 = new_regs.lccr3;
1681 local_irq_restore(flags);
1682
1683 /*
1684 * Only update the registers if the controller is enabled
1685 * and something has changed.
1686 */
1687 if ((LCCR0 != fbi->reg_lccr0) || (LCCR1 != fbi->reg_lccr1) ||
1688 (LCCR2 != fbi->reg_lccr2) || (LCCR3 != fbi->reg_lccr3) ||
1689 (DBAR1 != fbi->dbar1) || (DBAR2 != fbi->dbar2))
1690 sa1100fb_schedule_task(fbi, C_REENABLE);
1691
1692 return 0;
1693 }
1694
1695 /*
1696 * NOTE! The following functions are purely helpers for set_ctrlr_state.
1697 * Do not call them directly; set_ctrlr_state does the correct serialisation
1698 * to ensure that things happen in the right way 100% of time time.
1699 * -- rmk
1700 */
1701
1702 /*
1703 * FIXME: move LCD power stuff into sa1100fb_power_up_lcd()
1704 * Also, I'm expecting that the backlight stuff should
1705 * be handled differently.
1706 */
sa1100fb_backlight_on(struct sa1100fb_info * fbi)1707 static void sa1100fb_backlight_on(struct sa1100fb_info *fbi)
1708 {
1709 DPRINTK("backlight on\n");
1710
1711 #ifdef CONFIG_SA1100_FREEBIRD
1712 #error FIXME
1713 if (machine_is_freebird()) {
1714 BCR_set(BCR_FREEBIRD_LCD_PWR | BCR_FREEBIRD_LCD_DISP);
1715 }
1716 #endif
1717 #ifdef CONFIG_SA1100_FREEBIRD
1718 if (machine_is_freebird()) {
1719 /* Turn on backlight ,Chester */
1720 BCR_set(BCR_FREEBIRD_LCD_BACKLIGHT);
1721 }
1722 #endif
1723 #ifdef CONFIG_SA1100_HUW_WEBPANEL
1724 #error FIXME
1725 if (machine_is_huw_webpanel()) {
1726 BCR_set(BCR_CCFL_POW + BCR_PWM_BACKLIGHT);
1727 set_current_state(TASK_UNINTERRUPTIBLE);
1728 schedule_task(200 * HZ / 1000);
1729 BCR_set(BCR_TFT_ENA);
1730 }
1731 #endif
1732 #ifdef CONFIG_SA1100_OMNIMETER
1733 if (machine_is_omnimeter())
1734 LEDBacklightOn();
1735 #endif
1736 }
1737
1738 /*
1739 * FIXME: move LCD power stuf into sa1100fb_power_down_lcd()
1740 * Also, I'm expecting that the backlight stuff should
1741 * be handled differently.
1742 */
sa1100fb_backlight_off(struct sa1100fb_info * fbi)1743 static void sa1100fb_backlight_off(struct sa1100fb_info *fbi)
1744 {
1745 DPRINTK("backlight off\n");
1746
1747 #ifdef CONFIG_SA1100_FREEBIRD
1748 #error FIXME
1749 if (machine_is_freebird()) {
1750 BCR_clear(BCR_FREEBIRD_LCD_PWR | BCR_FREEBIRD_LCD_DISP
1751 /*| BCR_FREEBIRD_LCD_BACKLIGHT */ );
1752 }
1753 #endif
1754 #ifdef CONFIG_SA1100_OMNIMETER
1755 if (machine_is_omnimeter())
1756 LEDBacklightOff();
1757 #endif
1758 }
1759
sa1100fb_power_up_lcd(struct sa1100fb_info * fbi)1760 static void sa1100fb_power_up_lcd(struct sa1100fb_info *fbi)
1761 {
1762 DPRINTK("LCD power on\n");
1763
1764 #ifndef ASSABET_PAL_VIDEO
1765 if (machine_is_assabet())
1766 ASSABET_BCR_set(ASSABET_BCR_LCD_ON);
1767 #endif
1768 #ifdef CONFIG_SA1100_HUW_WEBPANEL
1769 if (machine_is_huw_webpanel())
1770 BCR_clear(BCR_TFT_NPWR);
1771 #endif
1772 #ifdef CONFIG_SA1100_OMNIMETER
1773 if (machine_is_omnimeter())
1774 LCDPowerOn();
1775 #endif
1776 #ifdef CONFIG_SA1100_H3600
1777 if (machine_is_h3600()) {
1778 set_h3600_egpio(EGPIO_H3600_LCD_ON |
1779 EGPIO_H3600_LCD_PCI |
1780 EGPIO_H3600_LCD_5V_ON |
1781 EGPIO_H3600_LVDD_ON);
1782 }
1783 #endif
1784 #ifdef CONFIG_SA1100_STORK
1785 if (machine_is_stork()) {
1786 storkSetLCDCPLD(0, 1);
1787 storkSetLatchA(STORK_LCD_BACKLIGHT_INVERTER_ON);
1788 }
1789 #endif
1790 }
1791
sa1100fb_power_down_lcd(struct sa1100fb_info * fbi)1792 static void sa1100fb_power_down_lcd(struct sa1100fb_info *fbi)
1793 {
1794 DPRINTK("LCD power off\n");
1795
1796 #ifndef ASSABET_PAL_VIDEO
1797 if (machine_is_assabet())
1798 ASSABET_BCR_clear(ASSABET_BCR_LCD_ON);
1799 #endif
1800 #ifdef CONFIG_SA1100_HUW_WEBPANEL
1801 // dont forget to set the control lines to zero (?)
1802 if (machine_is_huw_webpanel())
1803 BCR_set(BCR_TFT_NPWR);
1804 #endif
1805 #ifdef CONFIG_SA1100_H3600
1806 if (machine_is_h3600()) {
1807 clr_h3600_egpio(EGPIO_H3600_LCD_ON |
1808 EGPIO_H3600_LCD_PCI |
1809 EGPIO_H3600_LCD_5V_ON |
1810 EGPIO_H3600_LVDD_ON);
1811 }
1812 #endif
1813 #ifdef CONFIG_SA1100_STORK
1814 if (machine_is_stork()) {
1815 storkSetLCDCPLD(0, 0);
1816 storkClearLatchA(STORK_LCD_BACKLIGHT_INVERTER_ON);
1817 }
1818 #endif
1819 }
1820
sa1100fb_setup_gpio(struct sa1100fb_info * fbi)1821 static void sa1100fb_setup_gpio(struct sa1100fb_info *fbi)
1822 {
1823 u_int mask = 0;
1824
1825 /*
1826 * Enable GPIO<9:2> for LCD use if:
1827 * 1. Active display, or
1828 * 2. Color Dual Passive display
1829 *
1830 * see table 11.8 on page 11-27 in the SA1100 manual
1831 * -- Erik.
1832 *
1833 * SA1110 spec update nr. 25 says we can and should
1834 * clear LDD15 to 12 for 4 or 8bpp modes with active
1835 * panels.
1836 */
1837 if ((fbi->reg_lccr0 & LCCR0_CMS) == LCCR0_Color &&
1838 (fbi->reg_lccr0 & (LCCR0_Dual|LCCR0_Act)) != 0) {
1839 mask = GPIO_LDD11 | GPIO_LDD10 | GPIO_LDD9 | GPIO_LDD8;
1840
1841 if (fbi->fb.var.bits_per_pixel > 8 ||
1842 (fbi->reg_lccr0 & (LCCR0_Dual|LCCR0_Act)) == LCCR0_Dual)
1843 mask |= GPIO_LDD15 | GPIO_LDD14 | GPIO_LDD13 | GPIO_LDD12;
1844
1845 }
1846
1847 #ifdef CONFIG_SA1100_FREEBIRD
1848 #error Please contact <rmk@arm.linux.org.uk> about this
1849 if (machine_is_freebird()) {
1850 /* Color single passive */
1851 mask |= GPIO_LDD15 | GPIO_LDD14 | GPIO_LDD13 | GPIO_LDD12 |
1852 GPIO_LDD11 | GPIO_LDD10 | GPIO_LDD9 | GPIO_LDD8;
1853 }
1854 #endif
1855 if (machine_is_cerf()) {
1856 /* GPIO15 is used as a bypass for 3.8" displays */
1857 mask |= GPIO_GPIO15;
1858 #ifdef CONFIG_SA1100_CERF
1859 #warning Read Me Now!
1860 #endif
1861 #if 0 /* if this causes you problems, mail <rmk@arm.linux.org.uk> please. */
1862 /*
1863 * This was enabled for the 72_A version only, which is a _color_
1864 * _dual_ LCD. Now look at the generic test above, and calculate
1865 * the mask value for a colour dual display...
1866 *
1867 * I therefore conclude that the code below is redundant, and will
1868 * be killed at the start of November 2001.
1869 */
1870 /* FIXME: why is this? The Cerf's display doesn't seem
1871 * to be dual scan or active. I just leave it here,
1872 * but in my opinion this is definitively wrong.
1873 * -- Erik <J.A.K.Mouw@its.tudelft.nl>
1874 */
1875
1876 /* REPLY: Umm.. Well to be honest, the 5.7" LCD which
1877 * this was used for does not use these pins, but
1878 * apparently all hell breaks loose if they are not
1879 * set on the Cerf, so we decided to leave them in ;)
1880 * -- Daniel Chemko <dchemko@intrinsyc.com>
1881 */
1882 /* color {dual/single} passive */
1883 mask |= GPIO_LDD15 | GPIO_LDD14 | GPIO_LDD13 | GPIO_LDD12 |
1884 GPIO_LDD11 | GPIO_LDD10 | GPIO_LDD9 | GPIO_LDD8;
1885 #endif
1886 }
1887
1888 if (mask) {
1889 GPDR |= mask;
1890 GAFR |= mask;
1891 }
1892 }
1893
sa1100fb_enable_controller(struct sa1100fb_info * fbi)1894 static void sa1100fb_enable_controller(struct sa1100fb_info *fbi)
1895 {
1896 DPRINTK("Enabling LCD controller\n");
1897
1898 /*
1899 * Make sure the mode bits are present in the first palette entry
1900 */
1901 fbi->palette_cpu[0] &= 0xcfff;
1902 fbi->palette_cpu[0] |= palette_pbs(&fbi->fb.var);
1903
1904 /* Sequence from 11.7.10 */
1905 LCCR3 = fbi->reg_lccr3;
1906 LCCR2 = fbi->reg_lccr2;
1907 LCCR1 = fbi->reg_lccr1;
1908 LCCR0 = fbi->reg_lccr0 & ~LCCR0_LEN;
1909 DBAR1 = fbi->dbar1;
1910 DBAR2 = fbi->dbar2;
1911 LCCR0 |= LCCR0_LEN;
1912
1913 #ifdef CONFIG_SA1100_GRAPHICSCLIENT
1914 #error Where is GPIO24 set as an output? Can we fit this in somewhere else?
1915 if (machine_is_graphicsclient()) {
1916 // From ADS doc again...same as disable
1917 set_current_state(TASK_UNINTERRUPTIBLE);
1918 schedule_timeout(20 * HZ / 1000);
1919 GPSR |= GPIO_GPIO24;
1920 }
1921 #endif
1922
1923 DPRINTK("DBAR1 = %p\n", DBAR1);
1924 DPRINTK("DBAR2 = %p\n", DBAR2);
1925 DPRINTK("LCCR0 = 0x%08x\n", LCCR0);
1926 DPRINTK("LCCR1 = 0x%08x\n", LCCR1);
1927 DPRINTK("LCCR2 = 0x%08x\n", LCCR2);
1928 DPRINTK("LCCR3 = 0x%08x\n", LCCR3);
1929 }
1930
sa1100fb_disable_controller(struct sa1100fb_info * fbi)1931 static void sa1100fb_disable_controller(struct sa1100fb_info *fbi)
1932 {
1933 DECLARE_WAITQUEUE(wait, current);
1934
1935 DPRINTK("Disabling LCD controller\n");
1936
1937 #ifdef CONFIG_SA1100_GRAPHICSCLIENT
1938 #error Where is GPIO24 set as an output? Can we fit this in somewhere else?
1939 if (machine_is_graphicsclient()) {
1940 /*
1941 * From ADS internal document:
1942 * GPIO24 should be LOW at least 10msec prior to disabling
1943 * the LCD interface.
1944 *
1945 * We'll wait 20msec.
1946 */
1947 GPCR |= GPIO_GPIO24;
1948 set_current_state(TASK_UNINTERRUPTIBLE);
1949 schedule_timeout(20 * HZ / 1000);
1950 }
1951 #endif
1952 #ifdef CONFIG_SA1100_HUW_WEBPANEL
1953 #error Move me into sa1100fb_power_up_lcd and/or sa1100fb_backlight_on
1954 if (machine_is_huw_webpanel()) {
1955 // dont forget to set the control lines to zero (?)
1956 DPRINTK("ShutDown HuW LCD controller\n");
1957 BCR_clear(BCR_TFT_ENA + BCR_CCFL_POW + BCR_PWM_BACKLIGHT);
1958 }
1959 #endif
1960
1961 add_wait_queue(&fbi->ctrlr_wait, &wait);
1962 set_current_state(TASK_UNINTERRUPTIBLE);
1963
1964 LCSR = 0xffffffff; /* Clear LCD Status Register */
1965 LCCR0 &= ~LCCR0_LDM; /* Enable LCD Disable Done Interrupt */
1966 enable_irq(IRQ_LCD); /* Enable LCD IRQ */
1967 LCCR0 &= ~LCCR0_LEN; /* Disable LCD Controller */
1968
1969 schedule_timeout(20 * HZ / 1000);
1970 current->state = TASK_RUNNING;
1971 remove_wait_queue(&fbi->ctrlr_wait, &wait);
1972 }
1973
1974 /*
1975 * sa1100fb_handle_irq: Handle 'LCD DONE' interrupts.
1976 */
sa1100fb_handle_irq(int irq,void * dev_id,struct pt_regs * regs)1977 static void sa1100fb_handle_irq(int irq, void *dev_id, struct pt_regs *regs)
1978 {
1979 struct sa1100fb_info *fbi = dev_id;
1980 unsigned int lcsr = LCSR;
1981
1982 if (lcsr & LCSR_LDD) {
1983 LCCR0 |= LCCR0_LDM;
1984 wake_up(&fbi->ctrlr_wait);
1985 }
1986
1987 LCSR = lcsr;
1988 }
1989
1990 /*
1991 * This function must be called from task context only, since it will
1992 * sleep when disabling the LCD controller, or if we get two contending
1993 * processes trying to alter state.
1994 */
set_ctrlr_state(struct sa1100fb_info * fbi,u_int state)1995 static void set_ctrlr_state(struct sa1100fb_info *fbi, u_int state)
1996 {
1997 u_int old_state;
1998
1999 down(&fbi->ctrlr_sem);
2000
2001 old_state = fbi->state;
2002
2003 switch (state) {
2004 case C_DISABLE_CLKCHANGE:
2005 /*
2006 * Disable controller for clock change. If the
2007 * controller is already disabled, then do nothing.
2008 */
2009 if (old_state != C_DISABLE) {
2010 fbi->state = state;
2011 sa1100fb_disable_controller(fbi);
2012 }
2013 break;
2014
2015 case C_DISABLE:
2016 /*
2017 * Disable controller
2018 */
2019 if (old_state != C_DISABLE) {
2020 fbi->state = state;
2021
2022 sa1100fb_backlight_off(fbi);
2023 if (old_state != C_DISABLE_CLKCHANGE)
2024 sa1100fb_disable_controller(fbi);
2025 sa1100fb_power_down_lcd(fbi);
2026 }
2027 break;
2028
2029 case C_ENABLE_CLKCHANGE:
2030 /*
2031 * Enable the controller after clock change. Only
2032 * do this if we were disabled for the clock change.
2033 */
2034 if (old_state == C_DISABLE_CLKCHANGE) {
2035 fbi->state = C_ENABLE;
2036 sa1100fb_enable_controller(fbi);
2037 }
2038 break;
2039
2040 case C_REENABLE:
2041 /*
2042 * Re-enable the controller only if it was already
2043 * enabled. This is so we reprogram the control
2044 * registers.
2045 */
2046 if (old_state == C_ENABLE) {
2047 sa1100fb_disable_controller(fbi);
2048 sa1100fb_setup_gpio(fbi);
2049 sa1100fb_enable_controller(fbi);
2050 }
2051 break;
2052
2053 case C_ENABLE:
2054 /*
2055 * Power up the LCD screen, enable controller, and
2056 * turn on the backlight.
2057 */
2058 if (old_state != C_ENABLE) {
2059 fbi->state = C_ENABLE;
2060 sa1100fb_setup_gpio(fbi);
2061 sa1100fb_power_up_lcd(fbi);
2062 sa1100fb_enable_controller(fbi);
2063 sa1100fb_backlight_on(fbi);
2064 }
2065 break;
2066 }
2067 up(&fbi->ctrlr_sem);
2068 }
2069
2070 /*
2071 * Our LCD controller task (which is called when we blank or unblank)
2072 * via keventd.
2073 */
sa1100fb_task(void * dummy)2074 static void sa1100fb_task(void *dummy)
2075 {
2076 struct sa1100fb_info *fbi = dummy;
2077 u_int state = xchg(&fbi->task_state, -1);
2078
2079 set_ctrlr_state(fbi, state);
2080 }
2081
2082 #ifdef CONFIG_CPU_FREQ
2083 /*
2084 * Calculate the minimum DMA period over all displays that we own.
2085 * This, together with the SDRAM bandwidth defines the slowest CPU
2086 * frequency that can be selected.
2087 */
sa1100fb_min_dma_period(struct sa1100fb_info * fbi)2088 static unsigned int sa1100fb_min_dma_period(struct sa1100fb_info *fbi)
2089 {
2090 unsigned int min_period = (unsigned int)-1;
2091 int i;
2092
2093 for (i = 0; i < MAX_NR_CONSOLES; i++) {
2094 unsigned int period;
2095
2096 /*
2097 * Do we own this display?
2098 */
2099 if (fb_display[i].fb_info != &fbi->fb)
2100 continue;
2101
2102 /*
2103 * Ok, calculate its DMA period
2104 */
2105 period = sa1100fb_display_dma_period(get_con_var(&fbi->fb, i));
2106 if (period < min_period)
2107 min_period = period;
2108 }
2109
2110 return min_period;
2111 }
2112
2113 /*
2114 * CPU clock speed change handler. We need to adjust the LCD timing
2115 * parameters when the CPU clock is adjusted by the power management
2116 * subsystem.
2117 */
2118 static int
sa1100fb_clkchg_notifier(struct notifier_block * nb,unsigned long val,void * data)2119 sa1100fb_clkchg_notifier(struct notifier_block *nb, unsigned long val,
2120 void *data)
2121 {
2122 struct sa1100fb_info *fbi = TO_INF(nb, clockchg);
2123 struct cpufreq_minmax *mm = data;
2124 u_int pcd;
2125
2126 switch (val) {
2127 case CPUFREQ_MINMAX:
2128 printk(KERN_DEBUG "min dma period: %d ps, old clock %d kHz, "
2129 "new clock %d kHz\n", sa1100fb_min_dma_period(fbi),
2130 mm->cur_freq, mm->new_freq);
2131 /* todo: fill in min/max values */
2132 break;
2133
2134 case CPUFREQ_PRECHANGE:
2135 set_ctrlr_state(fbi, C_DISABLE_CLKCHANGE);
2136 break;
2137
2138 case CPUFREQ_POSTCHANGE:
2139 pcd = get_pcd(fbi->fb.var.pixclock);
2140 fbi->reg_lccr3 = (fbi->reg_lccr3 & ~0xff) | LCCR3_PixClkDiv(pcd);
2141 set_ctrlr_state(fbi, C_ENABLE_CLKCHANGE);
2142 break;
2143 }
2144 return 0;
2145 }
2146 #endif
2147
2148 #ifdef CONFIG_PM
2149 /*
2150 * Power management hook. Note that we won't be called from IRQ context,
2151 * unlike the blank functions above, so we may sleep.
2152 */
2153 static int
sa1100fb_pm_callback(struct pm_dev * pm_dev,pm_request_t req,void * data)2154 sa1100fb_pm_callback(struct pm_dev *pm_dev, pm_request_t req, void *data)
2155 {
2156 struct sa1100fb_info *fbi = pm_dev->data;
2157
2158 DPRINTK("pm_callback: %d\n", req);
2159
2160 if (req == PM_SUSPEND || req == PM_RESUME) {
2161 int state = (int)data;
2162
2163 if (state == 0) {
2164 /* Enter D0. */
2165 set_ctrlr_state(fbi, C_ENABLE);
2166 } else {
2167 /* Enter D1-D3. Disable the LCD controller. */
2168 set_ctrlr_state(fbi, C_DISABLE);
2169 }
2170 }
2171 DPRINTK("done\n");
2172 return 0;
2173 }
2174 #endif
2175
2176 /*
2177 * sa1100fb_map_video_memory():
2178 * Allocates the DRAM memory for the frame buffer. This buffer is
2179 * remapped into a non-cached, non-buffered, memory region to
2180 * allow palette and pixel writes to occur without flushing the
2181 * cache. Once this area is remapped, all virtual memory
2182 * access to the video memory should occur at the new region.
2183 */
sa1100fb_map_video_memory(struct sa1100fb_info * fbi)2184 static int __init sa1100fb_map_video_memory(struct sa1100fb_info *fbi)
2185 {
2186 /*
2187 * We reserve one page for the palette, plus the size
2188 * of the framebuffer.
2189 */
2190 fbi->map_size = PAGE_ALIGN(fbi->fb.fix.smem_len + PAGE_SIZE);
2191 fbi->map_cpu = consistent_alloc(GFP_KERNEL, fbi->map_size,
2192 &fbi->map_dma);
2193
2194 if (fbi->map_cpu) {
2195 fbi->screen_cpu = fbi->map_cpu + PAGE_SIZE;
2196 fbi->screen_dma = fbi->map_dma + PAGE_SIZE;
2197 fbi->fb.fix.smem_start = fbi->screen_dma;
2198 }
2199
2200 return fbi->map_cpu ? 0 : -ENOMEM;
2201 }
2202
2203 /* Fake monspecs to fill in fbinfo structure */
2204 static struct fb_monspecs monspecs __initdata = {
2205 30000, 70000, 50, 65, 0 /* Generic */
2206 };
2207
2208
sa1100fb_init_fbinfo(void)2209 static struct sa1100fb_info * __init sa1100fb_init_fbinfo(void)
2210 {
2211 struct sa1100fb_mach_info *inf;
2212 struct sa1100fb_info *fbi;
2213
2214 fbi = kmalloc(sizeof(struct sa1100fb_info) + sizeof(struct display) +
2215 sizeof(u16) * 16, GFP_KERNEL);
2216 if (!fbi)
2217 return NULL;
2218
2219 memset(fbi, 0, sizeof(struct sa1100fb_info) + sizeof(struct display));
2220
2221 fbi->currcon = -1;
2222
2223 strcpy(fbi->fb.fix.id, SA1100_NAME);
2224
2225 fbi->fb.fix.type = FB_TYPE_PACKED_PIXELS;
2226 fbi->fb.fix.type_aux = 0;
2227 fbi->fb.fix.xpanstep = 0;
2228 fbi->fb.fix.ypanstep = 0;
2229 fbi->fb.fix.ywrapstep = 0;
2230 fbi->fb.fix.accel = FB_ACCEL_NONE;
2231
2232 fbi->fb.var.nonstd = 0;
2233 fbi->fb.var.activate = FB_ACTIVATE_NOW;
2234 fbi->fb.var.height = -1;
2235 fbi->fb.var.width = -1;
2236 fbi->fb.var.accel_flags = 0;
2237 fbi->fb.var.vmode = FB_VMODE_NONINTERLACED;
2238
2239 strcpy(fbi->fb.modename, SA1100_NAME);
2240 strcpy(fbi->fb.fontname, "Acorn8x8");
2241
2242 fbi->fb.fbops = &sa1100fb_ops;
2243 fbi->fb.changevar = NULL;
2244 fbi->fb.switch_con = sa1100fb_switch;
2245 fbi->fb.updatevar = sa1100fb_updatevar;
2246 fbi->fb.blank = sa1100fb_blank;
2247 fbi->fb.flags = FBINFO_FLAG_DEFAULT;
2248 fbi->fb.node = -1;
2249 fbi->fb.monspecs = monspecs;
2250 fbi->fb.disp = (struct display *)(fbi + 1);
2251 fbi->fb.pseudo_palette = (void *)(fbi->fb.disp + 1);
2252
2253 fbi->rgb[RGB_8] = &rgb_8;
2254 fbi->rgb[RGB_16] = &def_rgb_16;
2255
2256 inf = sa1100fb_get_machine_info(fbi);
2257
2258 fbi->max_xres = inf->xres;
2259 fbi->fb.var.xres = inf->xres;
2260 fbi->fb.var.xres_virtual = inf->xres;
2261 fbi->max_yres = inf->yres;
2262 fbi->fb.var.yres = inf->yres;
2263 fbi->fb.var.yres_virtual = inf->yres;
2264 fbi->max_bpp = inf->bpp;
2265 fbi->fb.var.bits_per_pixel = inf->bpp;
2266 fbi->fb.var.pixclock = inf->pixclock;
2267 fbi->fb.var.hsync_len = inf->hsync_len;
2268 fbi->fb.var.left_margin = inf->left_margin;
2269 fbi->fb.var.right_margin = inf->right_margin;
2270 fbi->fb.var.vsync_len = inf->vsync_len;
2271 fbi->fb.var.upper_margin = inf->upper_margin;
2272 fbi->fb.var.lower_margin = inf->lower_margin;
2273 fbi->fb.var.sync = inf->sync;
2274 fbi->fb.var.grayscale = inf->cmap_greyscale;
2275 fbi->cmap_inverse = inf->cmap_inverse;
2276 fbi->cmap_static = inf->cmap_static;
2277 fbi->lccr0 = inf->lccr0;
2278 fbi->lccr3 = inf->lccr3;
2279 fbi->state = C_DISABLE;
2280 fbi->task_state = (u_char)-1;
2281 fbi->fb.fix.smem_len = fbi->max_xres * fbi->max_yres *
2282 fbi->max_bpp / 8;
2283
2284 init_waitqueue_head(&fbi->ctrlr_wait);
2285 INIT_TQUEUE(&fbi->task, sa1100fb_task, fbi);
2286 init_MUTEX(&fbi->ctrlr_sem);
2287
2288 return fbi;
2289 }
2290
sa1100fb_init(void)2291 int __init sa1100fb_init(void)
2292 {
2293 struct sa1100fb_info *fbi;
2294 int ret;
2295
2296 fbi = sa1100fb_init_fbinfo();
2297 ret = -ENOMEM;
2298 if (!fbi)
2299 goto failed;
2300
2301 /* Initialize video memory */
2302 ret = sa1100fb_map_video_memory(fbi);
2303 if (ret)
2304 goto failed;
2305
2306 ret = request_irq(IRQ_LCD, sa1100fb_handle_irq, SA_INTERRUPT,
2307 fbi->fb.fix.id, fbi);
2308 if (ret) {
2309 printk(KERN_ERR "sa1100fb: request_irq failed: %d\n", ret);
2310 goto failed;
2311 }
2312
2313 #ifdef ASSABET_PAL_VIDEO
2314 if (machine_is_assabet())
2315 ASSABET_BCR_clear(ASSABET_BCR_LCD_ON);
2316 #endif
2317
2318 #ifdef CONFIG_SA1100_FREEBIRD
2319 #error Please move this into sa1100fb_power_up_lcd
2320 if (machine_is_freebird()) {
2321 BCR_set(BCR_FREEBIRD_LCD_DISP);
2322 mdelay(20);
2323 BCR_set(BCR_FREEBIRD_LCD_PWR);
2324 mdelay(20);
2325 }
2326 #endif
2327
2328 sa1100fb_set_var(&fbi->fb.var, -1, &fbi->fb);
2329
2330 ret = register_framebuffer(&fbi->fb);
2331 if (ret < 0)
2332 goto failed;
2333
2334 #ifdef CONFIG_PM
2335 /*
2336 * Note that the console registers this as well, but we want to
2337 * power down the display prior to sleeping.
2338 */
2339 fbi->pm = pm_register(PM_SYS_DEV, PM_SYS_VGA, sa1100fb_pm_callback);
2340 if (fbi->pm)
2341 fbi->pm->data = fbi;
2342 #endif
2343 #ifdef CONFIG_CPU_FREQ
2344 fbi->clockchg.notifier_call = sa1100fb_clkchg_notifier;
2345 cpufreq_register_notifier(&fbi->clockchg);
2346 #endif
2347
2348 /*
2349 * Ok, now enable the LCD controller
2350 */
2351 set_ctrlr_state(fbi, C_ENABLE);
2352
2353 /* This driver cannot be unloaded at the moment */
2354 MOD_INC_USE_COUNT;
2355
2356 return 0;
2357
2358 failed:
2359 if (fbi)
2360 kfree(fbi);
2361 return ret;
2362 }
2363
sa1100fb_setup(char * options)2364 int __init sa1100fb_setup(char *options)
2365 {
2366 #if 0
2367 char *this_opt;
2368
2369 if (!options || !*options)
2370 return 0;
2371
2372 while ((this_opt = strsep(&options, ",")) != NULL) {
2373
2374 if (!strncmp(this_opt, "bpp:", 4))
2375 current_par.max_bpp =
2376 simple_strtoul(this_opt + 4, NULL, 0);
2377
2378 if (!strncmp(this_opt, "lccr0:", 6))
2379 lcd_shadow.lccr0 =
2380 simple_strtoul(this_opt + 6, NULL, 0);
2381 if (!strncmp(this_opt, "lccr1:", 6)) {
2382 lcd_shadow.lccr1 =
2383 simple_strtoul(this_opt + 6, NULL, 0);
2384 current_par.max_xres =
2385 (lcd_shadow.lccr1 & 0x3ff) + 16;
2386 }
2387 if (!strncmp(this_opt, "lccr2:", 6)) {
2388 lcd_shadow.lccr2 =
2389 simple_strtoul(this_opt + 6, NULL, 0);
2390 current_par.max_yres =
2391 (lcd_shadow.
2392 lccr0 & LCCR0_SDS) ? ((lcd_shadow.
2393 lccr2 & 0x3ff) +
2394 1) *
2395 2 : ((lcd_shadow.lccr2 & 0x3ff) + 1);
2396 }
2397 if (!strncmp(this_opt, "lccr3:", 6))
2398 lcd_shadow.lccr3 =
2399 simple_strtoul(this_opt + 6, NULL, 0);
2400 }
2401 #endif
2402 return 0;
2403 }
2404
2405 MODULE_DESCRIPTION("StrongARM-1100/1110 framebuffer driver");
2406 MODULE_LICENSE("GPL");
2407