?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / video / imxfb.c
blob01ce45611640a8830f3d0336db3ef839d87fe659
1 /*
2 * Freescale i.MX Frame Buffer device driver
3 *
4 * Copyright (C) 2004 Sascha Hauer, Pengutronix
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 * Please direct your questions and comments on this driver to the following
12 * email address:
13 *
14 * linux-arm-kernel@lists.arm.linux.org.uk
15 */
16
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/errno.h>
20 #include <linux/string.h>
21 #include <linux/interrupt.h>
22 #include <linux/slab.h>
23 #include <linux/mm.h>
24 #include <linux/fb.h>
25 #include <linux/delay.h>
26 #include <linux/init.h>
27 #include <linux/ioport.h>
28 #include <linux/cpufreq.h>
29 #include <linux/clk.h>
30 #include <linux/platform_device.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/io.h>
33 #include <linux/math64.h>
34
35 #include <mach/imxfb.h>
36 #include <mach/hardware.h>
37
38 /*
39 * Complain if VAR is out of range.
40 */
41 #define DEBUG_VAR 1
42
43 #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || \
44 (defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE) && defined(CONFIG_FB_IMX_MODULE))
45 #define PWMR_BACKLIGHT_AVAILABLE
46 #endif
47
48 #define DRIVER_NAME "imx-fb"
49
50 #define LCDC_SSA 0x00
51
52 #define LCDC_SIZE 0x04
53 #define SIZE_XMAX(x) ((((x) >> 4) & 0x3f) << 20)
54
55 #ifdef CONFIG_ARCH_MX1
56 #define SIZE_YMAX(y) ((y) & 0x1ff)
57 #else
58 #define SIZE_YMAX(y) ((y) & 0x3ff)
59 #endif
60
61 #define LCDC_VPW 0x08
62 #define VPW_VPW(x) ((x) & 0x3ff)
63
64 #define LCDC_CPOS 0x0C
65 #define CPOS_CC1 (1<<31)
66 #define CPOS_CC0 (1<<30)
67 #define CPOS_OP (1<<28)
68 #define CPOS_CXP(x) (((x) & 3ff) << 16)
69
70 #ifdef CONFIG_ARCH_MX1
71 #define CPOS_CYP(y) ((y) & 0x1ff)
72 #else
73 #define CPOS_CYP(y) ((y) & 0x3ff)
74 #endif
75
76 #define LCDC_LCWHB 0x10
77 #define LCWHB_BK_EN (1<<31)
78 #define LCWHB_CW(w) (((w) & 0x1f) << 24)
79 #define LCWHB_CH(h) (((h) & 0x1f) << 16)
80 #define LCWHB_BD(x) ((x) & 0xff)
81
82 #define LCDC_LCHCC 0x14
83
84 #ifdef CONFIG_ARCH_MX1
85 #define LCHCC_CUR_COL_R(r) (((r) & 0x1f) << 11)
86 #define LCHCC_CUR_COL_G(g) (((g) & 0x3f) << 5)
87 #define LCHCC_CUR_COL_B(b) ((b) & 0x1f)
88 #else
89 #define LCHCC_CUR_COL_R(r) (((r) & 0x3f) << 12)
90 #define LCHCC_CUR_COL_G(g) (((g) & 0x3f) << 6)
91 #define LCHCC_CUR_COL_B(b) ((b) & 0x3f)
92 #endif
93
94 #define LCDC_PCR 0x18
95
96 #define LCDC_HCR 0x1C
97 #define HCR_H_WIDTH(x) (((x) & 0x3f) << 26)
98 #define HCR_H_WAIT_1(x) (((x) & 0xff) << 8)
99 #define HCR_H_WAIT_2(x) ((x) & 0xff)
100
101 #define LCDC_VCR 0x20
102 #define VCR_V_WIDTH(x) (((x) & 0x3f) << 26)
103 #define VCR_V_WAIT_1(x) (((x) & 0xff) << 8)
104 #define VCR_V_WAIT_2(x) ((x) & 0xff)
105
106 #define LCDC_POS 0x24
107 #define POS_POS(x) ((x) & 1f)
108
109 #define LCDC_LSCR1 0x28
110 /* bit fields in imxfb.h */
111
112 #define LCDC_PWMR 0x2C
113 /* bit fields in imxfb.h */
114
115 #define LCDC_DMACR 0x30
116 /* bit fields in imxfb.h */
117
118 #define LCDC_RMCR 0x34
119
120 #ifdef CONFIG_ARCH_MX1
121 #define RMCR_LCDC_EN (1<<1)
122 #else
123 #define RMCR_LCDC_EN 0
124 #endif
125
126 #define RMCR_SELF_REF (1<<0)
127
128 #define LCDC_LCDICR 0x38
129 #define LCDICR_INT_SYN (1<<2)
130 #define LCDICR_INT_CON (1)
131
132 #define LCDC_LCDISR 0x40
133 #define LCDISR_UDR_ERR (1<<3)
134 #define LCDISR_ERR_RES (1<<2)
135 #define LCDISR_EOF (1<<1)
136 #define LCDISR_BOF (1<<0)
137
138 /* Used fb-mode. Can be set on kernel command line, therefore file-static. */
139 static const char *fb_mode;
140
141
142 /*
143 * These are the bitfields for each
144 * display depth that we support.
145 */
146 struct imxfb_rgb {
147 struct fb_bitfield red;
148 struct fb_bitfield green;
149 struct fb_bitfield blue;
150 struct fb_bitfield transp;
151 };
152
153 struct imxfb_info {
154 struct platform_device *pdev;
155 void __iomem *regs;
156 struct clk *clk;
157
158 /*
159 * These are the addresses we mapped
160 * the framebuffer memory region to.
161 */
162 dma_addr_t map_dma;
163 u_char *map_cpu;
164 u_int map_size;
165
166 u_char *screen_cpu;
167 dma_addr_t screen_dma;
168 u_int palette_size;
169
170 dma_addr_t dbar1;
171 dma_addr_t dbar2;
172
173 u_int pcr;
174 u_int pwmr;
175 u_int lscr1;
176 u_int dmacr;
177 u_int cmap_inverse:1,
178 cmap_static:1,
179 unused:30;
180
181 struct imx_fb_videomode *mode;
182 int num_modes;
183 #ifdef PWMR_BACKLIGHT_AVAILABLE
184 struct backlight_device *bl;
185 #endif
186
187 void (*lcd_power)(int);
188 void (*backlight_power)(int);
189 };
190
191 #define IMX_NAME "IMX"
192
193 /*
194 * Minimum X and Y resolutions
195 */
196 #define MIN_XRES 64
197 #define MIN_YRES 64
198
199 /* Actually this really is 18bit support, the lowest 2 bits of each colour
200 * are unused in hardware. We claim to have 24bit support to make software
201 * like X work, which does not support 18bit.
202 */
203 static struct imxfb_rgb def_rgb_18 = {
204 .red = {.offset = 16, .length = 8,},
205 .green = {.offset = 8, .length = 8,},
206 .blue = {.offset = 0, .length = 8,},
207 .transp = {.offset = 0, .length = 0,},
208 };
209
210 static struct imxfb_rgb def_rgb_16_tft = {
211 .red = {.offset = 11, .length = 5,},
212 .green = {.offset = 5, .length = 6,},
213 .blue = {.offset = 0, .length = 5,},
214 .transp = {.offset = 0, .length = 0,},
215 };
216
217 static struct imxfb_rgb def_rgb_16_stn = {
218 .red = {.offset = 8, .length = 4,},
219 .green = {.offset = 4, .length = 4,},
220 .blue = {.offset = 0, .length = 4,},
221 .transp = {.offset = 0, .length = 0,},
222 };
223
224 static struct imxfb_rgb def_rgb_8 = {
225 .red = {.offset = 0, .length = 8,},
226 .green = {.offset = 0, .length = 8,},
227 .blue = {.offset = 0, .length = 8,},
228 .transp = {.offset = 0, .length = 0,},
229 };
230
231 static int imxfb_activate_var(struct fb_var_screeninfo *var,
232 struct fb_info *info);
233
234 static inline u_int chan_to_field(u_int chan, struct fb_bitfield *bf)
235 {
236 chan &= 0xffff;
237 chan >>= 16 - bf->length;
238 return chan << bf->offset;
239 }
240
241 static int imxfb_setpalettereg(u_int regno, u_int red, u_int green, u_int blue,
242 u_int trans, struct fb_info *info)
243 {
244 struct imxfb_info *fbi = info->par;
245 u_int val, ret = 1;
246
247 #define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16)
248 if (regno < fbi->palette_size) {
249 val = (CNVT_TOHW(red, 4) << 8) |
250 (CNVT_TOHW(green,4) << 4) |
251 CNVT_TOHW(blue, 4);
252
253 writel(val, fbi->regs + 0x800 + (regno << 2));
254 ret = 0;
255 }
256 return ret;
257 }
258
259 static int imxfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
260 u_int trans, struct fb_info *info)
261 {
262 struct imxfb_info *fbi = info->par;
263 unsigned int val;
264 int ret = 1;
265
266 /*
267 * If inverse mode was selected, invert all the colours
268 * rather than the register number. The register number
269 * is what you poke into the framebuffer to produce the
270 * colour you requested.
271 */
272 if (fbi->cmap_inverse) {
273 red = 0xffff - red;
274 green = 0xffff - green;
275 blue = 0xffff - blue;
276 }
277
278 /*
279 * If greyscale is true, then we convert the RGB value
280 * to greyscale no mater what visual we are using.
281 */
282 if (info->var.grayscale)
283 red = green = blue = (19595 * red + 38470 * green +
284 7471 * blue) >> 16;
285
286 switch (info->fix.visual) {
287 case FB_VISUAL_TRUECOLOR:
288 /*
289 * 12 or 16-bit True Colour. We encode the RGB value
290 * according to the RGB bitfield information.
291 */
292 if (regno < 16) {
293 u32 *pal = info->pseudo_palette;
294
295 val = chan_to_field(red, &info->var.red);
296 val |= chan_to_field(green, &info->var.green);
297 val |= chan_to_field(blue, &info->var.blue);
298
299 pal[regno] = val;
300 ret = 0;
301 }
302 break;
303
304 case FB_VISUAL_STATIC_PSEUDOCOLOR:
305 case FB_VISUAL_PSEUDOCOLOR:
306 ret = imxfb_setpalettereg(regno, red, green, blue, trans, info);
307 break;
308 }
309
310 return ret;
311 }
312
313 static const struct imx_fb_videomode *imxfb_find_mode(struct imxfb_info *fbi)
314 {
315 struct imx_fb_videomode *m;
316 int i;
317
318 for (i = 0, m = &fbi->mode[0]; i < fbi->num_modes; i++, m++) {
319 if (!strcmp(m->mode.name, fb_mode))
320 return m;
321 }
322 return NULL;
323 }
324
325 /*
326 * imxfb_check_var():
327 * Round up in the following order: bits_per_pixel, xres,
328 * yres, xres_virtual, yres_virtual, xoffset, yoffset, grayscale,
329 * bitfields, horizontal timing, vertical timing.
330 */
331 static int imxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
332 {
333 struct imxfb_info *fbi = info->par;
334 struct imxfb_rgb *rgb;
335 const struct imx_fb_videomode *imxfb_mode;
336 unsigned long lcd_clk;
337 unsigned long long tmp;
338 u32 pcr = 0;
339
340 if (var->xres < MIN_XRES)
341 var->xres = MIN_XRES;
342 if (var->yres < MIN_YRES)
343 var->yres = MIN_YRES;
344
345 imxfb_mode = imxfb_find_mode(fbi);
346 if (!imxfb_mode)
347 return -EINVAL;
348
349 var->xres = imxfb_mode->mode.xres;
350 var->yres = imxfb_mode->mode.yres;
351 var->bits_per_pixel = imxfb_mode->bpp;
352 var->pixclock = imxfb_mode->mode.pixclock;
353 var->hsync_len = imxfb_mode->mode.hsync_len;
354 var->left_margin = imxfb_mode->mode.left_margin;
355 var->right_margin = imxfb_mode->mode.right_margin;
356 var->vsync_len = imxfb_mode->mode.vsync_len;
357 var->upper_margin = imxfb_mode->mode.upper_margin;
358 var->lower_margin = imxfb_mode->mode.lower_margin;
359 var->sync = imxfb_mode->mode.sync;
360 var->xres_virtual = max(var->xres_virtual, var->xres);
361 var->yres_virtual = max(var->yres_virtual, var->yres);
362
363 pr_debug("var->bits_per_pixel=%d\n", var->bits_per_pixel);
364
365 lcd_clk = clk_get_rate(fbi->clk);
366
367 tmp = var->pixclock * (unsigned long long)lcd_clk;
368
369 do_div(tmp, 1000000);
370
371 if (do_div(tmp, 1000000) > 500000)
372 tmp++;
373
374 pcr = (unsigned int)tmp;
375
376 if (--pcr > 0x3F) {
377 pcr = 0x3F;
378 printk(KERN_WARNING "Must limit pixel clock to %luHz\n",
379 lcd_clk / pcr);
380 }
381
382 switch (var->bits_per_pixel) {
383 case 32:
384 pcr |= PCR_BPIX_18;
385 rgb = &def_rgb_18;
386 break;
387 case 16:
388 default:
389 if (cpu_is_mx1())
390 pcr |= PCR_BPIX_12;
391 else
392 pcr |= PCR_BPIX_16;
393
394 if (imxfb_mode->pcr & PCR_TFT)
395 rgb = &def_rgb_16_tft;
396 else
397 rgb = &def_rgb_16_stn;
398 break;
399 case 8:
400 pcr |= PCR_BPIX_8;
401 rgb = &def_rgb_8;
402 break;
403 }
404
405 /* add sync polarities */
406 pcr |= imxfb_mode->pcr & ~(0x3f | (7 << 25));
407
408 fbi->pcr = pcr;
409
410 /*
411 * Copy the RGB parameters for this display
412 * from the machine specific parameters.
413 */
414 var->red = rgb->red;
415 var->green = rgb->green;
416 var->blue = rgb->blue;
417 var->transp = rgb->transp;
418
419 pr_debug("RGBT length = %d:%d:%d:%d\n",
420 var->red.length, var->green.length, var->blue.length,
421 var->transp.length);
422
423 pr_debug("RGBT offset = %d:%d:%d:%d\n",
424 var->red.offset, var->green.offset, var->blue.offset,
425 var->transp.offset);
426
427 return 0;
428 }
429
430 /*
431 * imxfb_set_par():
432 * Set the user defined part of the display for the specified console
433 */
434 static int imxfb_set_par(struct fb_info *info)
435 {
436 struct imxfb_info *fbi = info->par;
437 struct fb_var_screeninfo *var = &info->var;
438
439 if (var->bits_per_pixel == 16 || var->bits_per_pixel == 32)
440 info->fix.visual = FB_VISUAL_TRUECOLOR;
441 else if (!fbi->cmap_static)
442 info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
443 else {
444 /*
445 * Some people have weird ideas about wanting static
446 * pseudocolor maps. I suspect their user space
447 * applications are broken.
448 */
449 info->fix.visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
450 }
451
452 info->fix.line_length = var->xres_virtual * var->bits_per_pixel / 8;
453 fbi->palette_size = var->bits_per_pixel == 8 ? 256 : 16;
454
455 imxfb_activate_var(var, info);
456
457 return 0;
458 }
459
460 #ifdef PWMR_BACKLIGHT_AVAILABLE
461 static int imxfb_bl_get_brightness(struct backlight_device *bl)
462 {
463 struct imxfb_info *fbi = bl_get_data(bl);
464
465 return readl(fbi->regs + LCDC_PWMR) & 0xFF;
466 }
467
468 static int imxfb_bl_update_status(struct backlight_device *bl)
469 {
470 struct imxfb_info *fbi = bl_get_data(bl);
471 int brightness = bl->props.brightness;
472
473 if (bl->props.power != FB_BLANK_UNBLANK)
474 brightness = 0;
475 if (bl->props.fb_blank != FB_BLANK_UNBLANK)
476 brightness = 0;
477
478 fbi->pwmr = (fbi->pwmr & ~0xFF) | brightness;
479
480 if (bl->props.fb_blank != FB_BLANK_UNBLANK)
481 clk_enable(fbi->clk);
482 writel(fbi->pwmr, fbi->regs + LCDC_PWMR);
483 if (bl->props.fb_blank != FB_BLANK_UNBLANK)
484 clk_disable(fbi->clk);
485
486 return 0;
487 }
488
489 static const struct backlight_ops imxfb_lcdc_bl_ops = {
490 .update_status = imxfb_bl_update_status,
491 .get_brightness = imxfb_bl_get_brightness,
492 };
493
494 static void imxfb_init_backlight(struct imxfb_info *fbi)
495 {
496 struct backlight_properties props;
497 struct backlight_device *bl;
498
499 if (fbi->bl)
500 return;
501
502 memset(&props, 0, sizeof(struct backlight_properties));
503 props.max_brightness = 0xff;
504 writel(fbi->pwmr, fbi->regs + LCDC_PWMR);
505
506 bl = backlight_device_register("imxfb-bl", &fbi->pdev->dev, fbi,
507 &imxfb_lcdc_bl_ops, &props);
508 if (IS_ERR(bl)) {
509 dev_err(&fbi->pdev->dev, "error %ld on backlight register\n",
510 PTR_ERR(bl));
511 return;
512 }
513
514 fbi->bl = bl;
515 bl->props.power = FB_BLANK_UNBLANK;
516 bl->props.fb_blank = FB_BLANK_UNBLANK;
517 bl->props.brightness = imxfb_bl_get_brightness(bl);
518 }
519
520 static void imxfb_exit_backlight(struct imxfb_info *fbi)
521 {
522 if (fbi->bl)
523 backlight_device_unregister(fbi->bl);
524 }
525 #endif
526
527 static void imxfb_enable_controller(struct imxfb_info *fbi)
528 {
529 pr_debug("Enabling LCD controller\n");
530
531 writel(fbi->screen_dma, fbi->regs + LCDC_SSA);
532
533 /* panning offset 0 (0 pixel offset) */
534 writel(0x00000000, fbi->regs + LCDC_POS);
535
536 /* disable hardware cursor */
537 writel(readl(fbi->regs + LCDC_CPOS) & ~(CPOS_CC0 | CPOS_CC1),
538 fbi->regs + LCDC_CPOS);
539
540 writel(RMCR_LCDC_EN, fbi->regs + LCDC_RMCR);
541
542 clk_enable(fbi->clk);
543
544 if (fbi->backlight_power)
545 fbi->backlight_power(1);
546 if (fbi->lcd_power)
547 fbi->lcd_power(1);
548 }
549
550 static void imxfb_disable_controller(struct imxfb_info *fbi)
551 {
552 pr_debug("Disabling LCD controller\n");
553
554 if (fbi->backlight_power)
555 fbi->backlight_power(0);
556 if (fbi->lcd_power)
557 fbi->lcd_power(0);
558
559 clk_disable(fbi->clk);
560
561 writel(0, fbi->regs + LCDC_RMCR);
562 }
563
564 static int imxfb_blank(int blank, struct fb_info *info)
565 {
566 struct imxfb_info *fbi = info->par;
567
568 pr_debug("imxfb_blank: blank=%d\n", blank);
569
570 switch (blank) {
571 case FB_BLANK_POWERDOWN:
572 case FB_BLANK_VSYNC_SUSPEND:
573 case FB_BLANK_HSYNC_SUSPEND:
574 case FB_BLANK_NORMAL:
575 imxfb_disable_controller(fbi);
576 break;
577
578 case FB_BLANK_UNBLANK:
579 imxfb_enable_controller(fbi);
580 break;
581 }
582 return 0;
583 }
584
585 static struct fb_ops imxfb_ops = {
586 .owner = THIS_MODULE,
587 .fb_check_var = imxfb_check_var,
588 .fb_set_par = imxfb_set_par,
589 .fb_setcolreg = imxfb_setcolreg,
590 .fb_fillrect = cfb_fillrect,
591 .fb_copyarea = cfb_copyarea,
592 .fb_imageblit = cfb_imageblit,
593 .fb_blank = imxfb_blank,
594 };
595
596 /*
597 * imxfb_activate_var():
598 * Configures LCD Controller based on entries in var parameter. Settings are
599 * only written to the controller if changes were made.
600 */
601 static int imxfb_activate_var(struct fb_var_screeninfo *var, struct fb_info *info)
602 {
603 struct imxfb_info *fbi = info->par;
604
605 pr_debug("var: xres=%d hslen=%d lm=%d rm=%d\n",
606 var->xres, var->hsync_len,
607 var->left_margin, var->right_margin);
608 pr_debug("var: yres=%d vslen=%d um=%d bm=%d\n",
609 var->yres, var->vsync_len,
610 var->upper_margin, var->lower_margin);
611
612 #if DEBUG_VAR
613 if (var->xres < 16 || var->xres > 1024)
614 printk(KERN_ERR "%s: invalid xres %d\n",
615 info->fix.id, var->xres);
616 if (var->hsync_len < 1 || var->hsync_len > 64)
617 printk(KERN_ERR "%s: invalid hsync_len %d\n",
618 info->fix.id, var->hsync_len);
619 if (var->left_margin > 255)
620 printk(KERN_ERR "%s: invalid left_margin %d\n",
621 info->fix.id, var->left_margin);
622 if (var->right_margin > 255)
623 printk(KERN_ERR "%s: invalid right_margin %d\n",
624 info->fix.id, var->right_margin);
625 if (var->yres < 1 || var->yres > 511)
626 printk(KERN_ERR "%s: invalid yres %d\n",
627 info->fix.id, var->yres);
628 if (var->vsync_len > 100)
629 printk(KERN_ERR "%s: invalid vsync_len %d\n",
630 info->fix.id, var->vsync_len);
631 if (var->upper_margin > 63)
632 printk(KERN_ERR "%s: invalid upper_margin %d\n",
633 info->fix.id, var->upper_margin);
634 if (var->lower_margin > 255)
635 printk(KERN_ERR "%s: invalid lower_margin %d\n",
636 info->fix.id, var->lower_margin);
637 #endif
638
639 /* physical screen start address */
640 writel(VPW_VPW(var->xres * var->bits_per_pixel / 8 / 4),
641 fbi->regs + LCDC_VPW);
642
643 writel(HCR_H_WIDTH(var->hsync_len - 1) |
644 HCR_H_WAIT_1(var->right_margin - 1) |
645 HCR_H_WAIT_2(var->left_margin - 3),
646 fbi->regs + LCDC_HCR);
647
648 writel(VCR_V_WIDTH(var->vsync_len) |
649 VCR_V_WAIT_1(var->lower_margin) |
650 VCR_V_WAIT_2(var->upper_margin),
651 fbi->regs + LCDC_VCR);
652
653 writel(SIZE_XMAX(var->xres) | SIZE_YMAX(var->yres),
654 fbi->regs + LCDC_SIZE);
655
656 writel(fbi->pcr, fbi->regs + LCDC_PCR);
657 #ifndef PWMR_BACKLIGHT_AVAILABLE
658 writel(fbi->pwmr, fbi->regs + LCDC_PWMR);
659 #endif
660 writel(fbi->lscr1, fbi->regs + LCDC_LSCR1);
661 writel(fbi->dmacr, fbi->regs + LCDC_DMACR);
662
663 return 0;
664 }
665
666 #ifdef CONFIG_PM
667 /*
668 * Power management hooks. Note that we won't be called from IRQ context,
669 * unlike the blank functions above, so we may sleep.
670 */
671 static int imxfb_suspend(struct platform_device *dev, pm_message_t state)
672 {
673 struct fb_info *info = platform_get_drvdata(dev);
674 struct imxfb_info *fbi = info->par;
675
676 pr_debug("%s\n", __func__);
677
678 imxfb_disable_controller(fbi);
679 return 0;
680 }
681
682 static int imxfb_resume(struct platform_device *dev)
683 {
684 struct fb_info *info = platform_get_drvdata(dev);
685 struct imxfb_info *fbi = info->par;
686
687 pr_debug("%s\n", __func__);
688
689 imxfb_enable_controller(fbi);
690 return 0;
691 }
692 #else
693 #define imxfb_suspend NULL
694 #define imxfb_resume NULL
695 #endif
696
697 static int __init imxfb_init_fbinfo(struct platform_device *pdev)
698 {
699 struct imx_fb_platform_data *pdata = pdev->dev.platform_data;
700 struct fb_info *info = dev_get_drvdata(&pdev->dev);
701 struct imxfb_info *fbi = info->par;
702 struct imx_fb_videomode *m;
703 int i;
704
705 pr_debug("%s\n",__func__);
706
707 info->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
708 if (!info->pseudo_palette)
709 return -ENOMEM;
710
711 memset(fbi, 0, sizeof(struct imxfb_info));
712
713 strlcpy(info->fix.id, IMX_NAME, sizeof(info->fix.id));
714
715 info->fix.type = FB_TYPE_PACKED_PIXELS;
716 info->fix.type_aux = 0;
717 info->fix.xpanstep = 0;
718 info->fix.ypanstep = 0;
719 info->fix.ywrapstep = 0;
720 info->fix.accel = FB_ACCEL_NONE;
721
722 info->var.nonstd = 0;
723 info->var.activate = FB_ACTIVATE_NOW;
724 info->var.height = -1;
725 info->var.width = -1;
726 info->var.accel_flags = 0;
727 info->var.vmode = FB_VMODE_NONINTERLACED;
728
729 info->fbops = &imxfb_ops;
730 info->flags = FBINFO_FLAG_DEFAULT |
731 FBINFO_READS_FAST;
732 info->var.grayscale = pdata->cmap_greyscale;
733 fbi->cmap_inverse = pdata->cmap_inverse;
734 fbi->cmap_static = pdata->cmap_static;
735 fbi->lscr1 = pdata->lscr1;
736 fbi->dmacr = pdata->dmacr;
737 fbi->pwmr = pdata->pwmr;
738 fbi->lcd_power = pdata->lcd_power;
739 fbi->backlight_power = pdata->backlight_power;
740
741 for (i = 0, m = &pdata->mode[0]; i < pdata->num_modes; i++, m++)
742 info->fix.smem_len = max_t(size_t, info->fix.smem_len,
743 m->mode.xres * m->mode.yres * m->bpp / 8);
744
745 return 0;
746 }
747
748 static int __init imxfb_probe(struct platform_device *pdev)
749 {
750 struct imxfb_info *fbi;
751 struct fb_info *info;
752 struct imx_fb_platform_data *pdata;
753 struct resource *res;
754 int ret, i;
755
756 dev_info(&pdev->dev, "i.MX Framebuffer driver\n");
757
758 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
759 if (!res)
760 return -ENODEV;
761
762 pdata = pdev->dev.platform_data;
763 if (!pdata) {
764 dev_err(&pdev->dev,"No platform_data available\n");
765 return -ENOMEM;
766 }
767
768 info = framebuffer_alloc(sizeof(struct imxfb_info), &pdev->dev);
769 if (!info)
770 return -ENOMEM;
771
772 fbi = info->par;
773
774 if (!fb_mode)
775 fb_mode = pdata->mode[0].mode.name;
776
777 platform_set_drvdata(pdev, info);
778
779 ret = imxfb_init_fbinfo(pdev);
780 if (ret < 0)
781 goto failed_init;
782
783 res = request_mem_region(res->start, resource_size(res),
784 DRIVER_NAME);
785 if (!res) {
786 ret = -EBUSY;
787 goto failed_req;
788 }
789
790 fbi->clk = clk_get(&pdev->dev, NULL);
791 if (IS_ERR(fbi->clk)) {
792 ret = PTR_ERR(fbi->clk);
793 dev_err(&pdev->dev, "unable to get clock: %d\n", ret);
794 goto failed_getclock;
795 }
796
797 fbi->regs = ioremap(res->start, resource_size(res));
798 if (fbi->regs == NULL) {
799 dev_err(&pdev->dev, "Cannot map frame buffer registers\n");
800 goto failed_ioremap;
801 }
802
803 if (!pdata->fixed_screen_cpu) {
804 fbi->map_size = PAGE_ALIGN(info->fix.smem_len);
805 fbi->map_cpu = dma_alloc_writecombine(&pdev->dev,
806 fbi->map_size, &fbi->map_dma, GFP_KERNEL);
807
808 if (!fbi->map_cpu) {
809 dev_err(&pdev->dev, "Failed to allocate video RAM: %d\n", ret);
810 ret = -ENOMEM;
811 goto failed_map;
812 }
813
814 info->screen_base = fbi->map_cpu;
815 fbi->screen_cpu = fbi->map_cpu;
816 fbi->screen_dma = fbi->map_dma;
817 info->fix.smem_start = fbi->screen_dma;
818 } else {
819 /* Fixed framebuffer mapping enables location of the screen in eSRAM */
820 fbi->map_cpu = pdata->fixed_screen_cpu;
821 fbi->map_dma = pdata->fixed_screen_dma;
822 info->screen_base = fbi->map_cpu;
823 fbi->screen_cpu = fbi->map_cpu;
824 fbi->screen_dma = fbi->map_dma;
825 info->fix.smem_start = fbi->screen_dma;
826 }
827
828 if (pdata->init) {
829 ret = pdata->init(fbi->pdev);
830 if (ret)
831 goto failed_platform_init;
832 }
833
834 fbi->mode = pdata->mode;
835 fbi->num_modes = pdata->num_modes;
836
837 INIT_LIST_HEAD(&info->modelist);
838 for (i = 0; i < pdata->num_modes; i++)
839 fb_add_videomode(&pdata->mode[i].mode, &info->modelist);
840
841 /*
842 * This makes sure that our colour bitfield
843 * descriptors are correctly initialised.
844 */
845 imxfb_check_var(&info->var, info);
846
847 ret = fb_alloc_cmap(&info->cmap, 1 << info->var.bits_per_pixel, 0);
848 if (ret < 0)
849 goto failed_cmap;
850
851 imxfb_set_par(info);
852 ret = register_framebuffer(info);
853 if (ret < 0) {
854 dev_err(&pdev->dev, "failed to register framebuffer\n");
855 goto failed_register;
856 }
857
858 imxfb_enable_controller(fbi);
859 fbi->pdev = pdev;
860 #ifdef PWMR_BACKLIGHT_AVAILABLE
861 imxfb_init_backlight(fbi);
862 #endif
863
864 return 0;
865
866 failed_register:
867 fb_dealloc_cmap(&info->cmap);
868 failed_cmap:
869 if (pdata->exit)
870 pdata->exit(fbi->pdev);
871 failed_platform_init:
872 if (!pdata->fixed_screen_cpu)
873 dma_free_writecombine(&pdev->dev,fbi->map_size,fbi->map_cpu,
874 fbi->map_dma);
875 failed_map:
876 clk_put(fbi->clk);
877 failed_getclock:
878 iounmap(fbi->regs);
879 failed_ioremap:
880 release_mem_region(res->start, resource_size(res));
881 failed_req:
882 kfree(info->pseudo_palette);
883 failed_init:
884 platform_set_drvdata(pdev, NULL);
885 framebuffer_release(info);
886 return ret;
887 }
888
889 static int __devexit imxfb_remove(struct platform_device *pdev)
890 {
891 struct imx_fb_platform_data *pdata;
892 struct fb_info *info = platform_get_drvdata(pdev);
893 struct imxfb_info *fbi = info->par;
894 struct resource *res;
895
896 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
897
898 imxfb_disable_controller(fbi);
899
900 #ifdef PWMR_BACKLIGHT_AVAILABLE
901 imxfb_exit_backlight(fbi);
902 #endif
903 unregister_framebuffer(info);
904
905 pdata = pdev->dev.platform_data;
906 if (pdata->exit)
907 pdata->exit(fbi->pdev);
908
909 fb_dealloc_cmap(&info->cmap);
910 kfree(info->pseudo_palette);
911 framebuffer_release(info);
912
913 iounmap(fbi->regs);
914 release_mem_region(res->start, resource_size(res));
915 clk_disable(fbi->clk);
916 clk_put(fbi->clk);
917
918 platform_set_drvdata(pdev, NULL);
919
920 return 0;
921 }
922
923 void imxfb_shutdown(struct platform_device * dev)
924 {
925 struct fb_info *info = platform_get_drvdata(dev);
926 struct imxfb_info *fbi = info->par;
927 imxfb_disable_controller(fbi);
928 }
929
930 static struct platform_driver imxfb_driver = {
931 .suspend = imxfb_suspend,
932 .resume = imxfb_resume,
933 .remove = __devexit_p(imxfb_remove),
934 .shutdown = imxfb_shutdown,
935 .driver = {
936 .name = DRIVER_NAME,
937 },
938 };
939
940 static int imxfb_setup(void)
941 {
942 #ifndef MODULE
943 char *opt, *options = NULL;
944
945 if (fb_get_options("imxfb", &options))
946 return -ENODEV;
947
948 if (!options || !*options)
949 return 0;
950
951 while ((opt = strsep(&options, ",")) != NULL) {
952 if (!*opt)
953 continue;
954 else
955 fb_mode = opt;
956 }
957 #endif
958 return 0;
959 }
960
961 int __init imxfb_init(void)
962 {
963 int ret = imxfb_setup();
964
965 if (ret < 0)
966 return ret;
967
968 return platform_driver_probe(&imxfb_driver, imxfb_probe);
969 }
970
971 static void __exit imxfb_cleanup(void)
972 {
973 platform_driver_unregister(&imxfb_driver);
974 }
975
976 module_init(imxfb_init);
977 module_exit(imxfb_cleanup);
978
979 MODULE_DESCRIPTION("Motorola i.MX framebuffer driver");
980 MODULE_AUTHOR("Sascha Hauer, Pengutronix");
981 MODULE_LICENSE("GPL");
Tomato firmware and modifications.