2 * BRIEF MODULE DESCRIPTION
5 * Rewritten for 2.6 by Embedded Alley Solutions
6 * <source@embeddedalley.com>, based on submissions by
7 * Karl Lessard <klessard@sunrisetelecom.com>
8 * <c.pellegrin@exadron.com>
10 * PM support added by Rodolfo Giometti <giometti@linux.it>
12 * Copyright 2002 MontaVista Software
13 * Author: MontaVista Software, Inc.
14 * ppopov@mvista.com or source@mvista.com
16 * Copyright 2002 Alchemy Semiconductor
17 * Author: Alchemy Semiconductor
20 * linux/drivers/video/skeletonfb.c -- Skeleton for a frame buffer device
21 * Created 28 Dec 1997 by Geert Uytterhoeven
23 * This program is free software; you can redistribute it and/or modify it
24 * under the terms of the GNU General Public License as published by the
25 * Free Software Foundation; either version 2 of the License, or (at your
26 * option) any later version.
28 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
29 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
30 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
31 * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
32 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
33 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
34 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
35 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
37 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 * You should have received a copy of the GNU General Public License along
40 * with this program; if not, write to the Free Software Foundation, Inc.,
41 * 675 Mass Ave, Cambridge, MA 02139, USA.
43 #include <linux/config.h>
44 #include <linux/module.h>
45 #include <linux/kernel.h>
46 #include <linux/errno.h>
47 #include <linux/string.h>
50 #include <linux/init.h>
51 #include <linux/interrupt.h>
52 #include <linux/ctype.h>
53 #include <linux/dma-mapping.h>
54 #include <linux/platform_device.h>
56 #include <asm/mach-au1x00/au1000.h>
63 * Sanity check. If this is a new Au1100 based board, search for
64 * the PB1100 ifdefs to make sure you modify the code accordingly.
66 #if defined(CONFIG_MIPS_PB1100)
67 #include <asm/mach-pb1x00/pb1100.h>
68 #elif defined(CONFIG_MIPS_DB1100)
69 #include <asm/mach-db1x00/db1x00.h>
71 #error "Unknown Au1100 board, Au1100 FB driver not supported"
74 #define DRIVER_NAME "au1100fb"
75 #define DRIVER_DESC "LCD controller driver for AU1100 processors"
77 #define to_au1100fb_device(_info) \
78 (_info ? container_of(_info, struct au1100fb_device, info) : NULL);
80 /* Bitfields format supported by the controller. Note that the order of formats
81 * SHOULD be the same as in the LCD_CONTROL_SBPPF field, so we can retrieve the
82 * right pixel format by doing rgb_bitfields[LCD_CONTROL_SBPPF_XXX >> LCD_CONTROL_SBPPF]
84 struct fb_bitfield rgb_bitfields
[][4] =
86 /* Red, Green, Blue, Transp */
87 { { 10, 6, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
88 { { 11, 5, 0 }, { 5, 6, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
89 { { 11, 5, 0 }, { 6, 5, 0 }, { 0, 6, 0 }, { 0, 0, 0 } },
90 { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 15, 1, 0 } },
91 { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 1, 0 } },
93 /* The last is used to describe 12bpp format */
94 { { 8, 4, 0 }, { 4, 4, 0 }, { 0, 4, 0 }, { 0, 0, 0 } },
97 static struct fb_fix_screeninfo au1100fb_fix __initdata
= {
101 .type
= FB_TYPE_PACKED_PIXELS
,
102 .accel
= FB_ACCEL_NONE
,
105 static struct fb_var_screeninfo au1100fb_var __initdata
= {
106 .activate
= FB_ACTIVATE_NOW
,
109 .vmode
= FB_VMODE_NONINTERLACED
,
112 static struct au1100fb_drv_info drv_info
;
115 * Set hardware with var settings. This will enable the controller with a specific
116 * mode, normally validated with the fb_check_var method
118 int au1100fb_setmode(struct au1100fb_device
*fbdev
)
120 struct fb_info
*info
= &fbdev
->info
;
127 /* Update var-dependent FB info */
128 if (panel_is_active(fbdev
->panel
) || panel_is_color(fbdev
->panel
)) {
129 if (info
->var
.bits_per_pixel
<= 8) {
131 info
->var
.red
.offset
= 0;
132 info
->var
.red
.length
= info
->var
.bits_per_pixel
;
133 info
->var
.red
.msb_right
= 0;
135 info
->var
.green
.offset
= 0;
136 info
->var
.green
.length
= info
->var
.bits_per_pixel
;
137 info
->var
.green
.msb_right
= 0;
139 info
->var
.blue
.offset
= 0;
140 info
->var
.blue
.length
= info
->var
.bits_per_pixel
;
141 info
->var
.blue
.msb_right
= 0;
143 info
->var
.transp
.offset
= 0;
144 info
->var
.transp
.length
= 0;
145 info
->var
.transp
.msb_right
= 0;
147 info
->fix
.visual
= FB_VISUAL_PSEUDOCOLOR
;
148 info
->fix
.line_length
= info
->var
.xres_virtual
/
149 (8/info
->var
.bits_per_pixel
);
152 index
= (fbdev
->panel
->control_base
& LCD_CONTROL_SBPPF_MASK
) >> LCD_CONTROL_SBPPF_BIT
;
153 info
->var
.red
= rgb_bitfields
[index
][0];
154 info
->var
.green
= rgb_bitfields
[index
][1];
155 info
->var
.blue
= rgb_bitfields
[index
][2];
156 info
->var
.transp
= rgb_bitfields
[index
][3];
158 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
159 info
->fix
.line_length
= info
->var
.xres_virtual
<< 1; /* depth=16 */
163 info
->fix
.visual
= FB_VISUAL_MONO10
;
164 info
->fix
.line_length
= info
->var
.xres_virtual
/ 8;
167 info
->screen_size
= info
->fix
.line_length
* info
->var
.yres_virtual
;
169 /* Determine BPP mode and format */
170 fbdev
->regs
->lcd_control
= fbdev
->panel
->control_base
|
171 ((info
->var
.rotate
/90) << LCD_CONTROL_SM_BIT
);
173 fbdev
->regs
->lcd_intenable
= 0;
174 fbdev
->regs
->lcd_intstatus
= 0;
176 fbdev
->regs
->lcd_horztiming
= fbdev
->panel
->horztiming
;
178 fbdev
->regs
->lcd_verttiming
= fbdev
->panel
->verttiming
;
180 fbdev
->regs
->lcd_clkcontrol
= fbdev
->panel
->clkcontrol_base
;
182 fbdev
->regs
->lcd_dmaaddr0
= LCD_DMA_SA_N(fbdev
->fb_phys
);
184 if (panel_is_dual(fbdev
->panel
)) {
185 /* Second panel display seconf half of screen if possible,
186 * otherwise display the same as the first panel */
187 if (info
->var
.yres_virtual
>= (info
->var
.yres
<< 1)) {
188 fbdev
->regs
->lcd_dmaaddr1
= LCD_DMA_SA_N(fbdev
->fb_phys
+
189 (info
->fix
.line_length
*
190 (info
->var
.yres_virtual
>> 1)));
192 fbdev
->regs
->lcd_dmaaddr1
= LCD_DMA_SA_N(fbdev
->fb_phys
);
196 words
= info
->fix
.line_length
/ sizeof(u32
);
197 if (!info
->var
.rotate
|| (info
->var
.rotate
== 180)) {
198 words
*= info
->var
.yres_virtual
;
199 if (info
->var
.rotate
/* 180 */) {
200 words
-= (words
% 8); /* should be divisable by 8 */
203 fbdev
->regs
->lcd_words
= LCD_WRD_WRDS_N(words
);
205 fbdev
->regs
->lcd_pwmdiv
= 0;
206 fbdev
->regs
->lcd_pwmhi
= 0;
208 /* Resume controller */
209 fbdev
->regs
->lcd_control
|= LCD_CONTROL_GO
;
215 * Set color in LCD palette.
217 int au1100fb_fb_setcolreg(unsigned regno
, unsigned red
, unsigned green
, unsigned blue
, unsigned transp
, struct fb_info
*fbi
)
219 struct au1100fb_device
*fbdev
;
223 fbdev
= to_au1100fb_device(fbi
);
224 palette
= fbdev
->regs
->lcd_pallettebase
;
226 if (regno
> (AU1100_LCD_NBR_PALETTE_ENTRIES
- 1))
229 if (fbi
->var
.grayscale
) {
230 /* Convert color to grayscale */
232 (19595 * red
+ 38470 * green
+ 7471 * blue
) >> 16;
235 if (fbi
->fix
.visual
== FB_VISUAL_TRUECOLOR
) {
236 /* Place color in the pseudopalette */
240 palette
= (u32
*)fbi
->pseudo_palette
;
242 red
>>= (16 - fbi
->var
.red
.length
);
243 green
>>= (16 - fbi
->var
.green
.length
);
244 blue
>>= (16 - fbi
->var
.blue
.length
);
246 value
= (red
<< fbi
->var
.red
.offset
) |
247 (green
<< fbi
->var
.green
.offset
)|
248 (blue
<< fbi
->var
.blue
.offset
);
251 } else if (panel_is_active(fbdev
->panel
)) {
252 /* COLOR TFT PALLETTIZED (use RGB 565) */
253 value
= (red
& 0xF800)|((green
>> 5) & 0x07E0)|((blue
>> 11) & 0x001F);
256 } else if (panel_is_color(fbdev
->panel
)) {
258 value
= (((panel_swap_rgb(fbdev
->panel
) ? blue
: red
) >> 12) & 0x000F) |
259 ((green
>> 8) & 0x00F0) |
260 (((panel_swap_rgb(fbdev
->panel
) ? red
: blue
) >> 4) & 0x0F00);
263 /* MONOCHROME MODE */
264 value
= (green
>> 12) & 0x000F;
268 palette
[regno
] = value
;
274 * Blank the screen. Depending on the mode, the screen will be
275 * activated with the backlight color, or desactivated
277 int au1100fb_fb_blank(int blank_mode
, struct fb_info
*fbi
)
279 struct au1100fb_device
*fbdev
= to_au1100fb_device(fbi
);
281 print_dbg("fb_blank %d %p", blank_mode
, fbi
);
283 switch (blank_mode
) {
285 case VESA_NO_BLANKING
:
287 fbdev
->regs
->lcd_control
|= LCD_CONTROL_GO
;
288 #ifdef CONFIG_MIPS_PB1100
289 if (drv_info
.panel_idx
== 1) {
290 au_writew(au_readw(PB1100_G_CONTROL
)
291 | (PB1100_G_CONTROL_BL
| PB1100_G_CONTROL_VDD
),
298 case VESA_VSYNC_SUSPEND
:
299 case VESA_HSYNC_SUSPEND
:
302 fbdev
->regs
->lcd_control
&= ~LCD_CONTROL_GO
;
303 #ifdef CONFIG_MIPS_PB1100
304 if (drv_info
.panel_idx
== 1) {
305 au_writew(au_readw(PB1100_G_CONTROL
)
306 & ~(PB1100_G_CONTROL_BL
| PB1100_G_CONTROL_VDD
),
320 * Pan display in x and/or y as specified
322 int au1100fb_fb_pan_display(struct fb_var_screeninfo
*var
, struct fb_info
*fbi
)
324 struct au1100fb_device
*fbdev
;
327 fbdev
= to_au1100fb_device(fbi
);
329 print_dbg("fb_pan_display %p %p", var
, fbi
);
331 if (!var
|| !fbdev
) {
335 if (var
->xoffset
- fbi
->var
.xoffset
) {
336 /* No support for X panning for now! */
340 print_dbg("fb_pan_display 2 %p %p", var
, fbi
);
341 dy
= var
->yoffset
- fbi
->var
.yoffset
;
346 print_dbg("Panning screen of %d lines", dy
);
348 dmaaddr
= fbdev
->regs
->lcd_dmaaddr0
;
349 dmaaddr
+= (fbi
->fix
.line_length
* dy
);
351 /* TODO: Wait for current frame to finished */
352 fbdev
->regs
->lcd_dmaaddr0
= LCD_DMA_SA_N(dmaaddr
);
354 if (panel_is_dual(fbdev
->panel
)) {
355 dmaaddr
= fbdev
->regs
->lcd_dmaaddr1
;
356 dmaaddr
+= (fbi
->fix
.line_length
* dy
);
357 fbdev
->regs
->lcd_dmaaddr0
= LCD_DMA_SA_N(dmaaddr
);
360 print_dbg("fb_pan_display 3 %p %p", var
, fbi
);
366 * Rotate the display of this angle. This doesn't seems to be used by the core,
367 * but as our hardware supports it, so why not implementing it...
369 void au1100fb_fb_rotate(struct fb_info
*fbi
, int angle
)
371 struct au1100fb_device
*fbdev
= to_au1100fb_device(fbi
);
373 print_dbg("fb_rotate %p %d", fbi
, angle
);
375 if (fbdev
&& (angle
> 0) && !(angle
% 90)) {
377 fbdev
->regs
->lcd_control
&= ~LCD_CONTROL_GO
;
379 fbdev
->regs
->lcd_control
&= ~(LCD_CONTROL_SM_MASK
);
380 fbdev
->regs
->lcd_control
|= ((angle
/90) << LCD_CONTROL_SM_BIT
);
382 fbdev
->regs
->lcd_control
|= LCD_CONTROL_GO
;
387 * Map video memory in user space. We don't use the generic fb_mmap method mainly
388 * to allow the use of the TLB streaming flag (CCA=6)
390 int au1100fb_fb_mmap(struct fb_info
*fbi
, struct vm_area_struct
*vma
)
392 struct au1100fb_device
*fbdev
;
394 unsigned long start
=0, off
;
396 fbdev
= to_au1100fb_device(fbi
);
398 if (vma
->vm_pgoff
> (~0UL >> PAGE_SHIFT
)) {
402 start
= fbdev
->fb_phys
& PAGE_MASK
;
403 len
= PAGE_ALIGN((start
& ~PAGE_MASK
) + fbdev
->fb_len
);
405 off
= vma
->vm_pgoff
<< PAGE_SHIFT
;
407 if ((vma
->vm_end
- vma
->vm_start
+ off
) > len
) {
412 vma
->vm_pgoff
= off
>> PAGE_SHIFT
;
414 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
415 pgprot_val(vma
->vm_page_prot
) |= (6 << 9); //CCA=6
417 vma
->vm_flags
|= VM_IO
;
419 if (io_remap_pfn_range(vma
, vma
->vm_start
, off
>> PAGE_SHIFT
,
420 vma
->vm_end
- vma
->vm_start
,
421 vma
->vm_page_prot
)) {
428 static struct fb_ops au1100fb_ops
=
430 .owner
= THIS_MODULE
,
431 .fb_setcolreg
= au1100fb_fb_setcolreg
,
432 .fb_blank
= au1100fb_fb_blank
,
433 .fb_pan_display
= au1100fb_fb_pan_display
,
434 .fb_fillrect
= cfb_fillrect
,
435 .fb_copyarea
= cfb_copyarea
,
436 .fb_imageblit
= cfb_imageblit
,
437 .fb_rotate
= au1100fb_fb_rotate
,
438 .fb_mmap
= au1100fb_fb_mmap
,
442 /*-------------------------------------------------------------------------*/
444 /* AU1100 LCD controller device driver */
446 int au1100fb_drv_probe(struct device
*dev
)
448 struct au1100fb_device
*fbdev
= NULL
;
449 struct resource
*regs_res
;
456 /* Allocate new device private */
457 if (!(fbdev
= kmalloc(sizeof(struct au1100fb_device
), GFP_KERNEL
))) {
458 print_err("fail to allocate device private record");
461 memset((void*)fbdev
, 0, sizeof(struct au1100fb_device
));
463 fbdev
->panel
= &known_lcd_panels
[drv_info
.panel_idx
];
465 dev_set_drvdata(dev
, (void*)fbdev
);
467 /* Allocate region for our registers and map them */
468 if (!(regs_res
= platform_get_resource(to_platform_device(dev
),
469 IORESOURCE_MEM
, 0))) {
470 print_err("fail to retrieve registers resource");
474 au1100fb_fix
.mmio_start
= regs_res
->start
;
475 au1100fb_fix
.mmio_len
= regs_res
->end
- regs_res
->start
+ 1;
477 if (!request_mem_region(au1100fb_fix
.mmio_start
, au1100fb_fix
.mmio_len
,
479 print_err("fail to lock memory region at 0x%08lx",
480 au1100fb_fix
.mmio_start
);
484 fbdev
->regs
= (struct au1100fb_regs
*)KSEG1ADDR(au1100fb_fix
.mmio_start
);
486 print_dbg("Register memory map at %p", fbdev
->regs
);
487 print_dbg("phys=0x%08x, size=%d", fbdev
->regs_phys
, fbdev
->regs_len
);
491 /* Allocate the framebuffer to the maximum screen size * nbr of video buffers */
492 fbdev
->fb_len
= fbdev
->panel
->xres
* fbdev
->panel
->yres
*
493 (fbdev
->panel
->bpp
>> 3) * AU1100FB_NBR_VIDEO_BUFFERS
;
495 fbdev
->fb_mem
= dma_alloc_coherent(dev
, PAGE_ALIGN(fbdev
->fb_len
),
496 &fbdev
->fb_phys
, GFP_KERNEL
);
497 if (!fbdev
->fb_mem
) {
498 print_err("fail to allocate frambuffer (size: %dK))",
499 fbdev
->fb_len
/ 1024);
503 au1100fb_fix
.smem_start
= fbdev
->fb_phys
;
504 au1100fb_fix
.smem_len
= fbdev
->fb_len
;
507 * Set page reserved so that mmap will work. This is necessary
508 * since we'll be remapping normal memory.
510 for (page
= (unsigned long)fbdev
->fb_mem
;
511 page
< PAGE_ALIGN((unsigned long)fbdev
->fb_mem
+ fbdev
->fb_len
);
513 #if CONFIG_DMA_NONCOHERENT
514 SetPageReserved(virt_to_page(CAC_ADDR(page
)));
516 SetPageReserved(virt_to_page(page
));
520 print_dbg("Framebuffer memory map at %p", fbdev
->fb_mem
);
521 print_dbg("phys=0x%08x, size=%dK", fbdev
->fb_phys
, fbdev
->fb_len
/ 1024);
523 /* Setup LCD clock to AUX (48 MHz) */
524 sys_clksrc
= au_readl(SYS_CLKSRC
) & ~(SYS_CS_ML_MASK
| SYS_CS_DL
| SYS_CS_CL
);
525 au_writel((sys_clksrc
| (1 << SYS_CS_ML_BIT
)), SYS_CLKSRC
);
527 /* load the panel info into the var struct */
528 au1100fb_var
.bits_per_pixel
= fbdev
->panel
->bpp
;
529 au1100fb_var
.xres
= fbdev
->panel
->xres
;
530 au1100fb_var
.xres_virtual
= au1100fb_var
.xres
;
531 au1100fb_var
.yres
= fbdev
->panel
->yres
;
532 au1100fb_var
.yres_virtual
= au1100fb_var
.yres
;
534 fbdev
->info
.screen_base
= fbdev
->fb_mem
;
535 fbdev
->info
.fbops
= &au1100fb_ops
;
536 fbdev
->info
.fix
= au1100fb_fix
;
538 if (!(fbdev
->info
.pseudo_palette
= kmalloc(sizeof(u32
) * 16, GFP_KERNEL
))) {
541 memset(fbdev
->info
.pseudo_palette
, 0, sizeof(u32
) * 16);
543 if (fb_alloc_cmap(&fbdev
->info
.cmap
, AU1100_LCD_NBR_PALETTE_ENTRIES
, 0) < 0) {
544 print_err("Fail to allocate colormap (%d entries)",
545 AU1100_LCD_NBR_PALETTE_ENTRIES
);
546 kfree(fbdev
->info
.pseudo_palette
);
550 fbdev
->info
.var
= au1100fb_var
;
552 /* Set h/w registers */
553 au1100fb_setmode(fbdev
);
555 /* Register new framebuffer */
556 if (register_framebuffer(&fbdev
->info
) < 0) {
557 print_err("cannot register new framebuffer");
565 release_mem_region(fbdev
->regs_phys
, fbdev
->regs_len
);
568 dma_free_noncoherent(dev
, fbdev
->fb_len
, fbdev
->fb_mem
, fbdev
->fb_phys
);
570 if (fbdev
->info
.cmap
.len
!= 0) {
571 fb_dealloc_cmap(&fbdev
->info
.cmap
);
574 dev_set_drvdata(dev
, NULL
);
579 int au1100fb_drv_remove(struct device
*dev
)
581 struct au1100fb_device
*fbdev
= NULL
;
586 fbdev
= (struct au1100fb_device
*) dev_get_drvdata(dev
);
588 #if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
589 au1100fb_fb_blank(VESA_POWERDOWN
, &fbdev
->info
);
591 fbdev
->regs
->lcd_control
&= ~LCD_CONTROL_GO
;
593 /* Clean up all probe data */
594 unregister_framebuffer(&fbdev
->info
);
596 release_mem_region(fbdev
->regs_phys
, fbdev
->regs_len
);
598 dma_free_coherent(dev
, PAGE_ALIGN(fbdev
->fb_len
), fbdev
->fb_mem
, fbdev
->fb_phys
);
600 fb_dealloc_cmap(&fbdev
->info
.cmap
);
601 kfree(fbdev
->info
.pseudo_palette
);
608 static u32 sys_clksrc
;
609 static struct au1100fb_regs fbregs
;
611 int au1100fb_drv_suspend(struct device
*dev
, pm_message_t state
)
613 struct au1100fb_device
*fbdev
= dev_get_drvdata(dev
);
618 /* Save the clock source state */
619 sys_clksrc
= au_readl(SYS_CLKSRC
);
622 au1100fb_fb_blank(VESA_POWERDOWN
, &fbdev
->info
);
624 /* Stop LCD clocking */
625 au_writel(sys_clksrc
& ~SYS_CS_ML_MASK
, SYS_CLKSRC
);
627 memcpy(&fbregs
, fbdev
->regs
, sizeof(struct au1100fb_regs
));
632 int au1100fb_drv_resume(struct device
*dev
)
634 struct au1100fb_device
*fbdev
= dev_get_drvdata(dev
);
639 memcpy(fbdev
->regs
, &fbregs
, sizeof(struct au1100fb_regs
));
641 /* Restart LCD clocking */
642 au_writel(sys_clksrc
, SYS_CLKSRC
);
644 /* Unblank the LCD */
645 au1100fb_fb_blank(VESA_NO_BLANKING
, &fbdev
->info
);
650 #define au1100fb_drv_suspend NULL
651 #define au1100fb_drv_resume NULL
654 static struct device_driver au1100fb_driver
= {
655 .name
= "au1100-lcd",
656 .bus
= &platform_bus_type
,
658 .probe
= au1100fb_drv_probe
,
659 .remove
= au1100fb_drv_remove
,
660 .suspend
= au1100fb_drv_suspend
,
661 .resume
= au1100fb_drv_resume
,
664 /*-------------------------------------------------------------------------*/
668 int au1100fb_setup(char *options
)
671 int num_panels
= ARRAY_SIZE(known_lcd_panels
);
675 if (num_panels
<= 0) {
676 print_err("No LCD panels supported by driver!");
681 while ((this_opt
= strsep(&options
,",")) != NULL
) {
683 if (!strncmp(this_opt
, "panel:", 6)) {
686 for (i
= 0; i
< num_panels
; i
++) {
687 if (!strncmp(this_opt
,
688 known_lcd_panels
[i
].name
,
694 if (i
>= num_panels
) {
695 print_warn("Panel %s not supported!", this_opt
);
698 /* Mode option (only option that start with digit) */
699 else if (isdigit(this_opt
[0])) {
700 mode
= kmalloc(strlen(this_opt
) + 1, GFP_KERNEL
);
701 strncpy(mode
, this_opt
, strlen(this_opt
) + 1);
703 /* Unsupported option */
705 print_warn("Unsupported option \"%s\"", this_opt
);
710 drv_info
.panel_idx
= panel_idx
;
711 drv_info
.opt_mode
= mode
;
713 print_info("Panel=%s Mode=%s",
714 known_lcd_panels
[drv_info
.panel_idx
].name
,
715 drv_info
.opt_mode
? drv_info
.opt_mode
: "default");
720 int __init
au1100fb_init(void)
725 print_info("" DRIVER_DESC
"");
727 memset(&drv_info
, 0, sizeof(drv_info
));
729 if (fb_get_options(DRIVER_NAME
, &options
))
732 /* Setup driver with options */
733 ret
= au1100fb_setup(options
);
735 print_err("Fail to setup driver");
739 return driver_register(&au1100fb_driver
);
742 void __exit
au1100fb_cleanup(void)
744 driver_unregister(&au1100fb_driver
);
746 kfree(drv_info
.opt_mode
);
749 module_init(au1100fb_init
);
750 module_exit(au1100fb_cleanup
);
752 MODULE_DESCRIPTION(DRIVER_DESC
);
753 MODULE_LICENSE("GPL");