← Back to branch summary

~ubuntu-branches/ubuntu/karmic/linux-ports/karmic

« back to all changes in this revision

Viewing changes to drivers/video/imxfb.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich, Luke Yelavich, Michael Casadevall, Tim Gardner, Upstream Kernel Changes
  • Date: 2009-05-06 18:18:55 UTC
  • Revision ID: james.westby@ubuntu.com-20090506181855-t00baeevpnvd9o7a
Tags: 2.6.30-1.1
[ Luke Yelavich ]
* initial release for karmic
* SAUCE: rebase-ports - adjust for the karmic ports kernel
* SAUCE: rebase-ports - also remove abi dirs/files on rebase
* Update configs after rebase against mainline Jaunty tree
* [Config] Disable CONFIG_BLK_DEV_UB and CONFIG_USB_LIBUSUAL as per
  mainline jaunty
* forward-port patch to drbd for powerpc compilation
* [Config] disable CONFIG_LENOVO_SL_LAPTOP for i386 due to FTBFS
* add .o files found in arch/powerpc/lib to all powerpc kernel header
  packages
* [Config] enable CONFIG_DRM_I915_KMS for i386 as per karmic mainline

[ Michael Casadevall ]

* Disable kgdb on sparc64
* [sparc] [Config] Disable GPIO LEDS
* [ia64] Rename -ia64-generic to -ia64 in line with other architectures
* Correct kernel image path for sparc builds
* [hppa] Fix HPPA config files to build modules for all udebian

Rebase on top of karmic mainline 2.6.30-1.1

[ Tim Gardner ]

* [Config] armel: disable staging drivers, fixes FTBS
* [Config] armel imx51: Disable CONFIG_MTD_NAND_MXC, fixes FTBS

[ Upstream Kernel Changes ]

* mpt2sas: Change reset_type enum to avoid namespace collision.
  Submitted upstream.

* Initial release after rebasing against v2.6.30-rc3

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/video/imxfb.c
1
1
/*
2
 
 *  linux/drivers/video/imxfb.c
3
 
 *
4
2
 *  Freescale i.MX Frame Buffer device driver
5
3
 *
6
4
 *  Copyright (C) 2004 Sascha Hauer, Pengutronix
16
14
 *      linux-arm-kernel@lists.arm.linux.org.uk
17
15
 */
18
16
 
19
 
//#define DEBUG 1
20
 
 
21
17
#include <linux/module.h>
22
18
#include <linux/kernel.h>
23
19
#include <linux/errno.h>
30
26
#include <linux/init.h>
31
27
#include <linux/ioport.h>
32
28
#include <linux/cpufreq.h>
 
29
#include <linux/clk.h>
33
30
#include <linux/platform_device.h>
34
31
#include <linux/dma-mapping.h>
 
32
#include <linux/io.h>
 
33
#include <linux/math64.h>
35
34
 
36
 
#include <mach/hardware.h>
37
 
#include <asm/io.h>
38
35
#include <mach/imxfb.h>
39
36
 
40
37
/*
42
39
 */
43
40
#define DEBUG_VAR 1
44
41
 
45
 
#include "imxfb.h"
46
 
 
47
 
static struct imxfb_rgb def_rgb_16 = {
48
 
        .red    = { .offset = 8,  .length = 4, },
49
 
        .green  = { .offset = 4,  .length = 4, },
50
 
        .blue   = { .offset = 0,  .length = 4, },
51
 
        .transp = { .offset = 0,  .length = 0, },
 
42
#define DRIVER_NAME "imx-fb"
 
43
 
 
44
#define LCDC_SSA        0x00
 
45
 
 
46
#define LCDC_SIZE       0x04
 
47
#define SIZE_XMAX(x)    ((((x) >> 4) & 0x3f) << 20)
 
48
 
 
49
#ifdef CONFIG_ARCH_MX1
 
50
#define SIZE_YMAX(y)    ((y) & 0x1ff)
 
51
#else
 
52
#define SIZE_YMAX(y)    ((y) & 0x3ff)
 
53
#endif
 
54
 
 
55
#define LCDC_VPW        0x08
 
56
#define VPW_VPW(x)      ((x) & 0x3ff)
 
57
 
 
58
#define LCDC_CPOS       0x0C
 
59
#define CPOS_CC1        (1<<31)
 
60
#define CPOS_CC0        (1<<30)
 
61
#define CPOS_OP         (1<<28)
 
62
#define CPOS_CXP(x)     (((x) & 3ff) << 16)
 
63
 
 
64
#ifdef CONFIG_ARCH_MX1
 
65
#define CPOS_CYP(y)     ((y) & 0x1ff)
 
66
#else
 
67
#define CPOS_CYP(y)     ((y) & 0x3ff)
 
68
#endif
 
69
 
 
70
#define LCDC_LCWHB      0x10
 
71
#define LCWHB_BK_EN     (1<<31)
 
72
#define LCWHB_CW(w)     (((w) & 0x1f) << 24)
 
73
#define LCWHB_CH(h)     (((h) & 0x1f) << 16)
 
74
#define LCWHB_BD(x)     ((x) & 0xff)
 
75
 
 
76
#define LCDC_LCHCC      0x14
 
77
 
 
78
#ifdef CONFIG_ARCH_MX1
 
79
#define LCHCC_CUR_COL_R(r) (((r) & 0x1f) << 11)
 
80
#define LCHCC_CUR_COL_G(g) (((g) & 0x3f) << 5)
 
81
#define LCHCC_CUR_COL_B(b) ((b) & 0x1f)
 
82
#else
 
83
#define LCHCC_CUR_COL_R(r) (((r) & 0x3f) << 12)
 
84
#define LCHCC_CUR_COL_G(g) (((g) & 0x3f) << 6)
 
85
#define LCHCC_CUR_COL_B(b) ((b) & 0x3f)
 
86
#endif
 
87
 
 
88
#define LCDC_PCR        0x18
 
89
 
 
90
#define LCDC_HCR        0x1C
 
91
#define HCR_H_WIDTH(x)  (((x) & 0x3f) << 26)
 
92
#define HCR_H_WAIT_1(x) (((x) & 0xff) << 8)
 
93
#define HCR_H_WAIT_2(x) ((x) & 0xff)
 
94
 
 
95
#define LCDC_VCR        0x20
 
96
#define VCR_V_WIDTH(x)  (((x) & 0x3f) << 26)
 
97
#define VCR_V_WAIT_1(x) (((x) & 0xff) << 8)
 
98
#define VCR_V_WAIT_2(x) ((x) & 0xff)
 
99
 
 
100
#define LCDC_POS        0x24
 
101
#define POS_POS(x)      ((x) & 1f)
 
102
 
 
103
#define LCDC_LSCR1      0x28
 
104
/* bit fields in imxfb.h */
 
105
 
 
106
#define LCDC_PWMR       0x2C
 
107
/* bit fields in imxfb.h */
 
108
 
 
109
#define LCDC_DMACR      0x30
 
110
/* bit fields in imxfb.h */
 
111
 
 
112
#define LCDC_RMCR       0x34
 
113
 
 
114
#ifdef CONFIG_ARCH_MX1
 
115
#define RMCR_LCDC_EN    (1<<1)
 
116
#else
 
117
#define RMCR_LCDC_EN    0
 
118
#endif
 
119
 
 
120
#define RMCR_SELF_REF   (1<<0)
 
121
 
 
122
#define LCDC_LCDICR     0x38
 
123
#define LCDICR_INT_SYN  (1<<2)
 
124
#define LCDICR_INT_CON  (1)
 
125
 
 
126
#define LCDC_LCDISR     0x40
 
127
#define LCDISR_UDR_ERR  (1<<3)
 
128
#define LCDISR_ERR_RES  (1<<2)
 
129
#define LCDISR_EOF      (1<<1)
 
130
#define LCDISR_BOF      (1<<0)
 
131
 
 
132
/*
 
133
 * These are the bitfields for each
 
134
 * display depth that we support.
 
135
 */
 
136
struct imxfb_rgb {
 
137
        struct fb_bitfield      red;
 
138
        struct fb_bitfield      green;
 
139
        struct fb_bitfield      blue;
 
140
        struct fb_bitfield      transp;
 
141
};
 
142
 
 
143
struct imxfb_info {
 
144
        struct platform_device  *pdev;
 
145
        void __iomem            *regs;
 
146
        struct clk              *clk;
 
147
 
 
148
        u_int                   max_bpp;
 
149
        u_int                   max_xres;
 
150
        u_int                   max_yres;
 
151
 
 
152
        /*
 
153
         * These are the addresses we mapped
 
154
         * the framebuffer memory region to.
 
155
         */
 
156
        dma_addr_t              map_dma;
 
157
        u_char                  *map_cpu;
 
158
        u_int                   map_size;
 
159
 
 
160
        u_char                  *screen_cpu;
 
161
        dma_addr_t              screen_dma;
 
162
        u_int                   palette_size;
 
163
 
 
164
        dma_addr_t              dbar1;
 
165
        dma_addr_t              dbar2;
 
166
 
 
167
        u_int                   pcr;
 
168
        u_int                   pwmr;
 
169
        u_int                   lscr1;
 
170
        u_int                   dmacr;
 
171
        u_int                   cmap_inverse:1,
 
172
                                cmap_static:1,
 
173
                                unused:30;
 
174
 
 
175
        void (*lcd_power)(int);
 
176
        void (*backlight_power)(int);
 
177
};
 
178
 
 
179
#define IMX_NAME        "IMX"
 
180
 
 
181
/*
 
182
 * Minimum X and Y resolutions
 
183
 */
 
184
#define MIN_XRES        64
 
185
#define MIN_YRES        64
 
186
 
 
187
/* Actually this really is 18bit support, the lowest 2 bits of each colour
 
188
 * are unused in hardware. We claim to have 24bit support to make software
 
189
 * like X work, which does not support 18bit.
 
190
 */
 
191
static struct imxfb_rgb def_rgb_18 = {
 
192
        .red    = {.offset = 16, .length = 8,},
 
193
        .green  = {.offset = 8, .length = 8,},
 
194
        .blue   = {.offset = 0, .length = 8,},
 
195
        .transp = {.offset = 0, .length = 0,},
 
196
};
 
197
 
 
198
static struct imxfb_rgb def_rgb_16_tft = {
 
199
        .red    = {.offset = 11, .length = 5,},
 
200
        .green  = {.offset = 5, .length = 6,},
 
201
        .blue   = {.offset = 0, .length = 5,},
 
202
        .transp = {.offset = 0, .length = 0,},
 
203
};
 
204
 
 
205
static struct imxfb_rgb def_rgb_16_stn = {
 
206
        .red    = {.offset = 8, .length = 4,},
 
207
        .green  = {.offset = 4, .length = 4,},
 
208
        .blue   = {.offset = 0, .length = 4,},
 
209
        .transp = {.offset = 0, .length = 0,},
52
210
};
53
211
 
54
212
static struct imxfb_rgb def_rgb_8 = {
55
 
        .red    = { .offset = 0,  .length = 8, },
56
 
        .green  = { .offset = 0,  .length = 8, },
57
 
        .blue   = { .offset = 0,  .length = 8, },
58
 
        .transp = { .offset = 0,  .length = 0, },
 
213
        .red    = {.offset = 0, .length = 8,},
 
214
        .green  = {.offset = 0, .length = 8,},
 
215
        .blue   = {.offset = 0, .length = 8,},
 
216
        .transp = {.offset = 0, .length = 0,},
59
217
};
60
218
 
61
 
static int imxfb_activate_var(struct fb_var_screeninfo *var, struct fb_info *info);
 
219
static int imxfb_activate_var(struct fb_var_screeninfo *var,
 
220
                struct fb_info *info);
62
221
 
63
222
static inline u_int chan_to_field(u_int chan, struct fb_bitfield *bf)
64
223
{
67
226
        return chan << bf->offset;
68
227
}
69
228
 
70
 
#define LCDC_PALETTE(x) __REG2(IMX_LCDC_BASE+0x800, (x)<<2)
71
 
static int
72
 
imxfb_setpalettereg(u_int regno, u_int red, u_int green, u_int blue,
73
 
                       u_int trans, struct fb_info *info)
 
229
static int imxfb_setpalettereg(u_int regno, u_int red, u_int green, u_int blue,
 
230
                u_int trans, struct fb_info *info)
74
231
{
75
232
        struct imxfb_info *fbi = info->par;
76
233
        u_int val, ret = 1;
81
238
                      (CNVT_TOHW(green,4) << 4) |
82
239
                      CNVT_TOHW(blue,  4);
83
240
 
84
 
                LCDC_PALETTE(regno) = val;
 
241
                writel(val, fbi->regs + 0x800 + (regno << 2));
85
242
                ret = 0;
86
243
        }
87
244
        return ret;
88
245
}
89
246
 
90
 
static int
91
 
imxfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 
247
static int imxfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
92
248
                   u_int trans, struct fb_info *info)
93
249
{
94
250
        struct imxfb_info *fbi = info->par;
148
304
 *    yres, xres_virtual, yres_virtual, xoffset, yoffset, grayscale,
149
305
 *    bitfields, horizontal timing, vertical timing.
150
306
 */
151
 
static int
152
 
imxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 
307
static int imxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
153
308
{
154
309
        struct imxfb_info *fbi = info->par;
155
 
        int rgbidx;
 
310
        struct imxfb_rgb *rgb;
156
311
 
157
312
        if (var->xres < MIN_XRES)
158
313
                var->xres = MIN_XRES;
167
322
 
168
323
        pr_debug("var->bits_per_pixel=%d\n", var->bits_per_pixel);
169
324
        switch (var->bits_per_pixel) {
 
325
        case 32:
 
326
                rgb = &def_rgb_18;
 
327
                break;
170
328
        case 16:
171
 
                rgbidx = RGB_16;
172
 
                break;
173
 
        case 8:
174
 
                rgbidx = RGB_8;
175
 
                break;
176
329
        default:
177
 
                rgbidx = RGB_16;
 
330
                if (fbi->pcr & PCR_TFT)
 
331
                        rgb = &def_rgb_16_tft;
 
332
                else
 
333
                        rgb = &def_rgb_16_stn;
 
334
                break;
 
335
        case 8:
 
336
                rgb = &def_rgb_8;
 
337
                break;
178
338
        }
179
339
 
180
340
        /*
181
341
         * Copy the RGB parameters for this display
182
342
         * from the machine specific parameters.
183
343
         */
184
 
        var->red    = fbi->rgb[rgbidx]->red;
185
 
        var->green  = fbi->rgb[rgbidx]->green;
186
 
        var->blue   = fbi->rgb[rgbidx]->blue;
187
 
        var->transp = fbi->rgb[rgbidx]->transp;
 
344
        var->red    = rgb->red;
 
345
        var->green  = rgb->green;
 
346
        var->blue   = rgb->blue;
 
347
        var->transp = rgb->transp;
188
348
 
189
349
        pr_debug("RGBT length = %d:%d:%d:%d\n",
190
350
                var->red.length, var->green.length, var->blue.length,
206
366
        struct imxfb_info *fbi = info->par;
207
367
        struct fb_var_screeninfo *var = &info->var;
208
368
 
209
 
        pr_debug("set_par\n");
210
 
 
211
 
        if (var->bits_per_pixel == 16)
 
369
        if (var->bits_per_pixel == 16 || var->bits_per_pixel == 32)
212
370
                info->fix.visual = FB_VISUAL_TRUECOLOR;
213
371
        else if (!fbi->cmap_static)
214
372
                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
221
379
                info->fix.visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
222
380
        }
223
381
 
224
 
        info->fix.line_length = var->xres_virtual *
225
 
                                  var->bits_per_pixel / 8;
 
382
        info->fix.line_length = var->xres_virtual * var->bits_per_pixel / 8;
226
383
        fbi->palette_size = var->bits_per_pixel == 8 ? 256 : 16;
227
384
 
228
385
        imxfb_activate_var(var, info);
234
391
{
235
392
        pr_debug("Enabling LCD controller\n");
236
393
 
237
 
        /* initialize LCDC */
238
 
        LCDC_RMCR &= ~RMCR_LCDC_EN;             /* just to be safe... */
 
394
        writel(fbi->screen_dma, fbi->regs + LCDC_SSA);
239
395
 
240
 
        LCDC_SSA        = fbi->screen_dma;
241
396
        /* physical screen start address            */
242
 
        LCDC_VPW        = VPW_VPW(fbi->max_xres * fbi->max_bpp / 8 / 4);
 
397
        writel(VPW_VPW(fbi->max_xres * fbi->max_bpp / 8 / 4),
 
398
                fbi->regs + LCDC_VPW);
243
399
 
244
 
        LCDC_POS        = 0x00000000;   /* panning offset 0 (0 pixel offset)        */
 
400
        /* panning offset 0 (0 pixel offset)        */
 
401
        writel(0x00000000, fbi->regs + LCDC_POS);
245
402
 
246
403
        /* disable hardware cursor */
247
 
        LCDC_CPOS       &= ~(CPOS_CC0 | CPOS_CC1);
248
 
 
249
 
        LCDC_RMCR = RMCR_LCDC_EN;
250
 
 
251
 
        if(fbi->backlight_power)
 
404
        writel(readl(fbi->regs + LCDC_CPOS) & ~(CPOS_CC0 | CPOS_CC1),
 
405
                fbi->regs + LCDC_CPOS);
 
406
 
 
407
        writel(RMCR_LCDC_EN, fbi->regs + LCDC_RMCR);
 
408
 
 
409
        clk_enable(fbi->clk);
 
410
 
 
411
        if (fbi->backlight_power)
252
412
                fbi->backlight_power(1);
253
 
        if(fbi->lcd_power)
 
413
        if (fbi->lcd_power)
254
414
                fbi->lcd_power(1);
255
415
}
256
416
 
258
418
{
259
419
        pr_debug("Disabling LCD controller\n");
260
420
 
261
 
        if(fbi->backlight_power)
 
421
        if (fbi->backlight_power)
262
422
                fbi->backlight_power(0);
263
 
        if(fbi->lcd_power)
 
423
        if (fbi->lcd_power)
264
424
                fbi->lcd_power(0);
265
425
 
266
 
        LCDC_RMCR = 0;
 
426
        clk_disable(fbi->clk);
 
427
 
 
428
        writel(0, fbi->regs + LCDC_RMCR);
267
429
}
268
430
 
269
431
static int imxfb_blank(int blank, struct fb_info *info)
306
468
static int imxfb_activate_var(struct fb_var_screeninfo *var, struct fb_info *info)
307
469
{
308
470
        struct imxfb_info *fbi = info->par;
 
471
        unsigned int pcr, lcd_clk;
 
472
        unsigned long long tmp;
 
473
 
309
474
        pr_debug("var: xres=%d hslen=%d lm=%d rm=%d\n",
310
475
                var->xres, var->hsync_len,
311
476
                var->left_margin, var->right_margin);
340
505
                        info->fix.id, var->lower_margin);
341
506
#endif
342
507
 
343
 
        LCDC_HCR        = HCR_H_WIDTH(var->hsync_len) |
344
 
                          HCR_H_WAIT_1(var->left_margin) |
345
 
                          HCR_H_WAIT_2(var->right_margin);
346
 
 
347
 
        LCDC_VCR        = VCR_V_WIDTH(var->vsync_len) |
348
 
                          VCR_V_WAIT_1(var->upper_margin) |
349
 
                          VCR_V_WAIT_2(var->lower_margin);
350
 
 
351
 
        LCDC_SIZE       = SIZE_XMAX(var->xres) | SIZE_YMAX(var->yres);
352
 
        LCDC_PCR        = fbi->pcr;
353
 
        LCDC_PWMR       = fbi->pwmr;
354
 
        LCDC_LSCR1      = fbi->lscr1;
355
 
        LCDC_DMACR      = fbi->dmacr;
 
508
        writel(HCR_H_WIDTH(var->hsync_len - 1) |
 
509
                HCR_H_WAIT_1(var->right_margin - 1) |
 
510
                HCR_H_WAIT_2(var->left_margin - 3),
 
511
                fbi->regs + LCDC_HCR);
 
512
 
 
513
        writel(VCR_V_WIDTH(var->vsync_len) |
 
514
                VCR_V_WAIT_1(var->lower_margin) |
 
515
                VCR_V_WAIT_2(var->upper_margin),
 
516
                fbi->regs + LCDC_VCR);
 
517
 
 
518
        writel(SIZE_XMAX(var->xres) | SIZE_YMAX(var->yres),
 
519
                        fbi->regs + LCDC_SIZE);
 
520
 
 
521
        lcd_clk = clk_get_rate(fbi->clk);
 
522
        tmp = var->pixclock * (unsigned long long)lcd_clk;
 
523
        do_div(tmp, 1000000);
 
524
        if (do_div(tmp, 1000000) > 500000)
 
525
                tmp++;
 
526
        pcr = (unsigned int)tmp;
 
527
        if (--pcr > 0x3F) {
 
528
                pcr = 0x3F;
 
529
                printk(KERN_WARNING "Must limit pixel clock to %uHz\n",
 
530
                                lcd_clk / pcr);
 
531
        }
 
532
 
 
533
        /* add sync polarities */
 
534
        pcr |= fbi->pcr & ~0x3F;
 
535
 
 
536
        writel(pcr, fbi->regs + LCDC_PCR);
 
537
        writel(fbi->pwmr, fbi->regs + LCDC_PWMR);
 
538
        writel(fbi->lscr1, fbi->regs + LCDC_LSCR1);
 
539
        writel(fbi->dmacr, fbi->regs + LCDC_DMACR);
356
540
 
357
541
        return 0;
358
542
}
359
543
 
360
 
static void imxfb_setup_gpio(struct imxfb_info *fbi)
361
 
{
362
 
        int width;
363
 
 
364
 
        LCDC_RMCR       &= ~(RMCR_LCDC_EN | RMCR_SELF_REF);
365
 
 
366
 
        if( fbi->pcr & PCR_TFT )
367
 
                width = 16;
368
 
        else
369
 
                width = 1 << ((fbi->pcr >> 28) & 0x3);
370
 
 
371
 
        switch(width) {
372
 
        case 16:
373
 
                imx_gpio_mode(PD30_PF_LD15);
374
 
                imx_gpio_mode(PD29_PF_LD14);
375
 
                imx_gpio_mode(PD28_PF_LD13);
376
 
                imx_gpio_mode(PD27_PF_LD12);
377
 
                imx_gpio_mode(PD26_PF_LD11);
378
 
                imx_gpio_mode(PD25_PF_LD10);
379
 
                imx_gpio_mode(PD24_PF_LD9);
380
 
                imx_gpio_mode(PD23_PF_LD8);
381
 
        case 8:
382
 
                imx_gpio_mode(PD22_PF_LD7);
383
 
                imx_gpio_mode(PD21_PF_LD6);
384
 
                imx_gpio_mode(PD20_PF_LD5);
385
 
                imx_gpio_mode(PD19_PF_LD4);
386
 
        case 4:
387
 
                imx_gpio_mode(PD18_PF_LD3);
388
 
                imx_gpio_mode(PD17_PF_LD2);
389
 
        case 2:
390
 
                imx_gpio_mode(PD16_PF_LD1);
391
 
        case 1:
392
 
                imx_gpio_mode(PD15_PF_LD0);
393
 
        }
394
 
 
395
 
        /* initialize GPIOs */
396
 
        imx_gpio_mode(PD6_PF_LSCLK);
397
 
        imx_gpio_mode(PD11_PF_CONTRAST);
398
 
        imx_gpio_mode(PD14_PF_FLM_VSYNC);
399
 
        imx_gpio_mode(PD13_PF_LP_HSYNC);
400
 
        imx_gpio_mode(PD12_PF_ACD_OE);
401
 
 
402
 
        /* These are only needed for Sharp HR TFT displays */
403
 
        if (fbi->pcr & PCR_SHARP) {
404
 
                imx_gpio_mode(PD7_PF_REV);
405
 
                imx_gpio_mode(PD8_PF_CLS);
406
 
                imx_gpio_mode(PD9_PF_PS);
407
 
                imx_gpio_mode(PD10_PF_SPL_SPR);
408
 
        }
409
 
}
410
 
 
411
544
#ifdef CONFIG_PM
412
545
/*
413
546
 * Power management hooks.  Note that we won't be called from IRQ context,
416
549
static int imxfb_suspend(struct platform_device *dev, pm_message_t state)
417
550
{
418
551
        struct imxfb_info *fbi = platform_get_drvdata(dev);
419
 
        pr_debug("%s\n",__func__);
 
552
 
 
553
        pr_debug("%s\n", __func__);
420
554
 
421
555
        imxfb_disable_controller(fbi);
422
556
        return 0;
425
559
static int imxfb_resume(struct platform_device *dev)
426
560
{
427
561
        struct imxfb_info *fbi = platform_get_drvdata(dev);
428
 
        pr_debug("%s\n",__func__);
 
562
 
 
563
        pr_debug("%s\n", __func__);
429
564
 
430
565
        imxfb_enable_controller(fbi);
431
566
        return 0;
435
570
#define imxfb_resume    NULL
436
571
#endif
437
572
 
438
 
static int __init imxfb_init_fbinfo(struct device *dev)
 
573
static int __init imxfb_init_fbinfo(struct platform_device *pdev)
439
574
{
440
 
        struct imxfb_mach_info *inf = dev->platform_data;
441
 
        struct fb_info *info = dev_get_drvdata(dev);
 
575
        struct imx_fb_platform_data *pdata = pdev->dev.platform_data;
 
576
        struct fb_info *info = dev_get_drvdata(&pdev->dev);
442
577
        struct imxfb_info *fbi = info->par;
443
578
 
444
579
        pr_debug("%s\n",__func__);
445
580
 
446
 
        info->pseudo_palette = kmalloc( sizeof(u32) * 16, GFP_KERNEL);
 
581
        info->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
447
582
        if (!info->pseudo_palette)
448
583
                return -ENOMEM;
449
584
 
450
585
        memset(fbi, 0, sizeof(struct imxfb_info));
451
 
        fbi->dev = dev;
452
586
 
453
587
        strlcpy(info->fix.id, IMX_NAME, sizeof(info->fix.id));
454
588
 
455
 
        info->fix.type  = FB_TYPE_PACKED_PIXELS;
 
589
        info->fix.type                  = FB_TYPE_PACKED_PIXELS;
456
590
        info->fix.type_aux              = 0;
457
591
        info->fix.xpanstep              = 0;
458
592
        info->fix.ypanstep              = 0;
459
593
        info->fix.ywrapstep             = 0;
460
 
        info->fix.accel = FB_ACCEL_NONE;
 
594
        info->fix.accel                 = FB_ACCEL_NONE;
461
595
 
462
596
        info->var.nonstd                = 0;
463
597
        info->var.activate              = FB_ACTIVATE_NOW;
464
598
        info->var.height                = -1;
465
599
        info->var.width = -1;
466
600
        info->var.accel_flags           = 0;
467
 
        info->var.vmode = FB_VMODE_NONINTERLACED;
 
601
        info->var.vmode                 = FB_VMODE_NONINTERLACED;
468
602
 
469
603
        info->fbops                     = &imxfb_ops;
470
 
        info->flags                     = FBINFO_FLAG_DEFAULT | FBINFO_READS_FAST;
471
 
 
472
 
        fbi->rgb[RGB_16]                = &def_rgb_16;
473
 
        fbi->rgb[RGB_8]                 = &def_rgb_8;
474
 
 
475
 
        fbi->max_xres                   = inf->xres;
476
 
        info->var.xres                  = inf->xres;
477
 
        info->var.xres_virtual          = inf->xres;
478
 
        fbi->max_yres                   = inf->yres;
479
 
        info->var.yres                  = inf->yres;
480
 
        info->var.yres_virtual          = inf->yres;
481
 
        fbi->max_bpp                    = inf->bpp;
482
 
        info->var.bits_per_pixel        = inf->bpp;
483
 
        info->var.nonstd                = inf->nonstd;
484
 
        info->var.pixclock              = inf->pixclock;
485
 
        info->var.hsync_len             = inf->hsync_len;
486
 
        info->var.left_margin           = inf->left_margin;
487
 
        info->var.right_margin          = inf->right_margin;
488
 
        info->var.vsync_len             = inf->vsync_len;
489
 
        info->var.upper_margin          = inf->upper_margin;
490
 
        info->var.lower_margin          = inf->lower_margin;
491
 
        info->var.sync                  = inf->sync;
492
 
        info->var.grayscale             = inf->cmap_greyscale;
493
 
        fbi->cmap_inverse               = inf->cmap_inverse;
494
 
        fbi->cmap_static                = inf->cmap_static;
495
 
        fbi->pcr                        = inf->pcr;
496
 
        fbi->lscr1                      = inf->lscr1;
497
 
        fbi->dmacr                      = inf->dmacr;
498
 
        fbi->pwmr                       = inf->pwmr;
499
 
        fbi->lcd_power                  = inf->lcd_power;
500
 
        fbi->backlight_power            = inf->backlight_power;
 
604
        info->flags                     = FBINFO_FLAG_DEFAULT |
 
605
                                          FBINFO_READS_FAST;
 
606
 
 
607
        fbi->max_xres                   = pdata->xres;
 
608
        info->var.xres                  = pdata->xres;
 
609
        info->var.xres_virtual          = pdata->xres;
 
610
        fbi->max_yres                   = pdata->yres;
 
611
        info->var.yres                  = pdata->yres;
 
612
        info->var.yres_virtual          = pdata->yres;
 
613
        fbi->max_bpp                    = pdata->bpp;
 
614
        info->var.bits_per_pixel        = pdata->bpp;
 
615
        info->var.nonstd                = pdata->nonstd;
 
616
        info->var.pixclock              = pdata->pixclock;
 
617
        info->var.hsync_len             = pdata->hsync_len;
 
618
        info->var.left_margin           = pdata->left_margin;
 
619
        info->var.right_margin          = pdata->right_margin;
 
620
        info->var.vsync_len             = pdata->vsync_len;
 
621
        info->var.upper_margin          = pdata->upper_margin;
 
622
        info->var.lower_margin          = pdata->lower_margin;
 
623
        info->var.sync                  = pdata->sync;
 
624
        info->var.grayscale             = pdata->cmap_greyscale;
 
625
        fbi->cmap_inverse               = pdata->cmap_inverse;
 
626
        fbi->cmap_static                = pdata->cmap_static;
 
627
        fbi->pcr                        = pdata->pcr;
 
628
        fbi->lscr1                      = pdata->lscr1;
 
629
        fbi->dmacr                      = pdata->dmacr;
 
630
        fbi->pwmr                       = pdata->pwmr;
 
631
        fbi->lcd_power                  = pdata->lcd_power;
 
632
        fbi->backlight_power            = pdata->backlight_power;
501
633
        info->fix.smem_len              = fbi->max_xres * fbi->max_yres *
502
634
                                          fbi->max_bpp / 8;
503
635
 
504
636
        return 0;
505
637
}
506
638
 
507
 
/*
508
 
 *      Allocates the DRAM memory for the frame buffer.  This buffer is
509
 
 *      remapped into a non-cached, non-buffered, memory region to
510
 
 *      allow pixel writes to occur without flushing the cache.
511
 
 *      Once this area is remapped, all virtual memory access to the
512
 
 *      video memory should occur at the new region.
513
 
 */
514
 
static int __init imxfb_map_video_memory(struct fb_info *info)
515
 
{
516
 
        struct imxfb_info *fbi = info->par;
517
 
 
518
 
        fbi->map_size = PAGE_ALIGN(info->fix.smem_len);
519
 
        fbi->map_cpu = dma_alloc_writecombine(fbi->dev, fbi->map_size,
520
 
                                        &fbi->map_dma,GFP_KERNEL);
521
 
 
522
 
        if (fbi->map_cpu) {
523
 
                info->screen_base = fbi->map_cpu;
524
 
                fbi->screen_cpu = fbi->map_cpu;
525
 
                fbi->screen_dma = fbi->map_dma;
526
 
                info->fix.smem_start = fbi->screen_dma;
527
 
        }
528
 
 
529
 
        return fbi->map_cpu ? 0 : -ENOMEM;
530
 
}
531
 
 
532
639
static int __init imxfb_probe(struct platform_device *pdev)
533
640
{
534
641
        struct imxfb_info *fbi;
535
642
        struct fb_info *info;
536
 
        struct imxfb_mach_info *inf;
 
643
        struct imx_fb_platform_data *pdata;
537
644
        struct resource *res;
538
645
        int ret;
539
646
 
540
647
        printk("i.MX Framebuffer driver\n");
541
648
 
542
649
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
543
 
        if(!res)
 
650
        if (!res)
544
651
                return -ENODEV;
545
652
 
546
 
        inf = pdev->dev.platform_data;
547
 
        if(!inf) {
 
653
        pdata = pdev->dev.platform_data;
 
654
        if (!pdata) {
548
655
                dev_err(&pdev->dev,"No platform_data available\n");
549
656
                return -ENOMEM;
550
657
        }
551
658
 
552
659
        info = framebuffer_alloc(sizeof(struct imxfb_info), &pdev->dev);
553
 
        if(!info)
 
660
        if (!info)
554
661
                return -ENOMEM;
555
662
 
556
663
        fbi = info->par;
557
664
 
558
665
        platform_set_drvdata(pdev, info);
559
666
 
560
 
        ret = imxfb_init_fbinfo(&pdev->dev);
561
 
        if( ret < 0 )
 
667
        ret = imxfb_init_fbinfo(pdev);
 
668
        if (ret < 0)
562
669
                goto failed_init;
563
670
 
564
 
        res = request_mem_region(res->start, res->end - res->start + 1, "IMXFB");
 
671
        res = request_mem_region(res->start, resource_size(res),
 
672
                                DRIVER_NAME);
565
673
        if (!res) {
566
674
                ret = -EBUSY;
567
 
                goto failed_regs;
568
 
        }
569
 
 
570
 
        if (!inf->fixed_screen_cpu) {
571
 
                ret = imxfb_map_video_memory(info);
572
 
                if (ret) {
 
675
                goto failed_req;
 
676
        }
 
677
 
 
678
        fbi->clk = clk_get(&pdev->dev, NULL);
 
679
        if (IS_ERR(fbi->clk)) {
 
680
                ret = PTR_ERR(fbi->clk);;
 
681
                dev_err(&pdev->dev, "unable to get clock: %d\n", ret);
 
682
                goto failed_getclock;
 
683
        }
 
684
 
 
685
        fbi->regs = ioremap(res->start, resource_size(res));
 
686
        if (fbi->regs == NULL) {
 
687
                printk(KERN_ERR"Cannot map frame buffer registers\n");
 
688
                goto failed_ioremap;
 
689
        }
 
690
 
 
691
        if (!pdata->fixed_screen_cpu) {
 
692
                fbi->map_size = PAGE_ALIGN(info->fix.smem_len);
 
693
                fbi->map_cpu = dma_alloc_writecombine(&pdev->dev,
 
694
                                fbi->map_size, &fbi->map_dma, GFP_KERNEL);
 
695
 
 
696
                if (!fbi->map_cpu) {
573
697
                        dev_err(&pdev->dev, "Failed to allocate video RAM: %d\n", ret);
574
698
                        ret = -ENOMEM;
575
699
                        goto failed_map;
576
700
                }
 
701
 
 
702
                info->screen_base = fbi->map_cpu;
 
703
                fbi->screen_cpu = fbi->map_cpu;
 
704
                fbi->screen_dma = fbi->map_dma;
 
705
                info->fix.smem_start = fbi->screen_dma;
577
706
        } else {
578
707
                /* Fixed framebuffer mapping enables location of the screen in eSRAM */
579
 
                fbi->map_cpu = inf->fixed_screen_cpu;
580
 
                fbi->map_dma = inf->fixed_screen_dma;
 
708
                fbi->map_cpu = pdata->fixed_screen_cpu;
 
709
                fbi->map_dma = pdata->fixed_screen_dma;
581
710
                info->screen_base = fbi->map_cpu;
582
711
                fbi->screen_cpu = fbi->map_cpu;
583
712
                fbi->screen_dma = fbi->map_dma;
584
713
                info->fix.smem_start = fbi->screen_dma;
585
714
        }
586
715
 
 
716
        if (pdata->init) {
 
717
                ret = pdata->init(fbi->pdev);
 
718
                if (ret)
 
719
                        goto failed_platform_init;
 
720
        }
 
721
 
587
722
        /*
588
723
         * This makes sure that our colour bitfield
589
724
         * descriptors are correctly initialised.
590
725
         */
591
726
        imxfb_check_var(&info->var, info);
592
727
 
593
 
        ret = fb_alloc_cmap(&info->cmap, 1<<info->var.bits_per_pixel, 0);
 
728
        ret = fb_alloc_cmap(&info->cmap, 1 << info->var.bits_per_pixel, 0);
594
729
        if (ret < 0)
595
730
                goto failed_cmap;
596
731
 
597
 
        imxfb_setup_gpio(fbi);
598
 
 
599
732
        imxfb_set_par(info);
600
733
        ret = register_framebuffer(info);
601
734
        if (ret < 0) {
610
743
failed_register:
611
744
        fb_dealloc_cmap(&info->cmap);
612
745
failed_cmap:
613
 
        if (!inf->fixed_screen_cpu)
 
746
        if (pdata->exit)
 
747
                pdata->exit(fbi->pdev);
 
748
failed_platform_init:
 
749
        if (!pdata->fixed_screen_cpu)
614
750
                dma_free_writecombine(&pdev->dev,fbi->map_size,fbi->map_cpu,
615
 
                           fbi->map_dma);
 
751
                        fbi->map_dma);
616
752
failed_map:
617
 
        kfree(info->pseudo_palette);
618
 
failed_regs:
 
753
        clk_put(fbi->clk);
 
754
failed_getclock:
 
755
        iounmap(fbi->regs);
 
756
failed_ioremap:
619
757
        release_mem_region(res->start, res->end - res->start);
 
758
failed_req:
 
759
        kfree(info->pseudo_palette);
620
760
failed_init:
621
761
        platform_set_drvdata(pdev, NULL);
622
762
        framebuffer_release(info);
623
763
        return ret;
624
764
}
625
765
 
626
 
static int imxfb_remove(struct platform_device *pdev)
 
766
static int __devexit imxfb_remove(struct platform_device *pdev)
627
767
{
 
768
        struct imx_fb_platform_data *pdata;
628
769
        struct fb_info *info = platform_get_drvdata(pdev);
629
770
        struct imxfb_info *fbi = info->par;
630
771
        struct resource *res;
635
776
 
636
777
        unregister_framebuffer(info);
637
778
 
 
779
        pdata = pdev->dev.platform_data;
 
780
        if (pdata->exit)
 
781
                pdata->exit(fbi->pdev);
 
782
 
638
783
        fb_dealloc_cmap(&info->cmap);
639
784
        kfree(info->pseudo_palette);
640
785
        framebuffer_release(info);
641
786
 
 
787
        iounmap(fbi->regs);
642
788
        release_mem_region(res->start, res->end - res->start + 1);
 
789
        clk_disable(fbi->clk);
 
790
        clk_put(fbi->clk);
 
791
 
643
792
        platform_set_drvdata(pdev, NULL);
644
793
 
645
794
        return 0;
653
802
}
654
803
 
655
804
static struct platform_driver imxfb_driver = {
656
 
        .probe          = imxfb_probe,
657
805
        .suspend        = imxfb_suspend,
658
806
        .resume         = imxfb_resume,
659
 
        .remove         = imxfb_remove,
 
807
        .remove         = __devexit_p(imxfb_remove),
660
808
        .shutdown       = imxfb_shutdown,
661
809
        .driver         = {
662
 
                .name   = "imx-fb",
 
810
                .name   = DRIVER_NAME,
663
811
        },
664
812
};
665
813
 
666
814
int __init imxfb_init(void)
667
815
{
668
 
        return platform_driver_register(&imxfb_driver);
 
816
        return platform_driver_probe(&imxfb_driver, imxfb_probe);
669
817
}
670
818
 
671
819
static void __exit imxfb_cleanup(void)