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