2 * Driver for AT91/AT32 LCD Controller
4 * Copyright (C) 2007 Atmel Corporation
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file COPYING in the main directory of this archive for
11 #include <linux/kernel.h>
12 #include <linux/platform_device.h>
13 #include <linux/dma-mapping.h>
14 #include <linux/interrupt.h>
15 #include <linux/clk.h>
17 #include <linux/init.h>
18 #include <linux/delay.h>
19 #include <linux/backlight.h>
20 #include <linux/gfp.h>
21 #include <linux/module.h>
22 #include <linux/platform_data/atmel.h>
24 #include <linux/of_device.h>
25 #include <linux/of_gpio.h>
26 #include <video/of_display_timing.h>
27 #include <video/videomode.h>
32 #include <video/atmel_lcdc.h>
34 struct atmel_lcdfb_config
{
35 bool have_alt_pixclock
;
37 bool have_intensity_bit
;
40 /* LCD Controller info data structure, stored in device platform_data */
41 struct atmel_lcdfb_info
{
46 struct work_struct task
;
48 unsigned int smem_len
;
49 struct platform_device
*pdev
;
53 struct backlight_device
*backlight
;
57 u32 pseudo_palette
[16];
58 bool have_intensity_bit
;
60 struct atmel_lcdfb_pdata pdata
;
62 struct atmel_lcdfb_config
*config
;
65 struct atmel_lcdfb_power_ctrl_gpio
{
69 struct list_head list
;
72 #define lcdc_readl(sinfo, reg) __raw_readl((sinfo)->mmio+(reg))
73 #define lcdc_writel(sinfo, reg, val) __raw_writel((val), (sinfo)->mmio+(reg))
75 /* configurable parameters */
76 #define ATMEL_LCDC_CVAL_DEFAULT 0xc8
77 #define ATMEL_LCDC_DMA_BURST_LEN 8 /* words */
78 #define ATMEL_LCDC_FIFO_SIZE 512 /* words */
80 static struct atmel_lcdfb_config at91sam9261_config
= {
82 .have_intensity_bit
= true,
85 static struct atmel_lcdfb_config at91sam9263_config
= {
86 .have_intensity_bit
= true,
89 static struct atmel_lcdfb_config at91sam9g10_config
= {
93 static struct atmel_lcdfb_config at91sam9g45_config
= {
94 .have_alt_pixclock
= true,
97 static struct atmel_lcdfb_config at91sam9g45es_config
= {
100 static struct atmel_lcdfb_config at91sam9rl_config
= {
101 .have_intensity_bit
= true,
104 static struct atmel_lcdfb_config at32ap_config
= {
108 static const struct platform_device_id atmel_lcdfb_devtypes
[] = {
110 .name
= "at91sam9261-lcdfb",
111 .driver_data
= (unsigned long)&at91sam9261_config
,
113 .name
= "at91sam9263-lcdfb",
114 .driver_data
= (unsigned long)&at91sam9263_config
,
116 .name
= "at91sam9g10-lcdfb",
117 .driver_data
= (unsigned long)&at91sam9g10_config
,
119 .name
= "at91sam9g45-lcdfb",
120 .driver_data
= (unsigned long)&at91sam9g45_config
,
122 .name
= "at91sam9g45es-lcdfb",
123 .driver_data
= (unsigned long)&at91sam9g45es_config
,
125 .name
= "at91sam9rl-lcdfb",
126 .driver_data
= (unsigned long)&at91sam9rl_config
,
128 .name
= "at32ap-lcdfb",
129 .driver_data
= (unsigned long)&at32ap_config
,
135 static struct atmel_lcdfb_config
*
136 atmel_lcdfb_get_config(struct platform_device
*pdev
)
140 data
= platform_get_device_id(pdev
)->driver_data
;
142 return (struct atmel_lcdfb_config
*)data
;
145 #if defined(CONFIG_ARCH_AT91)
146 #define ATMEL_LCDFB_FBINFO_DEFAULT (FBINFO_DEFAULT \
147 | FBINFO_PARTIAL_PAN_OK \
148 | FBINFO_HWACCEL_YPAN)
150 static inline void atmel_lcdfb_update_dma2d(struct atmel_lcdfb_info
*sinfo
,
151 struct fb_var_screeninfo
*var
,
152 struct fb_info
*info
)
156 #elif defined(CONFIG_AVR32)
157 #define ATMEL_LCDFB_FBINFO_DEFAULT (FBINFO_DEFAULT \
158 | FBINFO_PARTIAL_PAN_OK \
159 | FBINFO_HWACCEL_XPAN \
160 | FBINFO_HWACCEL_YPAN)
162 static void atmel_lcdfb_update_dma2d(struct atmel_lcdfb_info
*sinfo
,
163 struct fb_var_screeninfo
*var
,
164 struct fb_info
*info
)
169 pixeloff
= (var
->xoffset
* info
->var
.bits_per_pixel
) & 0x1f;
171 dma2dcfg
= (info
->var
.xres_virtual
- info
->var
.xres
)
172 * info
->var
.bits_per_pixel
/ 8;
173 dma2dcfg
|= pixeloff
<< ATMEL_LCDC_PIXELOFF_OFFSET
;
174 lcdc_writel(sinfo
, ATMEL_LCDC_DMA2DCFG
, dma2dcfg
);
176 /* Update configuration */
177 lcdc_writel(sinfo
, ATMEL_LCDC_DMACON
,
178 lcdc_readl(sinfo
, ATMEL_LCDC_DMACON
)
179 | ATMEL_LCDC_DMAUPDT
);
183 static u32 contrast_ctr
= ATMEL_LCDC_PS_DIV8
184 | ATMEL_LCDC_POL_POSITIVE
185 | ATMEL_LCDC_ENA_PWMENABLE
;
187 #ifdef CONFIG_BACKLIGHT_ATMEL_LCDC
189 /* some bl->props field just changed */
190 static int atmel_bl_update_status(struct backlight_device
*bl
)
192 struct atmel_lcdfb_info
*sinfo
= bl_get_data(bl
);
193 int power
= sinfo
->bl_power
;
194 int brightness
= bl
->props
.brightness
;
196 /* REVISIT there may be a meaningful difference between
197 * fb_blank and power ... there seem to be some cases
198 * this doesn't handle correctly.
200 if (bl
->props
.fb_blank
!= sinfo
->bl_power
)
201 power
= bl
->props
.fb_blank
;
202 else if (bl
->props
.power
!= sinfo
->bl_power
)
203 power
= bl
->props
.power
;
205 if (brightness
< 0 && power
== FB_BLANK_UNBLANK
)
206 brightness
= lcdc_readl(sinfo
, ATMEL_LCDC_CONTRAST_VAL
);
207 else if (power
!= FB_BLANK_UNBLANK
)
210 lcdc_writel(sinfo
, ATMEL_LCDC_CONTRAST_VAL
, brightness
);
211 if (contrast_ctr
& ATMEL_LCDC_POL_POSITIVE
)
212 lcdc_writel(sinfo
, ATMEL_LCDC_CONTRAST_CTR
,
213 brightness
? contrast_ctr
: 0);
215 lcdc_writel(sinfo
, ATMEL_LCDC_CONTRAST_CTR
, contrast_ctr
);
217 bl
->props
.fb_blank
= bl
->props
.power
= sinfo
->bl_power
= power
;
222 static int atmel_bl_get_brightness(struct backlight_device
*bl
)
224 struct atmel_lcdfb_info
*sinfo
= bl_get_data(bl
);
226 return lcdc_readl(sinfo
, ATMEL_LCDC_CONTRAST_VAL
);
229 static const struct backlight_ops atmel_lcdc_bl_ops
= {
230 .update_status
= atmel_bl_update_status
,
231 .get_brightness
= atmel_bl_get_brightness
,
234 static void init_backlight(struct atmel_lcdfb_info
*sinfo
)
236 struct backlight_properties props
;
237 struct backlight_device
*bl
;
239 sinfo
->bl_power
= FB_BLANK_UNBLANK
;
241 if (sinfo
->backlight
)
244 memset(&props
, 0, sizeof(struct backlight_properties
));
245 props
.type
= BACKLIGHT_RAW
;
246 props
.max_brightness
= 0xff;
247 bl
= backlight_device_register("backlight", &sinfo
->pdev
->dev
, sinfo
,
248 &atmel_lcdc_bl_ops
, &props
);
250 dev_err(&sinfo
->pdev
->dev
, "error %ld on backlight register\n",
254 sinfo
->backlight
= bl
;
256 bl
->props
.power
= FB_BLANK_UNBLANK
;
257 bl
->props
.fb_blank
= FB_BLANK_UNBLANK
;
258 bl
->props
.brightness
= atmel_bl_get_brightness(bl
);
261 static void exit_backlight(struct atmel_lcdfb_info
*sinfo
)
263 if (!sinfo
->backlight
)
266 if (sinfo
->backlight
->ops
) {
267 sinfo
->backlight
->props
.power
= FB_BLANK_POWERDOWN
;
268 sinfo
->backlight
->ops
->update_status(sinfo
->backlight
);
270 backlight_device_unregister(sinfo
->backlight
);
275 static void init_backlight(struct atmel_lcdfb_info
*sinfo
)
277 dev_warn(&sinfo
->pdev
->dev
, "backlight control is not available\n");
280 static void exit_backlight(struct atmel_lcdfb_info
*sinfo
)
286 static void init_contrast(struct atmel_lcdfb_info
*sinfo
)
288 struct atmel_lcdfb_pdata
*pdata
= &sinfo
->pdata
;
290 /* contrast pwm can be 'inverted' */
291 if (pdata
->lcdcon_pol_negative
)
292 contrast_ctr
&= ~(ATMEL_LCDC_POL_POSITIVE
);
294 /* have some default contrast/backlight settings */
295 lcdc_writel(sinfo
, ATMEL_LCDC_CONTRAST_CTR
, contrast_ctr
);
296 lcdc_writel(sinfo
, ATMEL_LCDC_CONTRAST_VAL
, ATMEL_LCDC_CVAL_DEFAULT
);
298 if (pdata
->lcdcon_is_backlight
)
299 init_backlight(sinfo
);
302 static inline void atmel_lcdfb_power_control(struct atmel_lcdfb_info
*sinfo
, int on
)
304 struct atmel_lcdfb_pdata
*pdata
= &sinfo
->pdata
;
306 if (pdata
->atmel_lcdfb_power_control
)
307 pdata
->atmel_lcdfb_power_control(pdata
, on
);
310 static struct fb_fix_screeninfo atmel_lcdfb_fix __initdata
= {
311 .type
= FB_TYPE_PACKED_PIXELS
,
312 .visual
= FB_VISUAL_TRUECOLOR
,
316 .accel
= FB_ACCEL_NONE
,
319 static unsigned long compute_hozval(struct atmel_lcdfb_info
*sinfo
,
322 unsigned long lcdcon2
;
325 if (!sinfo
->config
->have_hozval
)
328 lcdcon2
= lcdc_readl(sinfo
, ATMEL_LCDC_LCDCON2
);
330 if ((lcdcon2
& ATMEL_LCDC_DISTYPE
) != ATMEL_LCDC_DISTYPE_TFT
) {
332 if ((lcdcon2
& ATMEL_LCDC_DISTYPE
) == ATMEL_LCDC_DISTYPE_STNCOLOR
) {
335 if ( (lcdcon2
& ATMEL_LCDC_IFWIDTH
) == ATMEL_LCDC_IFWIDTH_4
336 || ( (lcdcon2
& ATMEL_LCDC_IFWIDTH
) == ATMEL_LCDC_IFWIDTH_8
337 && (lcdcon2
& ATMEL_LCDC_SCANMOD
) == ATMEL_LCDC_SCANMOD_DUAL
))
338 value
= DIV_ROUND_UP(value
, 4);
340 value
= DIV_ROUND_UP(value
, 8);
346 static void atmel_lcdfb_stop_nowait(struct atmel_lcdfb_info
*sinfo
)
348 struct atmel_lcdfb_pdata
*pdata
= &sinfo
->pdata
;
350 /* Turn off the LCD controller and the DMA controller */
351 lcdc_writel(sinfo
, ATMEL_LCDC_PWRCON
,
352 pdata
->guard_time
<< ATMEL_LCDC_GUARDT_OFFSET
);
354 /* Wait for the LCDC core to become idle */
355 while (lcdc_readl(sinfo
, ATMEL_LCDC_PWRCON
) & ATMEL_LCDC_BUSY
)
358 lcdc_writel(sinfo
, ATMEL_LCDC_DMACON
, 0);
361 static void atmel_lcdfb_stop(struct atmel_lcdfb_info
*sinfo
)
363 atmel_lcdfb_stop_nowait(sinfo
);
365 /* Wait for DMA engine to become idle... */
366 while (lcdc_readl(sinfo
, ATMEL_LCDC_DMACON
) & ATMEL_LCDC_DMABUSY
)
370 static void atmel_lcdfb_start(struct atmel_lcdfb_info
*sinfo
)
372 struct atmel_lcdfb_pdata
*pdata
= &sinfo
->pdata
;
374 lcdc_writel(sinfo
, ATMEL_LCDC_DMACON
, pdata
->default_dmacon
);
375 lcdc_writel(sinfo
, ATMEL_LCDC_PWRCON
,
376 (pdata
->guard_time
<< ATMEL_LCDC_GUARDT_OFFSET
)
380 static void atmel_lcdfb_update_dma(struct fb_info
*info
,
381 struct fb_var_screeninfo
*var
)
383 struct atmel_lcdfb_info
*sinfo
= info
->par
;
384 struct fb_fix_screeninfo
*fix
= &info
->fix
;
385 unsigned long dma_addr
;
387 dma_addr
= (fix
->smem_start
+ var
->yoffset
* fix
->line_length
388 + var
->xoffset
* info
->var
.bits_per_pixel
/ 8);
392 /* Set framebuffer DMA base address and pixel offset */
393 lcdc_writel(sinfo
, ATMEL_LCDC_DMABADDR1
, dma_addr
);
395 atmel_lcdfb_update_dma2d(sinfo
, var
, info
);
398 static inline void atmel_lcdfb_free_video_memory(struct atmel_lcdfb_info
*sinfo
)
400 struct fb_info
*info
= sinfo
->info
;
402 dma_free_writecombine(info
->device
, info
->fix
.smem_len
,
403 info
->screen_base
, info
->fix
.smem_start
);
407 * atmel_lcdfb_alloc_video_memory - Allocate framebuffer memory
408 * @sinfo: the frame buffer to allocate memory for
410 * This function is called only from the atmel_lcdfb_probe()
411 * so no locking by fb_info->mm_lock around smem_len setting is needed.
413 static int atmel_lcdfb_alloc_video_memory(struct atmel_lcdfb_info
*sinfo
)
415 struct fb_info
*info
= sinfo
->info
;
416 struct fb_var_screeninfo
*var
= &info
->var
;
417 unsigned int smem_len
;
419 smem_len
= (var
->xres_virtual
* var
->yres_virtual
420 * ((var
->bits_per_pixel
+ 7) / 8));
421 info
->fix
.smem_len
= max(smem_len
, sinfo
->smem_len
);
423 info
->screen_base
= dma_alloc_writecombine(info
->device
, info
->fix
.smem_len
,
424 (dma_addr_t
*)&info
->fix
.smem_start
, GFP_KERNEL
);
426 if (!info
->screen_base
) {
430 memset(info
->screen_base
, 0, info
->fix
.smem_len
);
435 static const struct fb_videomode
*atmel_lcdfb_choose_mode(struct fb_var_screeninfo
*var
,
436 struct fb_info
*info
)
438 struct fb_videomode varfbmode
;
439 const struct fb_videomode
*fbmode
= NULL
;
441 fb_var_to_videomode(&varfbmode
, var
);
442 fbmode
= fb_find_nearest_mode(&varfbmode
, &info
->modelist
);
444 fb_videomode_to_var(var
, fbmode
);
450 * atmel_lcdfb_check_var - Validates a var passed in.
451 * @var: frame buffer variable screen structure
452 * @info: frame buffer structure that represents a single frame buffer
454 * Checks to see if the hardware supports the state requested by
455 * var passed in. This function does not alter the hardware
456 * state!!! This means the data stored in struct fb_info and
457 * struct atmel_lcdfb_info do not change. This includes the var
458 * inside of struct fb_info. Do NOT change these. This function
459 * can be called on its own if we intent to only test a mode and
460 * not actually set it. The stuff in modedb.c is a example of
461 * this. If the var passed in is slightly off by what the
462 * hardware can support then we alter the var PASSED in to what
463 * we can do. If the hardware doesn't support mode change a
464 * -EINVAL will be returned by the upper layers. You don't need
465 * to implement this function then. If you hardware doesn't
466 * support changing the resolution then this function is not
467 * needed. In this case the driver would just provide a var that
468 * represents the static state the screen is in.
470 * Returns negative errno on error, or zero on success.
472 static int atmel_lcdfb_check_var(struct fb_var_screeninfo
*var
,
473 struct fb_info
*info
)
475 struct device
*dev
= info
->device
;
476 struct atmel_lcdfb_info
*sinfo
= info
->par
;
477 struct atmel_lcdfb_pdata
*pdata
= &sinfo
->pdata
;
478 unsigned long clk_value_khz
;
480 clk_value_khz
= clk_get_rate(sinfo
->lcdc_clk
) / 1000;
482 dev_dbg(dev
, "%s:\n", __func__
);
484 if (!(var
->pixclock
&& var
->bits_per_pixel
)) {
485 /* choose a suitable mode if possible */
486 if (!atmel_lcdfb_choose_mode(var
, info
)) {
487 dev_err(dev
, "needed value not specified\n");
492 dev_dbg(dev
, " resolution: %ux%u\n", var
->xres
, var
->yres
);
493 dev_dbg(dev
, " pixclk: %lu KHz\n", PICOS2KHZ(var
->pixclock
));
494 dev_dbg(dev
, " bpp: %u\n", var
->bits_per_pixel
);
495 dev_dbg(dev
, " clk: %lu KHz\n", clk_value_khz
);
497 if (PICOS2KHZ(var
->pixclock
) > clk_value_khz
) {
498 dev_err(dev
, "%lu KHz pixel clock is too fast\n", PICOS2KHZ(var
->pixclock
));
502 /* Do not allow to have real resoulution larger than virtual */
503 if (var
->xres
> var
->xres_virtual
)
504 var
->xres_virtual
= var
->xres
;
506 if (var
->yres
> var
->yres_virtual
)
507 var
->yres_virtual
= var
->yres
;
509 /* Force same alignment for each line */
510 var
->xres
= (var
->xres
+ 3) & ~3UL;
511 var
->xres_virtual
= (var
->xres_virtual
+ 3) & ~3UL;
513 var
->red
.msb_right
= var
->green
.msb_right
= var
->blue
.msb_right
= 0;
514 var
->transp
.msb_right
= 0;
515 var
->transp
.offset
= var
->transp
.length
= 0;
516 var
->xoffset
= var
->yoffset
= 0;
518 if (info
->fix
.smem_len
) {
519 unsigned int smem_len
= (var
->xres_virtual
* var
->yres_virtual
520 * ((var
->bits_per_pixel
+ 7) / 8));
521 if (smem_len
> info
->fix
.smem_len
) {
522 dev_err(dev
, "Frame buffer is too small (%u) for screen size (need at least %u)\n",
523 info
->fix
.smem_len
, smem_len
);
528 /* Saturate vertical and horizontal timings at maximum values */
529 var
->vsync_len
= min_t(u32
, var
->vsync_len
,
530 (ATMEL_LCDC_VPW
>> ATMEL_LCDC_VPW_OFFSET
) + 1);
531 var
->upper_margin
= min_t(u32
, var
->upper_margin
,
532 ATMEL_LCDC_VBP
>> ATMEL_LCDC_VBP_OFFSET
);
533 var
->lower_margin
= min_t(u32
, var
->lower_margin
,
535 var
->right_margin
= min_t(u32
, var
->right_margin
,
536 (ATMEL_LCDC_HFP
>> ATMEL_LCDC_HFP_OFFSET
) + 1);
537 var
->hsync_len
= min_t(u32
, var
->hsync_len
,
538 (ATMEL_LCDC_HPW
>> ATMEL_LCDC_HPW_OFFSET
) + 1);
539 var
->left_margin
= min_t(u32
, var
->left_margin
,
542 /* Some parameters can't be zero */
543 var
->vsync_len
= max_t(u32
, var
->vsync_len
, 1);
544 var
->right_margin
= max_t(u32
, var
->right_margin
, 1);
545 var
->hsync_len
= max_t(u32
, var
->hsync_len
, 1);
546 var
->left_margin
= max_t(u32
, var
->left_margin
, 1);
548 switch (var
->bits_per_pixel
) {
553 var
->red
.offset
= var
->green
.offset
= var
->blue
.offset
= 0;
554 var
->red
.length
= var
->green
.length
= var
->blue
.length
555 = var
->bits_per_pixel
;
558 /* Older SOCs use IBGR:555 rather than BGR:565. */
559 if (sinfo
->config
->have_intensity_bit
)
560 var
->green
.length
= 5;
562 var
->green
.length
= 6;
564 if (pdata
->lcd_wiring_mode
== ATMEL_LCDC_WIRING_RGB
) {
566 var
->red
.offset
= var
->green
.length
+ 5;
567 var
->blue
.offset
= 0;
571 var
->blue
.offset
= var
->green
.length
+ 5;
573 var
->green
.offset
= 5;
574 var
->red
.length
= var
->blue
.length
= 5;
577 var
->transp
.offset
= 24;
578 var
->transp
.length
= 8;
581 if (pdata
->lcd_wiring_mode
== ATMEL_LCDC_WIRING_RGB
) {
583 var
->red
.offset
= 16;
584 var
->blue
.offset
= 0;
588 var
->blue
.offset
= 16;
590 var
->green
.offset
= 8;
591 var
->red
.length
= var
->green
.length
= var
->blue
.length
= 8;
594 dev_err(dev
, "color depth %d not supported\n",
595 var
->bits_per_pixel
);
605 static void atmel_lcdfb_reset(struct atmel_lcdfb_info
*sinfo
)
609 atmel_lcdfb_stop(sinfo
);
610 atmel_lcdfb_start(sinfo
);
614 * atmel_lcdfb_set_par - Alters the hardware state.
615 * @info: frame buffer structure that represents a single frame buffer
617 * Using the fb_var_screeninfo in fb_info we set the resolution
618 * of the this particular framebuffer. This function alters the
619 * par AND the fb_fix_screeninfo stored in fb_info. It doesn't
620 * not alter var in fb_info since we are using that data. This
621 * means we depend on the data in var inside fb_info to be
622 * supported by the hardware. atmel_lcdfb_check_var is always called
623 * before atmel_lcdfb_set_par to ensure this. Again if you can't
624 * change the resolution you don't need this function.
627 static int atmel_lcdfb_set_par(struct fb_info
*info
)
629 struct atmel_lcdfb_info
*sinfo
= info
->par
;
630 struct atmel_lcdfb_pdata
*pdata
= &sinfo
->pdata
;
631 unsigned long hozval_linesz
;
633 unsigned long clk_value_khz
;
634 unsigned long bits_per_line
;
635 unsigned long pix_factor
= 2;
639 dev_dbg(info
->device
, "%s:\n", __func__
);
640 dev_dbg(info
->device
, " * resolution: %ux%u (%ux%u virtual)\n",
641 info
->var
.xres
, info
->var
.yres
,
642 info
->var
.xres_virtual
, info
->var
.yres_virtual
);
644 atmel_lcdfb_stop_nowait(sinfo
);
646 if (info
->var
.bits_per_pixel
== 1)
647 info
->fix
.visual
= FB_VISUAL_MONO01
;
648 else if (info
->var
.bits_per_pixel
<= 8)
649 info
->fix
.visual
= FB_VISUAL_PSEUDOCOLOR
;
651 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
653 bits_per_line
= info
->var
.xres_virtual
* info
->var
.bits_per_pixel
;
654 info
->fix
.line_length
= DIV_ROUND_UP(bits_per_line
, 8);
656 /* Re-initialize the DMA engine... */
657 dev_dbg(info
->device
, " * update DMA engine\n");
658 atmel_lcdfb_update_dma(info
, &info
->var
);
660 /* ...set frame size and burst length = 8 words (?) */
661 value
= (info
->var
.yres
* info
->var
.xres
* info
->var
.bits_per_pixel
) / 32;
662 value
|= ((ATMEL_LCDC_DMA_BURST_LEN
- 1) << ATMEL_LCDC_BLENGTH_OFFSET
);
663 lcdc_writel(sinfo
, ATMEL_LCDC_DMAFRMCFG
, value
);
665 /* Now, the LCDC core... */
667 /* Set pixel clock */
668 if (sinfo
->config
->have_alt_pixclock
)
671 clk_value_khz
= clk_get_rate(sinfo
->lcdc_clk
) / 1000;
673 value
= DIV_ROUND_UP(clk_value_khz
, PICOS2KHZ(info
->var
.pixclock
));
675 if (value
< pix_factor
) {
676 dev_notice(info
->device
, "Bypassing pixel clock divider\n");
677 lcdc_writel(sinfo
, ATMEL_LCDC_LCDCON1
, ATMEL_LCDC_BYPASS
);
679 value
= (value
/ pix_factor
) - 1;
680 dev_dbg(info
->device
, " * programming CLKVAL = 0x%08lx\n",
682 lcdc_writel(sinfo
, ATMEL_LCDC_LCDCON1
,
683 value
<< ATMEL_LCDC_CLKVAL_OFFSET
);
685 KHZ2PICOS(clk_value_khz
/ (pix_factor
* (value
+ 1)));
686 dev_dbg(info
->device
, " updated pixclk: %lu KHz\n",
687 PICOS2KHZ(info
->var
.pixclock
));
691 /* Initialize control register 2 */
692 value
= pdata
->default_lcdcon2
;
694 if (!(info
->var
.sync
& FB_SYNC_HOR_HIGH_ACT
))
695 value
|= ATMEL_LCDC_INVLINE_INVERTED
;
696 if (!(info
->var
.sync
& FB_SYNC_VERT_HIGH_ACT
))
697 value
|= ATMEL_LCDC_INVFRAME_INVERTED
;
699 switch (info
->var
.bits_per_pixel
) {
700 case 1: value
|= ATMEL_LCDC_PIXELSIZE_1
; break;
701 case 2: value
|= ATMEL_LCDC_PIXELSIZE_2
; break;
702 case 4: value
|= ATMEL_LCDC_PIXELSIZE_4
; break;
703 case 8: value
|= ATMEL_LCDC_PIXELSIZE_8
; break;
704 case 15: /* fall through */
705 case 16: value
|= ATMEL_LCDC_PIXELSIZE_16
; break;
706 case 24: value
|= ATMEL_LCDC_PIXELSIZE_24
; break;
707 case 32: value
|= ATMEL_LCDC_PIXELSIZE_32
; break;
708 default: BUG(); break;
710 dev_dbg(info
->device
, " * LCDCON2 = %08lx\n", value
);
711 lcdc_writel(sinfo
, ATMEL_LCDC_LCDCON2
, value
);
713 /* Vertical timing */
714 value
= (info
->var
.vsync_len
- 1) << ATMEL_LCDC_VPW_OFFSET
;
715 value
|= info
->var
.upper_margin
<< ATMEL_LCDC_VBP_OFFSET
;
716 value
|= info
->var
.lower_margin
;
717 dev_dbg(info
->device
, " * LCDTIM1 = %08lx\n", value
);
718 lcdc_writel(sinfo
, ATMEL_LCDC_TIM1
, value
);
720 /* Horizontal timing */
721 value
= (info
->var
.right_margin
- 1) << ATMEL_LCDC_HFP_OFFSET
;
722 value
|= (info
->var
.hsync_len
- 1) << ATMEL_LCDC_HPW_OFFSET
;
723 value
|= (info
->var
.left_margin
- 1);
724 dev_dbg(info
->device
, " * LCDTIM2 = %08lx\n", value
);
725 lcdc_writel(sinfo
, ATMEL_LCDC_TIM2
, value
);
727 /* Horizontal value (aka line size) */
728 hozval_linesz
= compute_hozval(sinfo
, info
->var
.xres
);
731 value
= (hozval_linesz
- 1) << ATMEL_LCDC_HOZVAL_OFFSET
;
732 value
|= info
->var
.yres
- 1;
733 dev_dbg(info
->device
, " * LCDFRMCFG = %08lx\n", value
);
734 lcdc_writel(sinfo
, ATMEL_LCDC_LCDFRMCFG
, value
);
736 /* FIFO Threshold: Use formula from data sheet */
737 value
= ATMEL_LCDC_FIFO_SIZE
- (2 * ATMEL_LCDC_DMA_BURST_LEN
+ 3);
738 lcdc_writel(sinfo
, ATMEL_LCDC_FIFO
, value
);
740 /* Toggle LCD_MODE every frame */
741 lcdc_writel(sinfo
, ATMEL_LCDC_MVAL
, 0);
743 /* Disable all interrupts */
744 lcdc_writel(sinfo
, ATMEL_LCDC_IDR
, ~0UL);
745 /* Enable FIFO & DMA errors */
746 lcdc_writel(sinfo
, ATMEL_LCDC_IER
, ATMEL_LCDC_UFLWI
| ATMEL_LCDC_OWRI
| ATMEL_LCDC_MERI
);
748 /* ...wait for DMA engine to become idle... */
749 while (lcdc_readl(sinfo
, ATMEL_LCDC_DMACON
) & ATMEL_LCDC_DMABUSY
)
752 atmel_lcdfb_start(sinfo
);
754 dev_dbg(info
->device
, " * DONE\n");
759 static inline unsigned int chan_to_field(unsigned int chan
, const struct fb_bitfield
*bf
)
762 chan
>>= 16 - bf
->length
;
763 return chan
<< bf
->offset
;
767 * atmel_lcdfb_setcolreg - Optional function. Sets a color register.
768 * @regno: Which register in the CLUT we are programming
769 * @red: The red value which can be up to 16 bits wide
770 * @green: The green value which can be up to 16 bits wide
771 * @blue: The blue value which can be up to 16 bits wide.
772 * @transp: If supported the alpha value which can be up to 16 bits wide.
773 * @info: frame buffer info structure
775 * Set a single color register. The values supplied have a 16 bit
776 * magnitude which needs to be scaled in this function for the hardware.
777 * Things to take into consideration are how many color registers, if
778 * any, are supported with the current color visual. With truecolor mode
779 * no color palettes are supported. Here a pseudo palette is created
780 * which we store the value in pseudo_palette in struct fb_info. For
781 * pseudocolor mode we have a limited color palette. To deal with this
782 * we can program what color is displayed for a particular pixel value.
783 * DirectColor is similar in that we can program each color field. If
784 * we have a static colormap we don't need to implement this function.
786 * Returns negative errno on error, or zero on success. In an
787 * ideal world, this would have been the case, but as it turns
788 * out, the other drivers return 1 on failure, so that's what
791 static int atmel_lcdfb_setcolreg(unsigned int regno
, unsigned int red
,
792 unsigned int green
, unsigned int blue
,
793 unsigned int transp
, struct fb_info
*info
)
795 struct atmel_lcdfb_info
*sinfo
= info
->par
;
796 struct atmel_lcdfb_pdata
*pdata
= &sinfo
->pdata
;
801 if (info
->var
.grayscale
)
802 red
= green
= blue
= (19595 * red
+ 38470 * green
803 + 7471 * blue
) >> 16;
805 switch (info
->fix
.visual
) {
806 case FB_VISUAL_TRUECOLOR
:
808 pal
= info
->pseudo_palette
;
810 val
= chan_to_field(red
, &info
->var
.red
);
811 val
|= chan_to_field(green
, &info
->var
.green
);
812 val
|= chan_to_field(blue
, &info
->var
.blue
);
819 case FB_VISUAL_PSEUDOCOLOR
:
821 if (sinfo
->config
->have_intensity_bit
) {
822 /* old style I+BGR:555 */
823 val
= ((red
>> 11) & 0x001f);
824 val
|= ((green
>> 6) & 0x03e0);
825 val
|= ((blue
>> 1) & 0x7c00);
828 * TODO: intensity bit. Maybe something like
829 * ~(red[10] ^ green[10] ^ blue[10]) & 1
832 /* new style BGR:565 / RGB:565 */
833 if (pdata
->lcd_wiring_mode
== ATMEL_LCDC_WIRING_RGB
) {
834 val
= ((blue
>> 11) & 0x001f);
835 val
|= ((red
>> 0) & 0xf800);
837 val
= ((red
>> 11) & 0x001f);
838 val
|= ((blue
>> 0) & 0xf800);
841 val
|= ((green
>> 5) & 0x07e0);
844 lcdc_writel(sinfo
, ATMEL_LCDC_LUT(regno
), val
);
849 case FB_VISUAL_MONO01
:
851 val
= (regno
== 0) ? 0x00 : 0x1F;
852 lcdc_writel(sinfo
, ATMEL_LCDC_LUT(regno
), val
);
862 static int atmel_lcdfb_pan_display(struct fb_var_screeninfo
*var
,
863 struct fb_info
*info
)
865 dev_dbg(info
->device
, "%s\n", __func__
);
867 atmel_lcdfb_update_dma(info
, var
);
872 static int atmel_lcdfb_blank(int blank_mode
, struct fb_info
*info
)
874 struct atmel_lcdfb_info
*sinfo
= info
->par
;
876 switch (blank_mode
) {
877 case FB_BLANK_UNBLANK
:
878 case FB_BLANK_NORMAL
:
879 atmel_lcdfb_start(sinfo
);
881 case FB_BLANK_VSYNC_SUSPEND
:
882 case FB_BLANK_HSYNC_SUSPEND
:
884 case FB_BLANK_POWERDOWN
:
885 atmel_lcdfb_stop(sinfo
);
891 /* let fbcon do a soft blank for us */
892 return ((blank_mode
== FB_BLANK_NORMAL
) ? 1 : 0);
895 static struct fb_ops atmel_lcdfb_ops
= {
896 .owner
= THIS_MODULE
,
897 .fb_check_var
= atmel_lcdfb_check_var
,
898 .fb_set_par
= atmel_lcdfb_set_par
,
899 .fb_setcolreg
= atmel_lcdfb_setcolreg
,
900 .fb_blank
= atmel_lcdfb_blank
,
901 .fb_pan_display
= atmel_lcdfb_pan_display
,
902 .fb_fillrect
= cfb_fillrect
,
903 .fb_copyarea
= cfb_copyarea
,
904 .fb_imageblit
= cfb_imageblit
,
907 static irqreturn_t
atmel_lcdfb_interrupt(int irq
, void *dev_id
)
909 struct fb_info
*info
= dev_id
;
910 struct atmel_lcdfb_info
*sinfo
= info
->par
;
913 status
= lcdc_readl(sinfo
, ATMEL_LCDC_ISR
);
914 if (status
& ATMEL_LCDC_UFLWI
) {
915 dev_warn(info
->device
, "FIFO underflow %#x\n", status
);
916 /* reset DMA and FIFO to avoid screen shifting */
917 schedule_work(&sinfo
->task
);
919 lcdc_writel(sinfo
, ATMEL_LCDC_ICR
, status
);
924 * LCD controller task (to reset the LCD)
926 static void atmel_lcdfb_task(struct work_struct
*work
)
928 struct atmel_lcdfb_info
*sinfo
=
929 container_of(work
, struct atmel_lcdfb_info
, task
);
931 atmel_lcdfb_reset(sinfo
);
934 static int __init
atmel_lcdfb_init_fbinfo(struct atmel_lcdfb_info
*sinfo
)
936 struct fb_info
*info
= sinfo
->info
;
939 info
->var
.activate
|= FB_ACTIVATE_FORCE
| FB_ACTIVATE_NOW
;
941 dev_info(info
->device
,
942 "%luKiB frame buffer at %08lx (mapped at %p)\n",
943 (unsigned long)info
->fix
.smem_len
/ 1024,
944 (unsigned long)info
->fix
.smem_start
,
947 /* Allocate colormap */
948 ret
= fb_alloc_cmap(&info
->cmap
, 256, 0);
950 dev_err(info
->device
, "Alloc color map failed\n");
955 static void atmel_lcdfb_start_clock(struct atmel_lcdfb_info
*sinfo
)
957 clk_prepare_enable(sinfo
->bus_clk
);
958 clk_prepare_enable(sinfo
->lcdc_clk
);
961 static void atmel_lcdfb_stop_clock(struct atmel_lcdfb_info
*sinfo
)
963 clk_disable_unprepare(sinfo
->bus_clk
);
964 clk_disable_unprepare(sinfo
->lcdc_clk
);
968 static const struct of_device_id atmel_lcdfb_dt_ids
[] = {
969 { .compatible
= "atmel,at91sam9261-lcdc" , .data
= &at91sam9261_config
, },
970 { .compatible
= "atmel,at91sam9263-lcdc" , .data
= &at91sam9263_config
, },
971 { .compatible
= "atmel,at91sam9g10-lcdc" , .data
= &at91sam9g10_config
, },
972 { .compatible
= "atmel,at91sam9g45-lcdc" , .data
= &at91sam9g45_config
, },
973 { .compatible
= "atmel,at91sam9g45es-lcdc" , .data
= &at91sam9g45es_config
, },
974 { .compatible
= "atmel,at91sam9rl-lcdc" , .data
= &at91sam9rl_config
, },
975 { .compatible
= "atmel,at32ap-lcdc" , .data
= &at32ap_config
, },
979 MODULE_DEVICE_TABLE(of
, atmel_lcdfb_dt_ids
);
981 static const char *atmel_lcdfb_wiring_modes
[] = {
982 [ATMEL_LCDC_WIRING_BGR
] = "BRG",
983 [ATMEL_LCDC_WIRING_RGB
] = "RGB",
986 const int atmel_lcdfb_get_of_wiring_modes(struct device_node
*np
)
991 err
= of_property_read_string(np
, "atmel,lcd-wiring-mode", &mode
);
993 return ATMEL_LCDC_WIRING_BGR
;
995 for (i
= 0; i
< ARRAY_SIZE(atmel_lcdfb_wiring_modes
); i
++)
996 if (!strcasecmp(mode
, atmel_lcdfb_wiring_modes
[i
]))
1002 static void atmel_lcdfb_power_control_gpio(struct atmel_lcdfb_pdata
*pdata
, int on
)
1004 struct atmel_lcdfb_power_ctrl_gpio
*og
;
1006 list_for_each_entry(og
, &pdata
->pwr_gpios
, list
)
1007 gpio_set_value(og
->gpio
, on
);
1010 static int atmel_lcdfb_of_init(struct atmel_lcdfb_info
*sinfo
)
1012 struct fb_info
*info
= sinfo
->info
;
1013 struct atmel_lcdfb_pdata
*pdata
= &sinfo
->pdata
;
1014 struct fb_var_screeninfo
*var
= &info
->var
;
1015 struct device
*dev
= &sinfo
->pdev
->dev
;
1016 struct device_node
*np
=dev
->of_node
;
1017 struct device_node
*display_np
;
1018 struct device_node
*timings_np
;
1019 struct display_timings
*timings
;
1020 enum of_gpio_flags flags
;
1021 struct atmel_lcdfb_power_ctrl_gpio
*og
;
1022 bool is_gpio_power
= false;
1026 sinfo
->config
= (struct atmel_lcdfb_config
*)
1027 of_match_device(atmel_lcdfb_dt_ids
, dev
)->data
;
1029 display_np
= of_parse_phandle(np
, "display", 0);
1031 dev_err(dev
, "failed to find display phandle\n");
1035 ret
= of_property_read_u32(display_np
, "bits-per-pixel", &var
->bits_per_pixel
);
1037 dev_err(dev
, "failed to get property bits-per-pixel\n");
1038 goto put_display_node
;
1041 ret
= of_property_read_u32(display_np
, "atmel,guard-time", &pdata
->guard_time
);
1043 dev_err(dev
, "failed to get property atmel,guard-time\n");
1044 goto put_display_node
;
1047 ret
= of_property_read_u32(display_np
, "atmel,lcdcon2", &pdata
->default_lcdcon2
);
1049 dev_err(dev
, "failed to get property atmel,lcdcon2\n");
1050 goto put_display_node
;
1053 ret
= of_property_read_u32(display_np
, "atmel,dmacon", &pdata
->default_dmacon
);
1055 dev_err(dev
, "failed to get property bits-per-pixel\n");
1056 goto put_display_node
;
1060 for (i
= 0; i
< of_gpio_named_count(display_np
, "atmel,power-control-gpio"); i
++) {
1061 gpio
= of_get_named_gpio_flags(display_np
, "atmel,power-control-gpio",
1066 og
= devm_kzalloc(dev
, sizeof(*og
), GFP_KERNEL
);
1068 goto put_display_node
;
1071 og
->active_low
= flags
& OF_GPIO_ACTIVE_LOW
;
1072 is_gpio_power
= true;
1073 ret
= devm_gpio_request(dev
, gpio
, "lcd-power-control-gpio");
1075 dev_err(dev
, "request gpio %d failed\n", gpio
);
1076 goto put_display_node
;
1079 ret
= gpio_direction_output(gpio
, og
->active_low
);
1081 dev_err(dev
, "set direction output gpio %d failed\n", gpio
);
1082 goto put_display_node
;
1087 pdata
->atmel_lcdfb_power_control
= atmel_lcdfb_power_control_gpio
;
1089 ret
= atmel_lcdfb_get_of_wiring_modes(display_np
);
1091 dev_err(dev
, "invalid atmel,lcd-wiring-mode\n");
1092 goto put_display_node
;
1094 pdata
->lcd_wiring_mode
= ret
;
1096 pdata
->lcdcon_is_backlight
= of_property_read_bool(display_np
, "atmel,lcdcon-backlight");
1098 timings
= of_get_display_timings(display_np
);
1100 dev_err(dev
, "failed to get display timings\n");
1101 goto put_display_node
;
1104 timings_np
= of_find_node_by_name(display_np
, "display-timings");
1106 dev_err(dev
, "failed to find display-timings node\n");
1107 goto put_display_node
;
1110 for (i
= 0; i
< of_get_child_count(timings_np
); i
++) {
1111 struct videomode vm
;
1112 struct fb_videomode fb_vm
;
1114 ret
= videomode_from_timings(timings
, &vm
, i
);
1116 goto put_timings_node
;
1117 ret
= fb_videomode_from_videomode(&vm
, &fb_vm
);
1119 goto put_timings_node
;
1121 fb_add_videomode(&fb_vm
, &info
->modelist
);
1127 of_node_put(timings_np
);
1129 of_node_put(display_np
);
1133 static int atmel_lcdfb_of_init(struct atmel_lcdfb_info
*sinfo
)
1139 static int __init
atmel_lcdfb_probe(struct platform_device
*pdev
)
1141 struct device
*dev
= &pdev
->dev
;
1142 struct fb_info
*info
;
1143 struct atmel_lcdfb_info
*sinfo
;
1144 struct atmel_lcdfb_pdata
*pdata
= NULL
;
1145 struct resource
*regs
= NULL
;
1146 struct resource
*map
= NULL
;
1147 struct fb_modelist
*modelist
;
1150 dev_dbg(dev
, "%s BEGIN\n", __func__
);
1153 info
= framebuffer_alloc(sizeof(struct atmel_lcdfb_info
), dev
);
1155 dev_err(dev
, "cannot allocate memory\n");
1163 INIT_LIST_HEAD(&info
->modelist
);
1165 if (pdev
->dev
.of_node
) {
1166 ret
= atmel_lcdfb_of_init(sinfo
);
1169 } else if (dev_get_platdata(dev
)) {
1170 struct fb_monspecs
*monspecs
;
1173 pdata
= dev_get_platdata(dev
);
1174 monspecs
= pdata
->default_monspecs
;
1175 sinfo
->pdata
= *pdata
;
1177 for (i
= 0; i
< monspecs
->modedb_len
; i
++)
1178 fb_add_videomode(&monspecs
->modedb
[i
], &info
->modelist
);
1180 sinfo
->config
= atmel_lcdfb_get_config(pdev
);
1182 info
->var
.bits_per_pixel
= pdata
->default_bpp
? pdata
->default_bpp
: 16;
1183 memcpy(&info
->monspecs
, pdata
->default_monspecs
, sizeof(info
->monspecs
));
1185 dev_err(dev
, "cannot get default configuration\n");
1192 strcpy(info
->fix
.id
, sinfo
->pdev
->name
);
1193 info
->flags
= ATMEL_LCDFB_FBINFO_DEFAULT
;
1194 info
->pseudo_palette
= sinfo
->pseudo_palette
;
1195 info
->fbops
= &atmel_lcdfb_ops
;
1197 info
->fix
= atmel_lcdfb_fix
;
1199 /* Enable LCDC Clocks */
1200 sinfo
->bus_clk
= clk_get(dev
, "hclk");
1201 if (IS_ERR(sinfo
->bus_clk
)) {
1202 ret
= PTR_ERR(sinfo
->bus_clk
);
1205 sinfo
->lcdc_clk
= clk_get(dev
, "lcdc_clk");
1206 if (IS_ERR(sinfo
->lcdc_clk
)) {
1207 ret
= PTR_ERR(sinfo
->lcdc_clk
);
1210 atmel_lcdfb_start_clock(sinfo
);
1212 modelist
= list_first_entry(&info
->modelist
,
1213 struct fb_modelist
, list
);
1214 fb_videomode_to_var(&info
->var
, &modelist
->mode
);
1216 atmel_lcdfb_check_var(&info
->var
, info
);
1218 regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1220 dev_err(dev
, "resources unusable\n");
1225 sinfo
->irq_base
= platform_get_irq(pdev
, 0);
1226 if (sinfo
->irq_base
< 0) {
1227 dev_err(dev
, "unable to get irq\n");
1228 ret
= sinfo
->irq_base
;
1232 /* Initialize video memory */
1233 map
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
1235 /* use a pre-allocated memory buffer */
1236 info
->fix
.smem_start
= map
->start
;
1237 info
->fix
.smem_len
= resource_size(map
);
1238 if (!request_mem_region(info
->fix
.smem_start
,
1239 info
->fix
.smem_len
, pdev
->name
)) {
1244 info
->screen_base
= ioremap(info
->fix
.smem_start
, info
->fix
.smem_len
);
1245 if (!info
->screen_base
) {
1247 goto release_intmem
;
1251 * Don't clear the framebuffer -- someone may have set
1252 * up a splash image.
1255 /* allocate memory buffer */
1256 ret
= atmel_lcdfb_alloc_video_memory(sinfo
);
1258 dev_err(dev
, "cannot allocate framebuffer: %d\n", ret
);
1263 /* LCDC registers */
1264 info
->fix
.mmio_start
= regs
->start
;
1265 info
->fix
.mmio_len
= resource_size(regs
);
1267 if (!request_mem_region(info
->fix
.mmio_start
,
1268 info
->fix
.mmio_len
, pdev
->name
)) {
1273 sinfo
->mmio
= ioremap(info
->fix
.mmio_start
, info
->fix
.mmio_len
);
1275 dev_err(dev
, "cannot map LCDC registers\n");
1280 /* Initialize PWM for contrast or backlight ("off") */
1281 init_contrast(sinfo
);
1284 ret
= request_irq(sinfo
->irq_base
, atmel_lcdfb_interrupt
, 0, pdev
->name
, info
);
1286 dev_err(dev
, "request_irq failed: %d\n", ret
);
1290 /* Some operations on the LCDC might sleep and
1291 * require a preemptible task context */
1292 INIT_WORK(&sinfo
->task
, atmel_lcdfb_task
);
1294 ret
= atmel_lcdfb_init_fbinfo(sinfo
);
1296 dev_err(dev
, "init fbinfo failed: %d\n", ret
);
1297 goto unregister_irqs
;
1300 dev_set_drvdata(dev
, info
);
1303 * Tell the world that we're ready to go
1305 ret
= register_framebuffer(info
);
1307 dev_err(dev
, "failed to register framebuffer device: %d\n", ret
);
1311 /* Power up the LCDC screen */
1312 atmel_lcdfb_power_control(sinfo
, 1);
1314 dev_info(dev
, "fb%d: Atmel LCDC at 0x%08lx (mapped at %p), irq %d\n",
1315 info
->node
, info
->fix
.mmio_start
, sinfo
->mmio
, sinfo
->irq_base
);
1320 dev_set_drvdata(dev
, NULL
);
1321 fb_dealloc_cmap(&info
->cmap
);
1323 cancel_work_sync(&sinfo
->task
);
1324 free_irq(sinfo
->irq_base
, info
);
1326 exit_backlight(sinfo
);
1327 iounmap(sinfo
->mmio
);
1329 release_mem_region(info
->fix
.mmio_start
, info
->fix
.mmio_len
);
1332 iounmap(info
->screen_base
);
1334 atmel_lcdfb_free_video_memory(sinfo
);
1338 release_mem_region(info
->fix
.smem_start
, info
->fix
.smem_len
);
1340 atmel_lcdfb_stop_clock(sinfo
);
1341 clk_put(sinfo
->lcdc_clk
);
1343 clk_put(sinfo
->bus_clk
);
1345 framebuffer_release(info
);
1347 dev_dbg(dev
, "%s FAILED\n", __func__
);
1351 static int __exit
atmel_lcdfb_remove(struct platform_device
*pdev
)
1353 struct device
*dev
= &pdev
->dev
;
1354 struct fb_info
*info
= dev_get_drvdata(dev
);
1355 struct atmel_lcdfb_info
*sinfo
;
1356 struct atmel_lcdfb_pdata
*pdata
;
1358 if (!info
|| !info
->par
)
1361 pdata
= &sinfo
->pdata
;
1363 cancel_work_sync(&sinfo
->task
);
1364 exit_backlight(sinfo
);
1365 atmel_lcdfb_power_control(sinfo
, 0);
1366 unregister_framebuffer(info
);
1367 atmel_lcdfb_stop_clock(sinfo
);
1368 clk_put(sinfo
->lcdc_clk
);
1369 clk_put(sinfo
->bus_clk
);
1370 fb_dealloc_cmap(&info
->cmap
);
1371 free_irq(sinfo
->irq_base
, info
);
1372 iounmap(sinfo
->mmio
);
1373 release_mem_region(info
->fix
.mmio_start
, info
->fix
.mmio_len
);
1374 if (platform_get_resource(pdev
, IORESOURCE_MEM
, 1)) {
1375 iounmap(info
->screen_base
);
1376 release_mem_region(info
->fix
.smem_start
, info
->fix
.smem_len
);
1378 atmel_lcdfb_free_video_memory(sinfo
);
1381 framebuffer_release(info
);
1388 static int atmel_lcdfb_suspend(struct platform_device
*pdev
, pm_message_t mesg
)
1390 struct fb_info
*info
= platform_get_drvdata(pdev
);
1391 struct atmel_lcdfb_info
*sinfo
= info
->par
;
1394 * We don't want to handle interrupts while the clock is
1395 * stopped. It may take forever.
1397 lcdc_writel(sinfo
, ATMEL_LCDC_IDR
, ~0UL);
1399 sinfo
->saved_lcdcon
= lcdc_readl(sinfo
, ATMEL_LCDC_CONTRAST_CTR
);
1400 lcdc_writel(sinfo
, ATMEL_LCDC_CONTRAST_CTR
, 0);
1401 atmel_lcdfb_power_control(sinfo
, 0);
1402 atmel_lcdfb_stop(sinfo
);
1403 atmel_lcdfb_stop_clock(sinfo
);
1408 static int atmel_lcdfb_resume(struct platform_device
*pdev
)
1410 struct fb_info
*info
= platform_get_drvdata(pdev
);
1411 struct atmel_lcdfb_info
*sinfo
= info
->par
;
1413 atmel_lcdfb_start_clock(sinfo
);
1414 atmel_lcdfb_start(sinfo
);
1415 atmel_lcdfb_power_control(sinfo
, 1);
1416 lcdc_writel(sinfo
, ATMEL_LCDC_CONTRAST_CTR
, sinfo
->saved_lcdcon
);
1418 /* Enable FIFO & DMA errors */
1419 lcdc_writel(sinfo
, ATMEL_LCDC_IER
, ATMEL_LCDC_UFLWI
1420 | ATMEL_LCDC_OWRI
| ATMEL_LCDC_MERI
);
1426 #define atmel_lcdfb_suspend NULL
1427 #define atmel_lcdfb_resume NULL
1430 static struct platform_driver atmel_lcdfb_driver
= {
1431 .remove
= __exit_p(atmel_lcdfb_remove
),
1432 .suspend
= atmel_lcdfb_suspend
,
1433 .resume
= atmel_lcdfb_resume
,
1434 .id_table
= atmel_lcdfb_devtypes
,
1436 .name
= "atmel_lcdfb",
1437 .owner
= THIS_MODULE
,
1438 .of_match_table
= of_match_ptr(atmel_lcdfb_dt_ids
),
1442 module_platform_driver_probe(atmel_lcdfb_driver
, atmel_lcdfb_probe
);
1444 MODULE_DESCRIPTION("AT91/AT32 LCD Controller framebuffer driver");
1445 MODULE_AUTHOR("Nicolas Ferre <nicolas.ferre@atmel.com>");
1446 MODULE_LICENSE("GPL");