[PATCH] more get_property() fallout
[linux-2.6] / drivers / video / w100fb.c
1 /*
2  * linux/drivers/video/w100fb.c
3  *
4  * Frame Buffer Device for ATI Imageon w100 (Wallaby)
5  *
6  * Copyright (C) 2002, ATI Corp.
7  * Copyright (C) 2004-2006 Richard Purdie
8  * Copyright (c) 2005 Ian Molton
9  * Copyright (c) 2006 Alberto Mardegan
10  *
11  * Rewritten for 2.6 by Richard Purdie <rpurdie@rpsys.net>
12  *
13  * Generic platform support by Ian Molton <spyro@f2s.com>
14  * and Richard Purdie <rpurdie@rpsys.net>
15  *
16  * w32xx support by Ian Molton
17  *
18  * Hardware acceleration support by Alberto Mardegan
19  * <mardy@users.sourceforge.net>
20  *
21  * This program is free software; you can redistribute it and/or modify
22  * it under the terms of the GNU General Public License version 2 as
23  * published by the Free Software Foundation.
24  *
25  */
26
27 #include <linux/delay.h>
28 #include <linux/fb.h>
29 #include <linux/init.h>
30 #include <linux/kernel.h>
31 #include <linux/mm.h>
32 #include <linux/platform_device.h>
33 #include <linux/string.h>
34 #include <linux/vmalloc.h>
35 #include <asm/io.h>
36 #include <asm/uaccess.h>
37 #include <video/w100fb.h>
38 #include "w100fb.h"
39
40 /*
41  * Prototypes
42  */
43 static void w100_suspend(u32 mode);
44 static void w100_vsync(void);
45 static void w100_hw_init(struct w100fb_par*);
46 static void w100_pwm_setup(struct w100fb_par*);
47 static void w100_init_clocks(struct w100fb_par*);
48 static void w100_setup_memory(struct w100fb_par*);
49 static void w100_init_lcd(struct w100fb_par*);
50 static void w100_set_dispregs(struct w100fb_par*);
51 static void w100_update_enable(void);
52 static void w100_update_disable(void);
53 static void calc_hsync(struct w100fb_par *par);
54 static void w100_init_graphic_engine(struct w100fb_par *par);
55 struct w100_pll_info *w100_get_xtal_table(unsigned int freq);
56
57 /* Pseudo palette size */
58 #define MAX_PALETTES      16
59
60 #define W100_SUSPEND_EXTMEM 0
61 #define W100_SUSPEND_ALL    1
62
63 #define BITS_PER_PIXEL    16
64
65 /* Remapped addresses for base cfg, memmapped regs and the frame buffer itself */
66 static void *remapped_base;
67 static void *remapped_regs;
68 static void *remapped_fbuf;
69
70 #define REMAPPED_FB_LEN   0x15ffff
71
72 /* This is the offset in the w100's address space we map the current
73    framebuffer memory to. We use the position of external memory as
74    we can remap internal memory to there if external isn't present. */
75 #define W100_FB_BASE MEM_EXT_BASE_VALUE
76
77
78 /*
79  * Sysfs functions
80  */
81 static ssize_t flip_show(struct device *dev, struct device_attribute *attr, char *buf)
82 {
83         struct fb_info *info = dev_get_drvdata(dev);
84         struct w100fb_par *par=info->par;
85
86         return sprintf(buf, "%d\n",par->flip);
87 }
88
89 static ssize_t flip_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
90 {
91         unsigned int flip;
92         struct fb_info *info = dev_get_drvdata(dev);
93         struct w100fb_par *par=info->par;
94
95         flip = simple_strtoul(buf, NULL, 10);
96
97         if (flip > 0)
98                 par->flip = 1;
99         else
100                 par->flip = 0;
101
102         w100_update_disable();
103         w100_set_dispregs(par);
104         w100_update_enable();
105
106         calc_hsync(par);
107
108         return count;
109 }
110
111 static DEVICE_ATTR(flip, 0644, flip_show, flip_store);
112
113 static ssize_t w100fb_reg_read(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
114 {
115         unsigned long regs, param;
116         regs = simple_strtoul(buf, NULL, 16);
117         param = readl(remapped_regs + regs);
118         printk("Read Register 0x%08lX: 0x%08lX\n", regs, param);
119         return count;
120 }
121
122 static DEVICE_ATTR(reg_read, 0200, NULL, w100fb_reg_read);
123
124 static ssize_t w100fb_reg_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
125 {
126         unsigned long regs, param;
127         sscanf(buf, "%lx %lx", &regs, &param);
128
129         if (regs <= 0x2000) {
130                 printk("Write Register 0x%08lX: 0x%08lX\n", regs, param);
131                 writel(param, remapped_regs + regs);
132         }
133
134         return count;
135 }
136
137 static DEVICE_ATTR(reg_write, 0200, NULL, w100fb_reg_write);
138
139
140 static ssize_t fastpllclk_show(struct device *dev, struct device_attribute *attr, char *buf)
141 {
142         struct fb_info *info = dev_get_drvdata(dev);
143         struct w100fb_par *par=info->par;
144
145         return sprintf(buf, "%d\n",par->fastpll_mode);
146 }
147
148 static ssize_t fastpllclk_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
149 {
150         struct fb_info *info = dev_get_drvdata(dev);
151         struct w100fb_par *par=info->par;
152
153         if (simple_strtoul(buf, NULL, 10) > 0) {
154                 par->fastpll_mode=1;
155                 printk("w100fb: Using fast system clock (if possible)\n");
156         } else {
157                 par->fastpll_mode=0;
158                 printk("w100fb: Using normal system clock\n");
159         }
160
161         w100_init_clocks(par);
162         calc_hsync(par);
163
164         return count;
165 }
166
167 static DEVICE_ATTR(fastpllclk, 0644, fastpllclk_show, fastpllclk_store);
168
169 /*
170  * Some touchscreens need hsync information from the video driver to
171  * function correctly. We export it here.
172  */
173 unsigned long w100fb_get_hsynclen(struct device *dev)
174 {
175         struct fb_info *info = dev_get_drvdata(dev);
176         struct w100fb_par *par=info->par;
177
178         /* If display is blanked/suspended, hsync isn't active */
179         if (par->blanked)
180                 return 0;
181         else
182                 return par->hsync_len;
183 }
184 EXPORT_SYMBOL(w100fb_get_hsynclen);
185
186 static void w100fb_clear_screen(struct w100fb_par *par)
187 {
188         memset_io(remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), 0, (par->xres * par->yres * BITS_PER_PIXEL/8));
189 }
190
191
192 /*
193  * Set a palette value from rgb components
194  */
195 static int w100fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
196                              u_int trans, struct fb_info *info)
197 {
198         unsigned int val;
199         int ret = 1;
200
201         /*
202          * If greyscale is true, then we convert the RGB value
203          * to greyscale no matter what visual we are using.
204          */
205         if (info->var.grayscale)
206                 red = green = blue = (19595 * red + 38470 * green + 7471 * blue) >> 16;
207
208         /*
209          * 16-bit True Colour.  We encode the RGB value
210          * according to the RGB bitfield information.
211          */
212         if (regno < MAX_PALETTES) {
213                 u32 *pal = info->pseudo_palette;
214
215                 val = (red & 0xf800) | ((green & 0xfc00) >> 5) | ((blue & 0xf800) >> 11);
216                 pal[regno] = val;
217                 ret = 0;
218         }
219         return ret;
220 }
221
222
223 /*
224  * Blank the display based on value in blank_mode
225  */
226 static int w100fb_blank(int blank_mode, struct fb_info *info)
227 {
228         struct w100fb_par *par = info->par;
229         struct w100_tg_info *tg = par->mach->tg;
230
231         switch(blank_mode) {
232
233         case FB_BLANK_NORMAL:         /* Normal blanking */
234         case FB_BLANK_VSYNC_SUSPEND:  /* VESA blank (vsync off) */
235         case FB_BLANK_HSYNC_SUSPEND:  /* VESA blank (hsync off) */
236         case FB_BLANK_POWERDOWN:      /* Poweroff */
237                 if (par->blanked == 0) {
238                         if(tg && tg->suspend)
239                                 tg->suspend(par);
240                         par->blanked = 1;
241                 }
242                 break;
243
244         case FB_BLANK_UNBLANK: /* Unblanking */
245                 if (par->blanked != 0) {
246                         if(tg && tg->resume)
247                                 tg->resume(par);
248                         par->blanked = 0;
249                 }
250                 break;
251         }
252         return 0;
253 }
254
255
256 static void w100_fifo_wait(int entries)
257 {
258         union rbbm_status_u status;
259         int i;
260
261         for (i = 0; i < 2000000; i++) {
262                 status.val = readl(remapped_regs + mmRBBM_STATUS);
263                 if (status.f.cmdfifo_avail >= entries)
264                         return;
265                 udelay(1);
266         }
267         printk(KERN_ERR "w100fb: FIFO Timeout!\n");
268 }
269
270
271 static int w100fb_sync(struct fb_info *info)
272 {
273         union rbbm_status_u status;
274         int i;
275
276         for (i = 0; i < 2000000; i++) {
277                 status.val = readl(remapped_regs + mmRBBM_STATUS);
278                 if (!status.f.gui_active)
279                         return 0;
280                 udelay(1);
281         }
282         printk(KERN_ERR "w100fb: Graphic engine timeout!\n");
283         return -EBUSY;
284 }
285
286
287 static void w100_init_graphic_engine(struct w100fb_par *par)
288 {
289         union dp_gui_master_cntl_u gmc;
290         union dp_mix_u dp_mix;
291         union dp_datatype_u dp_datatype;
292         union dp_cntl_u dp_cntl;
293
294         w100_fifo_wait(4);
295         writel(W100_FB_BASE, remapped_regs + mmDST_OFFSET);
296         writel(par->xres, remapped_regs + mmDST_PITCH);
297         writel(W100_FB_BASE, remapped_regs + mmSRC_OFFSET);
298         writel(par->xres, remapped_regs + mmSRC_PITCH);
299
300         w100_fifo_wait(3);
301         writel(0, remapped_regs + mmSC_TOP_LEFT);
302         writel((par->yres << 16) | par->xres, remapped_regs + mmSC_BOTTOM_RIGHT);
303         writel(0x1fff1fff, remapped_regs + mmSRC_SC_BOTTOM_RIGHT);
304
305         w100_fifo_wait(4);
306         dp_cntl.val = 0;
307         dp_cntl.f.dst_x_dir = 1;
308         dp_cntl.f.dst_y_dir = 1;
309         dp_cntl.f.src_x_dir = 1;
310         dp_cntl.f.src_y_dir = 1;
311         dp_cntl.f.dst_major_x = 1;
312         dp_cntl.f.src_major_x = 1;
313         writel(dp_cntl.val, remapped_regs + mmDP_CNTL);
314
315         gmc.val = 0;
316         gmc.f.gmc_src_pitch_offset_cntl = 1;
317         gmc.f.gmc_dst_pitch_offset_cntl = 1;
318         gmc.f.gmc_src_clipping = 1;
319         gmc.f.gmc_dst_clipping = 1;
320         gmc.f.gmc_brush_datatype = GMC_BRUSH_NONE;
321         gmc.f.gmc_dst_datatype = 3; /* from DstType_16Bpp_444 */
322         gmc.f.gmc_src_datatype = SRC_DATATYPE_EQU_DST;
323         gmc.f.gmc_byte_pix_order = 1;
324         gmc.f.gmc_default_sel = 0;
325         gmc.f.gmc_rop3 = ROP3_SRCCOPY;
326         gmc.f.gmc_dp_src_source = DP_SRC_MEM_RECTANGULAR;
327         gmc.f.gmc_clr_cmp_fcn_dis = 1;
328         gmc.f.gmc_wr_msk_dis = 1;
329         gmc.f.gmc_dp_op = DP_OP_ROP;
330         writel(gmc.val, remapped_regs + mmDP_GUI_MASTER_CNTL);
331
332         dp_datatype.val = dp_mix.val = 0;
333         dp_datatype.f.dp_dst_datatype = gmc.f.gmc_dst_datatype;
334         dp_datatype.f.dp_brush_datatype = gmc.f.gmc_brush_datatype;
335         dp_datatype.f.dp_src2_type = 0;
336         dp_datatype.f.dp_src2_datatype = gmc.f.gmc_src_datatype;
337         dp_datatype.f.dp_src_datatype = gmc.f.gmc_src_datatype;
338         dp_datatype.f.dp_byte_pix_order = gmc.f.gmc_byte_pix_order;
339         writel(dp_datatype.val, remapped_regs + mmDP_DATATYPE);
340
341         dp_mix.f.dp_src_source = gmc.f.gmc_dp_src_source;
342         dp_mix.f.dp_src2_source = 1;
343         dp_mix.f.dp_rop3 = gmc.f.gmc_rop3;
344         dp_mix.f.dp_op = gmc.f.gmc_dp_op;
345         writel(dp_mix.val, remapped_regs + mmDP_MIX);
346 }
347
348
349 static void w100fb_fillrect(struct fb_info *info,
350                             const struct fb_fillrect *rect)
351 {
352         union dp_gui_master_cntl_u gmc;
353
354         if (info->state != FBINFO_STATE_RUNNING)
355                 return;
356         if (info->flags & FBINFO_HWACCEL_DISABLED) {
357                 cfb_fillrect(info, rect);
358                 return;
359         }
360
361         gmc.val = readl(remapped_regs + mmDP_GUI_MASTER_CNTL);
362         gmc.f.gmc_rop3 = ROP3_PATCOPY;
363         gmc.f.gmc_brush_datatype = GMC_BRUSH_SOLID_COLOR;
364         w100_fifo_wait(2);
365         writel(gmc.val, remapped_regs + mmDP_GUI_MASTER_CNTL);
366         writel(rect->color, remapped_regs + mmDP_BRUSH_FRGD_CLR);
367
368         w100_fifo_wait(2);
369         writel((rect->dy << 16) | (rect->dx & 0xffff), remapped_regs + mmDST_Y_X);
370         writel((rect->width << 16) | (rect->height & 0xffff),
371                remapped_regs + mmDST_WIDTH_HEIGHT);
372 }
373
374
375 static void w100fb_copyarea(struct fb_info *info,
376                             const struct fb_copyarea *area)
377 {
378         u32 dx = area->dx, dy = area->dy, sx = area->sx, sy = area->sy;
379         u32 h = area->height, w = area->width;
380         union dp_gui_master_cntl_u gmc;
381
382         if (info->state != FBINFO_STATE_RUNNING)
383                 return;
384         if (info->flags & FBINFO_HWACCEL_DISABLED) {
385                 cfb_copyarea(info, area);
386                 return;
387         }
388
389         gmc.val = readl(remapped_regs + mmDP_GUI_MASTER_CNTL);
390         gmc.f.gmc_rop3 = ROP3_SRCCOPY;
391         gmc.f.gmc_brush_datatype = GMC_BRUSH_NONE;
392         w100_fifo_wait(1);
393         writel(gmc.val, remapped_regs + mmDP_GUI_MASTER_CNTL);
394
395         w100_fifo_wait(3);
396         writel((sy << 16) | (sx & 0xffff), remapped_regs + mmSRC_Y_X);
397         writel((dy << 16) | (dx & 0xffff), remapped_regs + mmDST_Y_X);
398         writel((w << 16) | (h & 0xffff), remapped_regs + mmDST_WIDTH_HEIGHT);
399 }
400
401
402 /*
403  *  Change the resolution by calling the appropriate hardware functions
404  */
405 static void w100fb_activate_var(struct w100fb_par *par)
406 {
407         struct w100_tg_info *tg = par->mach->tg;
408
409         w100_pwm_setup(par);
410         w100_setup_memory(par);
411         w100_init_clocks(par);
412         w100fb_clear_screen(par);
413         w100_vsync();
414
415         w100_update_disable();
416         w100_init_lcd(par);
417         w100_set_dispregs(par);
418         w100_update_enable();
419         w100_init_graphic_engine(par);
420
421         calc_hsync(par);
422
423         if (!par->blanked && tg && tg->change)
424                 tg->change(par);
425 }
426
427
428 /* Select the smallest mode that allows the desired resolution to be
429  * displayed. If desired, the x and y parameters can be rounded up to
430  * match the selected mode.
431  */
432 static struct w100_mode *w100fb_get_mode(struct w100fb_par *par, unsigned int *x, unsigned int *y, int saveval)
433 {
434         struct w100_mode *mode = NULL;
435         struct w100_mode *modelist = par->mach->modelist;
436         unsigned int best_x = 0xffffffff, best_y = 0xffffffff;
437         unsigned int i;
438
439         for (i = 0 ; i < par->mach->num_modes ; i++) {
440                 if (modelist[i].xres >= *x && modelist[i].yres >= *y &&
441                                 modelist[i].xres < best_x && modelist[i].yres < best_y) {
442                         best_x = modelist[i].xres;
443                         best_y = modelist[i].yres;
444                         mode = &modelist[i];
445                 } else if(modelist[i].xres >= *y && modelist[i].yres >= *x &&
446                         modelist[i].xres < best_y && modelist[i].yres < best_x) {
447                         best_x = modelist[i].yres;
448                         best_y = modelist[i].xres;
449                         mode = &modelist[i];
450                 }
451         }
452
453         if (mode && saveval) {
454                 *x = best_x;
455                 *y = best_y;
456         }
457
458         return mode;
459 }
460
461
462 /*
463  *  w100fb_check_var():
464  *  Get the video params out of 'var'. If a value doesn't fit, round it up,
465  *  if it's too big, return -EINVAL.
466  */
467 static int w100fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
468 {
469         struct w100fb_par *par=info->par;
470
471         if(!w100fb_get_mode(par, &var->xres, &var->yres, 1))
472                 return -EINVAL;
473
474         if (par->mach->mem && ((var->xres*var->yres*BITS_PER_PIXEL/8) > (par->mach->mem->size+1)))
475                 return -EINVAL;
476
477         if (!par->mach->mem && ((var->xres*var->yres*BITS_PER_PIXEL/8) > (MEM_INT_SIZE+1)))
478                 return -EINVAL;
479
480         var->xres_virtual = max(var->xres_virtual, var->xres);
481         var->yres_virtual = max(var->yres_virtual, var->yres);
482
483         if (var->bits_per_pixel > BITS_PER_PIXEL)
484                 return -EINVAL;
485         else
486                 var->bits_per_pixel = BITS_PER_PIXEL;
487
488         var->red.offset = 11;
489         var->red.length = 5;
490         var->green.offset = 5;
491         var->green.length = 6;
492         var->blue.offset = 0;
493         var->blue.length = 5;
494         var->transp.offset = var->transp.length = 0;
495
496         var->nonstd = 0;
497         var->height = -1;
498         var->width = -1;
499         var->vmode = FB_VMODE_NONINTERLACED;
500         var->sync = 0;
501         var->pixclock = 0x04;  /* 171521; */
502
503         return 0;
504 }
505
506
507 /*
508  * w100fb_set_par():
509  *      Set the user defined part of the display for the specified console
510  *  by looking at the values in info.var
511  */
512 static int w100fb_set_par(struct fb_info *info)
513 {
514         struct w100fb_par *par=info->par;
515
516         if (par->xres != info->var.xres || par->yres != info->var.yres) {
517                 par->xres = info->var.xres;
518                 par->yres = info->var.yres;
519                 par->mode = w100fb_get_mode(par, &par->xres, &par->yres, 0);
520
521                 info->fix.visual = FB_VISUAL_TRUECOLOR;
522                 info->fix.ypanstep = 0;
523                 info->fix.ywrapstep = 0;
524                 info->fix.line_length = par->xres * BITS_PER_PIXEL / 8;
525
526                 if ((par->xres*par->yres*BITS_PER_PIXEL/8) > (MEM_INT_SIZE+1)) {
527                         par->extmem_active = 1;
528                         info->fix.smem_len = par->mach->mem->size+1;
529                 } else {
530                         par->extmem_active = 0;
531                         info->fix.smem_len = MEM_INT_SIZE+1;
532                 }
533
534                 w100fb_activate_var(par);
535         }
536         return 0;
537 }
538
539
540 /*
541  *  Frame buffer operations
542  */
543 static struct fb_ops w100fb_ops = {
544         .owner        = THIS_MODULE,
545         .fb_check_var = w100fb_check_var,
546         .fb_set_par   = w100fb_set_par,
547         .fb_setcolreg = w100fb_setcolreg,
548         .fb_blank     = w100fb_blank,
549         .fb_fillrect  = w100fb_fillrect,
550         .fb_copyarea  = w100fb_copyarea,
551         .fb_imageblit = cfb_imageblit,
552         .fb_sync      = w100fb_sync,
553 };
554
555 #ifdef CONFIG_PM
556 static void w100fb_save_vidmem(struct w100fb_par *par)
557 {
558         int memsize;
559
560         if (par->extmem_active) {
561                 memsize=par->mach->mem->size;
562                 par->saved_extmem = vmalloc(memsize);
563                 if (par->saved_extmem)
564                         memcpy_fromio(par->saved_extmem, remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), memsize);
565         }
566         memsize=MEM_INT_SIZE;
567         par->saved_intmem = vmalloc(memsize);
568         if (par->saved_intmem && par->extmem_active)
569                 memcpy_fromio(par->saved_intmem, remapped_fbuf + (W100_FB_BASE-MEM_INT_BASE_VALUE), memsize);
570         else if (par->saved_intmem)
571                 memcpy_fromio(par->saved_intmem, remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), memsize);
572 }
573
574 static void w100fb_restore_vidmem(struct w100fb_par *par)
575 {
576         int memsize;
577
578         if (par->extmem_active && par->saved_extmem) {
579                 memsize=par->mach->mem->size;
580                 memcpy_toio(remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), par->saved_extmem, memsize);
581                 vfree(par->saved_extmem);
582         }
583         if (par->saved_intmem) {
584                 memsize=MEM_INT_SIZE;
585                 if (par->extmem_active)
586                         memcpy_toio(remapped_fbuf + (W100_FB_BASE-MEM_INT_BASE_VALUE), par->saved_intmem, memsize);
587                 else
588                         memcpy_toio(remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), par->saved_intmem, memsize);
589                 vfree(par->saved_intmem);
590         }
591 }
592
593 static int w100fb_suspend(struct platform_device *dev, pm_message_t state)
594 {
595         struct fb_info *info = platform_get_drvdata(dev);
596         struct w100fb_par *par=info->par;
597         struct w100_tg_info *tg = par->mach->tg;
598
599         w100fb_save_vidmem(par);
600         if(tg && tg->suspend)
601                 tg->suspend(par);
602         w100_suspend(W100_SUSPEND_ALL);
603         par->blanked = 1;
604
605         return 0;
606 }
607
608 static int w100fb_resume(struct platform_device *dev)
609 {
610         struct fb_info *info = platform_get_drvdata(dev);
611         struct w100fb_par *par=info->par;
612         struct w100_tg_info *tg = par->mach->tg;
613
614         w100_hw_init(par);
615         w100fb_activate_var(par);
616         w100fb_restore_vidmem(par);
617         if(tg && tg->resume)
618                 tg->resume(par);
619         par->blanked = 0;
620
621         return 0;
622 }
623 #else
624 #define w100fb_suspend  NULL
625 #define w100fb_resume   NULL
626 #endif
627
628
629 int __init w100fb_probe(struct platform_device *pdev)
630 {
631         int err = -EIO;
632         struct w100fb_mach_info *inf;
633         struct fb_info *info = NULL;
634         struct w100fb_par *par;
635         struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
636         unsigned int chip_id;
637
638         if (!mem)
639                 return -EINVAL;
640
641         /* Remap the chip base address */
642         remapped_base = ioremap_nocache(mem->start+W100_CFG_BASE, W100_CFG_LEN);
643         if (remapped_base == NULL)
644                 goto out;
645
646         /* Map the register space */
647         remapped_regs = ioremap_nocache(mem->start+W100_REG_BASE, W100_REG_LEN);
648         if (remapped_regs == NULL)
649                 goto out;
650
651         /* Identify the chip */
652         printk("Found ");
653         chip_id = readl(remapped_regs + mmCHIP_ID);
654         switch(chip_id) {
655                 case CHIP_ID_W100:  printk("w100");  break;
656                 case CHIP_ID_W3200: printk("w3200"); break;
657                 case CHIP_ID_W3220: printk("w3220"); break;
658                 default:
659                         printk("Unknown imageon chip ID\n");
660                         err = -ENODEV;
661                         goto out;
662         }
663         printk(" at 0x%08lx.\n", mem->start+W100_CFG_BASE);
664
665         /* Remap the framebuffer */
666         remapped_fbuf = ioremap_nocache(mem->start+MEM_WINDOW_BASE, MEM_WINDOW_SIZE);
667         if (remapped_fbuf == NULL)
668                 goto out;
669
670         info=framebuffer_alloc(sizeof(struct w100fb_par), &pdev->dev);
671         if (!info) {
672                 err = -ENOMEM;
673                 goto out;
674         }
675
676         par = info->par;
677         platform_set_drvdata(pdev, info);
678
679         inf = pdev->dev.platform_data;
680         par->chip_id = chip_id;
681         par->mach = inf;
682         par->fastpll_mode = 0;
683         par->blanked = 0;
684
685         par->pll_table=w100_get_xtal_table(inf->xtal_freq);
686         if (!par->pll_table) {
687                 printk(KERN_ERR "No matching Xtal definition found\n");
688                 err = -EINVAL;
689                 goto out;
690         }
691
692         info->pseudo_palette = kmalloc(sizeof (u32) * MAX_PALETTES, GFP_KERNEL);
693         if (!info->pseudo_palette) {
694                 err = -ENOMEM;
695                 goto out;
696         }
697
698         info->fbops = &w100fb_ops;
699         info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_COPYAREA |
700                 FBINFO_HWACCEL_FILLRECT;
701         info->node = -1;
702         info->screen_base = remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE);
703         info->screen_size = REMAPPED_FB_LEN;
704
705         strcpy(info->fix.id, "w100fb");
706         info->fix.type = FB_TYPE_PACKED_PIXELS;
707         info->fix.type_aux = 0;
708         info->fix.accel = FB_ACCEL_NONE;
709         info->fix.smem_start = mem->start+W100_FB_BASE;
710         info->fix.mmio_start = mem->start+W100_REG_BASE;
711         info->fix.mmio_len = W100_REG_LEN;
712
713         if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
714                 err = -ENOMEM;
715                 goto out;
716         }
717
718         par->mode = &inf->modelist[0];
719         if(inf->init_mode & INIT_MODE_ROTATED) {
720                 info->var.xres = par->mode->yres;
721                 info->var.yres = par->mode->xres;
722         }
723         else {
724                 info->var.xres = par->mode->xres;
725                 info->var.yres = par->mode->yres;
726         }
727
728         if(inf->init_mode &= INIT_MODE_FLIPPED)
729                 par->flip = 1;
730         else
731                 par->flip = 0;
732
733         info->var.xres_virtual = info->var.xres;
734         info->var.yres_virtual = info->var.yres;
735         info->var.pixclock = 0x04;  /* 171521; */
736         info->var.sync = 0;
737         info->var.grayscale = 0;
738         info->var.xoffset = info->var.yoffset = 0;
739         info->var.accel_flags = 0;
740         info->var.activate = FB_ACTIVATE_NOW;
741
742         w100_hw_init(par);
743
744         if (w100fb_check_var(&info->var, info) < 0) {
745                 err = -EINVAL;
746                 goto out;
747         }
748
749         w100fb_set_par(info);
750
751         if (register_framebuffer(info) < 0) {
752                 err = -EINVAL;
753                 goto out;
754         }
755
756         device_create_file(&pdev->dev, &dev_attr_fastpllclk);
757         device_create_file(&pdev->dev, &dev_attr_reg_read);
758         device_create_file(&pdev->dev, &dev_attr_reg_write);
759         device_create_file(&pdev->dev, &dev_attr_flip);
760
761         printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id);
762         return 0;
763 out:
764         fb_dealloc_cmap(&info->cmap);
765         kfree(info->pseudo_palette);
766         if (remapped_fbuf != NULL)
767                 iounmap(remapped_fbuf);
768         if (remapped_regs != NULL)
769                 iounmap(remapped_regs);
770         if (remapped_base != NULL)
771                 iounmap(remapped_base);
772         if (info)
773                 framebuffer_release(info);
774         return err;
775 }
776
777
778 static int w100fb_remove(struct platform_device *pdev)
779 {
780         struct fb_info *info = platform_get_drvdata(pdev);
781         struct w100fb_par *par=info->par;
782
783         device_remove_file(&pdev->dev, &dev_attr_fastpllclk);
784         device_remove_file(&pdev->dev, &dev_attr_reg_read);
785         device_remove_file(&pdev->dev, &dev_attr_reg_write);
786         device_remove_file(&pdev->dev, &dev_attr_flip);
787
788         unregister_framebuffer(info);
789
790         vfree(par->saved_intmem);
791         vfree(par->saved_extmem);
792         kfree(info->pseudo_palette);
793         fb_dealloc_cmap(&info->cmap);
794
795         iounmap(remapped_base);
796         iounmap(remapped_regs);
797         iounmap(remapped_fbuf);
798
799         framebuffer_release(info);
800
801         return 0;
802 }
803
804
805 /* ------------------- chipset specific functions -------------------------- */
806
807
808 static void w100_soft_reset(void)
809 {
810         u16 val = readw((u16 *) remapped_base + cfgSTATUS);
811         writew(val | 0x08, (u16 *) remapped_base + cfgSTATUS);
812         udelay(100);
813         writew(0x00, (u16 *) remapped_base + cfgSTATUS);
814         udelay(100);
815 }
816
817 static void w100_update_disable(void)
818 {
819         union disp_db_buf_cntl_wr_u disp_db_buf_wr_cntl;
820
821         /* Prevent display updates */
822         disp_db_buf_wr_cntl.f.db_buf_cntl = 0x1e;
823         disp_db_buf_wr_cntl.f.update_db_buf = 0;
824         disp_db_buf_wr_cntl.f.en_db_buf = 0;
825         writel((u32) (disp_db_buf_wr_cntl.val), remapped_regs + mmDISP_DB_BUF_CNTL);
826 }
827
828 static void w100_update_enable(void)
829 {
830         union disp_db_buf_cntl_wr_u disp_db_buf_wr_cntl;
831
832         /* Enable display updates */
833         disp_db_buf_wr_cntl.f.db_buf_cntl = 0x1e;
834         disp_db_buf_wr_cntl.f.update_db_buf = 1;
835         disp_db_buf_wr_cntl.f.en_db_buf = 1;
836         writel((u32) (disp_db_buf_wr_cntl.val), remapped_regs + mmDISP_DB_BUF_CNTL);
837 }
838
839 unsigned long w100fb_gpio_read(int port)
840 {
841         unsigned long value;
842
843         if (port==W100_GPIO_PORT_A)
844                 value = readl(remapped_regs + mmGPIO_DATA);
845         else
846                 value = readl(remapped_regs + mmGPIO_DATA2);
847
848         return value;
849 }
850
851 void w100fb_gpio_write(int port, unsigned long value)
852 {
853         if (port==W100_GPIO_PORT_A)
854                 value = writel(value, remapped_regs + mmGPIO_DATA);
855         else
856                 value = writel(value, remapped_regs + mmGPIO_DATA2);
857 }
858 EXPORT_SYMBOL(w100fb_gpio_read);
859 EXPORT_SYMBOL(w100fb_gpio_write);
860
861 /*
862  * Initialization of critical w100 hardware
863  */
864 static void w100_hw_init(struct w100fb_par *par)
865 {
866         u32 temp32;
867         union cif_cntl_u cif_cntl;
868         union intf_cntl_u intf_cntl;
869         union cfgreg_base_u cfgreg_base;
870         union wrap_top_dir_u wrap_top_dir;
871         union cif_read_dbg_u cif_read_dbg;
872         union cpu_defaults_u cpu_default;
873         union cif_write_dbg_u cif_write_dbg;
874         union wrap_start_dir_u wrap_start_dir;
875         union cif_io_u cif_io;
876         struct w100_gpio_regs *gpio = par->mach->gpio;
877
878         w100_soft_reset();
879
880         /* This is what the fpga_init code does on reset. May be wrong
881            but there is little info available */
882         writel(0x31, remapped_regs + mmSCRATCH_UMSK);
883         for (temp32 = 0; temp32 < 10000; temp32++)
884                 readl(remapped_regs + mmSCRATCH_UMSK);
885         writel(0x30, remapped_regs + mmSCRATCH_UMSK);
886
887         /* Set up CIF */
888         cif_io.val = defCIF_IO;
889         writel((u32)(cif_io.val), remapped_regs + mmCIF_IO);
890
891         cif_write_dbg.val = readl(remapped_regs + mmCIF_WRITE_DBG);
892         cif_write_dbg.f.dis_packer_ful_during_rbbm_timeout = 0;
893         cif_write_dbg.f.en_dword_split_to_rbbm = 1;
894         cif_write_dbg.f.dis_timeout_during_rbbm = 1;
895         writel((u32) (cif_write_dbg.val), remapped_regs + mmCIF_WRITE_DBG);
896
897         cif_read_dbg.val = readl(remapped_regs + mmCIF_READ_DBG);
898         cif_read_dbg.f.dis_rd_same_byte_to_trig_fetch = 1;
899         writel((u32) (cif_read_dbg.val), remapped_regs + mmCIF_READ_DBG);
900
901         cif_cntl.val = readl(remapped_regs + mmCIF_CNTL);
902         cif_cntl.f.dis_system_bits = 1;
903         cif_cntl.f.dis_mr = 1;
904         cif_cntl.f.en_wait_to_compensate_dq_prop_dly = 0;
905         cif_cntl.f.intb_oe = 1;
906         cif_cntl.f.interrupt_active_high = 1;
907         writel((u32) (cif_cntl.val), remapped_regs + mmCIF_CNTL);
908
909         /* Setup cfgINTF_CNTL and cfgCPU defaults */
910         intf_cntl.val = defINTF_CNTL;
911         intf_cntl.f.ad_inc_a = 1;
912         intf_cntl.f.ad_inc_b = 1;
913         intf_cntl.f.rd_data_rdy_a = 0;
914         intf_cntl.f.rd_data_rdy_b = 0;
915         writeb((u8) (intf_cntl.val), remapped_base + cfgINTF_CNTL);
916
917         cpu_default.val = defCPU_DEFAULTS;
918         cpu_default.f.access_ind_addr_a = 1;
919         cpu_default.f.access_ind_addr_b = 1;
920         cpu_default.f.access_scratch_reg = 1;
921         cpu_default.f.transition_size = 0;
922         writeb((u8) (cpu_default.val), remapped_base + cfgCPU_DEFAULTS);
923
924         /* set up the apertures */
925         writeb((u8) (W100_REG_BASE >> 16), remapped_base + cfgREG_BASE);
926
927         cfgreg_base.val = defCFGREG_BASE;
928         cfgreg_base.f.cfgreg_base = W100_CFG_BASE;
929         writel((u32) (cfgreg_base.val), remapped_regs + mmCFGREG_BASE);
930
931         wrap_start_dir.val = defWRAP_START_DIR;
932         wrap_start_dir.f.start_addr = WRAP_BUF_BASE_VALUE >> 1;
933         writel((u32) (wrap_start_dir.val), remapped_regs + mmWRAP_START_DIR);
934
935         wrap_top_dir.val = defWRAP_TOP_DIR;
936         wrap_top_dir.f.top_addr = WRAP_BUF_TOP_VALUE >> 1;
937         writel((u32) (wrap_top_dir.val), remapped_regs + mmWRAP_TOP_DIR);
938
939         writel((u32) 0x2440, remapped_regs + mmRBBM_CNTL);
940
941         /* Set the hardware to 565 colour */
942         temp32 = readl(remapped_regs + mmDISP_DEBUG2);
943         temp32 &= 0xff7fffff;
944         temp32 |= 0x00800000;
945         writel(temp32, remapped_regs + mmDISP_DEBUG2);
946
947         /* Initialise the GPIO lines */
948         if (gpio) {
949                 writel(gpio->init_data1, remapped_regs + mmGPIO_DATA);
950                 writel(gpio->init_data2, remapped_regs + mmGPIO_DATA2);
951                 writel(gpio->gpio_dir1,  remapped_regs + mmGPIO_CNTL1);
952                 writel(gpio->gpio_oe1,   remapped_regs + mmGPIO_CNTL2);
953                 writel(gpio->gpio_dir2,  remapped_regs + mmGPIO_CNTL3);
954                 writel(gpio->gpio_oe2,   remapped_regs + mmGPIO_CNTL4);
955         }
956 }
957
958
959 struct power_state {
960         union clk_pin_cntl_u clk_pin_cntl;
961         union pll_ref_fb_div_u pll_ref_fb_div;
962         union pll_cntl_u pll_cntl;
963         union sclk_cntl_u sclk_cntl;
964         union pclk_cntl_u pclk_cntl;
965         union pwrmgt_cntl_u pwrmgt_cntl;
966         int auto_mode;  /* system clock auto changing? */
967 };
968
969
970 static struct power_state w100_pwr_state;
971
972 /* The PLL Fout is determined by (XtalFreq/(M+1)) * ((N_int+1) + (N_fac/8)) */
973
974 /* 12.5MHz Crystal PLL Table */
975 static struct w100_pll_info xtal_12500000[] = {
976         /*freq     M   N_int    N_fac  tfgoal  lock_time */
977         { 50,      0,   1,       0,     0xe0,        56},  /*  50.00 MHz */
978         { 75,      0,   5,       0,     0xde,        37},  /*  75.00 MHz */
979         {100,      0,   7,       0,     0xe0,        28},  /* 100.00 MHz */
980         {125,      0,   9,       0,     0xe0,        22},  /* 125.00 MHz */
981         {150,      0,   11,      0,     0xe0,        17},  /* 150.00 MHz */
982         {  0,      0,   0,       0,        0,         0},  /* Terminator */
983 };
984
985 /* 14.318MHz Crystal PLL Table */
986 static struct w100_pll_info xtal_14318000[] = {
987         /*freq     M   N_int    N_fac  tfgoal  lock_time */
988         { 40,      4,   13,      0,     0xe0,        80}, /* tfgoal guessed */
989         { 50,      1,   6,       0,     0xe0,        64}, /*  50.05 MHz */
990         { 57,      2,   11,      0,     0xe0,        53}, /* tfgoal guessed */
991         { 75,      0,   4,       3,     0xe0,        43}, /*  75.08 MHz */
992         {100,      0,   6,       0,     0xe0,        32}, /* 100.10 MHz */
993         {  0,      0,   0,       0,        0,         0},
994 };
995
996 /* 16MHz Crystal PLL Table */
997 static struct w100_pll_info xtal_16000000[] = {
998         /*freq     M   N_int    N_fac  tfgoal  lock_time */
999         { 72,      1,   8,       0,     0xe0,        48}, /* tfgoal guessed */
1000         { 95,      1,   10,      7,     0xe0,        38}, /* tfgoal guessed */
1001         { 96,      1,   11,      0,     0xe0,        36}, /* tfgoal guessed */
1002         {  0,      0,   0,       0,        0,         0},
1003 };
1004
1005 static struct pll_entries {
1006         int xtal_freq;
1007         struct w100_pll_info *pll_table;
1008 } w100_pll_tables[] = {
1009         { 12500000, &xtal_12500000[0] },
1010         { 14318000, &xtal_14318000[0] },
1011         { 16000000, &xtal_16000000[0] },
1012         { 0 },
1013 };
1014
1015 struct w100_pll_info *w100_get_xtal_table(unsigned int freq)
1016 {
1017         struct pll_entries *pll_entry = w100_pll_tables;
1018
1019         do {
1020                 if (freq == pll_entry->xtal_freq)
1021                         return pll_entry->pll_table;
1022                 pll_entry++;
1023         } while (pll_entry->xtal_freq);
1024         return 0;
1025 }
1026
1027
1028 static unsigned int w100_get_testcount(unsigned int testclk_sel)
1029 {
1030         union clk_test_cntl_u clk_test_cntl;
1031
1032         udelay(5);
1033
1034         /* Select the test clock source and reset */
1035         clk_test_cntl.f.start_check_freq = 0x0;
1036         clk_test_cntl.f.testclk_sel = testclk_sel;
1037         clk_test_cntl.f.tstcount_rst = 0x1; /* set reset */
1038         writel((u32) (clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
1039
1040         clk_test_cntl.f.tstcount_rst = 0x0; /* clear reset */
1041         writel((u32) (clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
1042
1043         /* Run clock test */
1044         clk_test_cntl.f.start_check_freq = 0x1;
1045         writel((u32) (clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
1046
1047         /* Give the test time to complete */
1048         udelay(20);
1049
1050         /* Return the result */
1051         clk_test_cntl.val = readl(remapped_regs + mmCLK_TEST_CNTL);
1052         clk_test_cntl.f.start_check_freq = 0x0;
1053         writel((u32) (clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
1054
1055         return clk_test_cntl.f.test_count;
1056 }
1057
1058
1059 static int w100_pll_adjust(struct w100_pll_info *pll)
1060 {
1061         unsigned int tf80;
1062         unsigned int tf20;
1063
1064         /* Initial Settings */
1065         w100_pwr_state.pll_cntl.f.pll_pwdn = 0x0;     /* power down */
1066         w100_pwr_state.pll_cntl.f.pll_reset = 0x0;    /* not reset */
1067         w100_pwr_state.pll_cntl.f.pll_tcpoff = 0x1;   /* Hi-Z */
1068         w100_pwr_state.pll_cntl.f.pll_pvg = 0x0;      /* VCO gain = 0 */
1069         w100_pwr_state.pll_cntl.f.pll_vcofr = 0x0;    /* VCO frequency range control = off */
1070         w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;  /* current offset inside VCO = 0 */
1071         w100_pwr_state.pll_cntl.f.pll_ring_off = 0x0;
1072
1073         /* Wai Ming 80 percent of VDD 1.3V gives 1.04V, minimum operating voltage is 1.08V
1074          * therefore, commented out the following lines
1075          * tf80 meant tf100
1076          */
1077         do {
1078                 /* set VCO input = 0.8 * VDD */
1079                 w100_pwr_state.pll_cntl.f.pll_dactal = 0xd;
1080                 writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
1081
1082                 tf80 = w100_get_testcount(TESTCLK_SRC_PLL);
1083                 if (tf80 >= (pll->tfgoal)) {
1084                         /* set VCO input = 0.2 * VDD */
1085                         w100_pwr_state.pll_cntl.f.pll_dactal = 0x7;
1086                         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
1087
1088                         tf20 = w100_get_testcount(TESTCLK_SRC_PLL);
1089                         if (tf20 <= (pll->tfgoal))
1090                                 return 1;  /* Success */
1091
1092                         if ((w100_pwr_state.pll_cntl.f.pll_vcofr == 0x0) &&
1093                                 ((w100_pwr_state.pll_cntl.f.pll_pvg == 0x7) ||
1094                                 (w100_pwr_state.pll_cntl.f.pll_ioffset == 0x0))) {
1095                                 /* slow VCO config */
1096                                 w100_pwr_state.pll_cntl.f.pll_vcofr = 0x1;
1097                                 w100_pwr_state.pll_cntl.f.pll_pvg = 0x0;
1098                                 w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;
1099                                 continue;
1100                         }
1101                 }
1102                 if ((w100_pwr_state.pll_cntl.f.pll_ioffset) < 0x3) {
1103                         w100_pwr_state.pll_cntl.f.pll_ioffset += 0x1;
1104                 } else if ((w100_pwr_state.pll_cntl.f.pll_pvg) < 0x7) {
1105                         w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;
1106                         w100_pwr_state.pll_cntl.f.pll_pvg += 0x1;
1107                 } else {
1108                         return 0;  /* Error */
1109                 }
1110         } while(1);
1111 }
1112
1113
1114 /*
1115  * w100_pll_calibration
1116  */
1117 static int w100_pll_calibration(struct w100_pll_info *pll)
1118 {
1119         int status;
1120
1121         status = w100_pll_adjust(pll);
1122
1123         /* PLL Reset And Lock */
1124         /* set VCO input = 0.5 * VDD */
1125         w100_pwr_state.pll_cntl.f.pll_dactal = 0xa;
1126         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
1127
1128         udelay(1);  /* reset time */
1129
1130         /* enable charge pump */
1131         w100_pwr_state.pll_cntl.f.pll_tcpoff = 0x0;  /* normal */
1132         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
1133
1134         /* set VCO input = Hi-Z, disable DAC */
1135         w100_pwr_state.pll_cntl.f.pll_dactal = 0x0;
1136         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
1137
1138         udelay(400);  /* lock time */
1139
1140         /* PLL locked */
1141
1142         return status;
1143 }
1144
1145
1146 static int w100_pll_set_clk(struct w100_pll_info *pll)
1147 {
1148         int status;
1149
1150         if (w100_pwr_state.auto_mode == 1)  /* auto mode */
1151         {
1152                 w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_hw_en = 0x0;  /* disable fast to normal */
1153                 w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_hw_en = 0x0;  /* disable normal to fast */
1154                 writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
1155         }
1156
1157         /* Set system clock source to XTAL whilst adjusting the PLL! */
1158         w100_pwr_state.sclk_cntl.f.sclk_src_sel = CLK_SRC_XTAL;
1159         writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
1160
1161         w100_pwr_state.pll_ref_fb_div.f.pll_ref_div = pll->M;
1162         w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_int = pll->N_int;
1163         w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_frac = pll->N_fac;
1164         w100_pwr_state.pll_ref_fb_div.f.pll_lock_time = pll->lock_time;
1165         writel((u32) (w100_pwr_state.pll_ref_fb_div.val), remapped_regs + mmPLL_REF_FB_DIV);
1166
1167         w100_pwr_state.pwrmgt_cntl.f.pwm_mode_req = 0;
1168         writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
1169
1170         status = w100_pll_calibration(pll);
1171
1172         if (w100_pwr_state.auto_mode == 1)  /* auto mode */
1173         {
1174                 w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_hw_en = 0x1;  /* reenable fast to normal */
1175                 w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_hw_en = 0x1;  /* reenable normal to fast  */
1176                 writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
1177         }
1178         return status;
1179 }
1180
1181 /* freq = target frequency of the PLL */
1182 static int w100_set_pll_freq(struct w100fb_par *par, unsigned int freq)
1183 {
1184         struct w100_pll_info *pll = par->pll_table;
1185
1186         do {
1187                 if (freq == pll->freq) {
1188                         return w100_pll_set_clk(pll);
1189                 }
1190                 pll++;
1191         } while(pll->freq);
1192         return 0;
1193 }
1194
1195 /* Set up an initial state.  Some values/fields set
1196    here will be overwritten. */
1197 static void w100_pwm_setup(struct w100fb_par *par)
1198 {
1199         w100_pwr_state.clk_pin_cntl.f.osc_en = 0x1;
1200         w100_pwr_state.clk_pin_cntl.f.osc_gain = 0x1f;
1201         w100_pwr_state.clk_pin_cntl.f.dont_use_xtalin = 0x0;
1202         w100_pwr_state.clk_pin_cntl.f.xtalin_pm_en = 0x0;
1203         w100_pwr_state.clk_pin_cntl.f.xtalin_dbl_en = par->mach->xtal_dbl ? 1 : 0;
1204         w100_pwr_state.clk_pin_cntl.f.cg_debug = 0x0;
1205         writel((u32) (w100_pwr_state.clk_pin_cntl.val), remapped_regs + mmCLK_PIN_CNTL);
1206
1207         w100_pwr_state.sclk_cntl.f.sclk_src_sel = CLK_SRC_XTAL;
1208         w100_pwr_state.sclk_cntl.f.sclk_post_div_fast = 0x0;  /* Pfast = 1 */
1209         w100_pwr_state.sclk_cntl.f.sclk_clkon_hys = 0x3;
1210         w100_pwr_state.sclk_cntl.f.sclk_post_div_slow = 0x0;  /* Pslow = 1 */
1211         w100_pwr_state.sclk_cntl.f.disp_cg_ok2switch_en = 0x0;
1212         w100_pwr_state.sclk_cntl.f.sclk_force_reg = 0x0;    /* Dynamic */
1213         w100_pwr_state.sclk_cntl.f.sclk_force_disp = 0x0;   /* Dynamic */
1214         w100_pwr_state.sclk_cntl.f.sclk_force_mc = 0x0;     /* Dynamic */
1215         w100_pwr_state.sclk_cntl.f.sclk_force_extmc = 0x0;  /* Dynamic */
1216         w100_pwr_state.sclk_cntl.f.sclk_force_cp = 0x0;     /* Dynamic */
1217         w100_pwr_state.sclk_cntl.f.sclk_force_e2 = 0x0;     /* Dynamic */
1218         w100_pwr_state.sclk_cntl.f.sclk_force_e3 = 0x0;     /* Dynamic */
1219         w100_pwr_state.sclk_cntl.f.sclk_force_idct = 0x0;   /* Dynamic */
1220         w100_pwr_state.sclk_cntl.f.sclk_force_bist = 0x0;   /* Dynamic */
1221         w100_pwr_state.sclk_cntl.f.busy_extend_cp = 0x0;
1222         w100_pwr_state.sclk_cntl.f.busy_extend_e2 = 0x0;
1223         w100_pwr_state.sclk_cntl.f.busy_extend_e3 = 0x0;
1224         w100_pwr_state.sclk_cntl.f.busy_extend_idct = 0x0;
1225         writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
1226
1227         w100_pwr_state.pclk_cntl.f.pclk_src_sel = CLK_SRC_XTAL;
1228         w100_pwr_state.pclk_cntl.f.pclk_post_div = 0x1;    /* P = 2 */
1229         w100_pwr_state.pclk_cntl.f.pclk_force_disp = 0x0;  /* Dynamic */
1230         writel((u32) (w100_pwr_state.pclk_cntl.val), remapped_regs + mmPCLK_CNTL);
1231
1232         w100_pwr_state.pll_ref_fb_div.f.pll_ref_div = 0x0;     /* M = 1 */
1233         w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_int = 0x0;  /* N = 1.0 */
1234         w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_frac = 0x0;
1235         w100_pwr_state.pll_ref_fb_div.f.pll_reset_time = 0x5;
1236         w100_pwr_state.pll_ref_fb_div.f.pll_lock_time = 0xff;
1237         writel((u32) (w100_pwr_state.pll_ref_fb_div.val), remapped_regs + mmPLL_REF_FB_DIV);
1238
1239         w100_pwr_state.pll_cntl.f.pll_pwdn = 0x1;
1240         w100_pwr_state.pll_cntl.f.pll_reset = 0x1;
1241         w100_pwr_state.pll_cntl.f.pll_pm_en = 0x0;
1242         w100_pwr_state.pll_cntl.f.pll_mode = 0x0;  /* uses VCO clock */
1243         w100_pwr_state.pll_cntl.f.pll_refclk_sel = 0x0;
1244         w100_pwr_state.pll_cntl.f.pll_fbclk_sel = 0x0;
1245         w100_pwr_state.pll_cntl.f.pll_tcpoff = 0x0;
1246         w100_pwr_state.pll_cntl.f.pll_pcp = 0x4;
1247         w100_pwr_state.pll_cntl.f.pll_pvg = 0x0;
1248         w100_pwr_state.pll_cntl.f.pll_vcofr = 0x0;
1249         w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;
1250         w100_pwr_state.pll_cntl.f.pll_pecc_mode = 0x0;
1251         w100_pwr_state.pll_cntl.f.pll_pecc_scon = 0x0;
1252         w100_pwr_state.pll_cntl.f.pll_dactal = 0x0;  /* Hi-Z */
1253         w100_pwr_state.pll_cntl.f.pll_cp_clip = 0x3;
1254         w100_pwr_state.pll_cntl.f.pll_conf = 0x2;
1255         w100_pwr_state.pll_cntl.f.pll_mbctrl = 0x2;
1256         w100_pwr_state.pll_cntl.f.pll_ring_off = 0x0;
1257         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
1258
1259         w100_pwr_state.pwrmgt_cntl.f.pwm_enable = 0x0;
1260         w100_pwr_state.pwrmgt_cntl.f.pwm_mode_req = 0x1;  /* normal mode (0, 1, 3) */
1261         w100_pwr_state.pwrmgt_cntl.f.pwm_wakeup_cond = 0x0;
1262         w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_hw_en = 0x0;
1263         w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_hw_en = 0x0;
1264         w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_cond = 0x1;  /* PM4,ENG */
1265         w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_cond = 0x1;  /* PM4,ENG */
1266         w100_pwr_state.pwrmgt_cntl.f.pwm_idle_timer = 0xFF;
1267         w100_pwr_state.pwrmgt_cntl.f.pwm_busy_timer = 0xFF;
1268         writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
1269
1270         w100_pwr_state.auto_mode = 0;  /* manual mode */
1271 }
1272
1273
1274 /*
1275  * Setup the w100 clocks for the specified mode
1276  */
1277 static void w100_init_clocks(struct w100fb_par *par)
1278 {
1279         struct w100_mode *mode = par->mode;
1280
1281         if (mode->pixclk_src == CLK_SRC_PLL || mode->sysclk_src == CLK_SRC_PLL)
1282                 w100_set_pll_freq(par, (par->fastpll_mode && mode->fast_pll_freq) ? mode->fast_pll_freq : mode->pll_freq);
1283
1284         w100_pwr_state.sclk_cntl.f.sclk_src_sel = mode->sysclk_src;
1285         w100_pwr_state.sclk_cntl.f.sclk_post_div_fast = mode->sysclk_divider;
1286         w100_pwr_state.sclk_cntl.f.sclk_post_div_slow = mode->sysclk_divider;
1287         writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
1288 }
1289
1290 static void w100_init_lcd(struct w100fb_par *par)
1291 {
1292         u32 temp32;
1293         struct w100_mode *mode = par->mode;
1294         struct w100_gen_regs *regs = par->mach->regs;
1295         union active_h_disp_u active_h_disp;
1296         union active_v_disp_u active_v_disp;
1297         union graphic_h_disp_u graphic_h_disp;
1298         union graphic_v_disp_u graphic_v_disp;
1299         union crtc_total_u crtc_total;
1300
1301         /* w3200 doesnt like undefined bits being set so zero register values first */
1302
1303         active_h_disp.val = 0;
1304         active_h_disp.f.active_h_start=mode->left_margin;
1305         active_h_disp.f.active_h_end=mode->left_margin + mode->xres;
1306         writel(active_h_disp.val, remapped_regs + mmACTIVE_H_DISP);
1307
1308         active_v_disp.val = 0;
1309         active_v_disp.f.active_v_start=mode->upper_margin;
1310         active_v_disp.f.active_v_end=mode->upper_margin + mode->yres;
1311         writel(active_v_disp.val, remapped_regs + mmACTIVE_V_DISP);
1312
1313         graphic_h_disp.val = 0;
1314         graphic_h_disp.f.graphic_h_start=mode->left_margin;
1315         graphic_h_disp.f.graphic_h_end=mode->left_margin + mode->xres;
1316         writel(graphic_h_disp.val, remapped_regs + mmGRAPHIC_H_DISP);
1317
1318         graphic_v_disp.val = 0;
1319         graphic_v_disp.f.graphic_v_start=mode->upper_margin;
1320         graphic_v_disp.f.graphic_v_end=mode->upper_margin + mode->yres;
1321         writel(graphic_v_disp.val, remapped_regs + mmGRAPHIC_V_DISP);
1322
1323         crtc_total.val = 0;
1324         crtc_total.f.crtc_h_total=mode->left_margin  + mode->xres + mode->right_margin;
1325         crtc_total.f.crtc_v_total=mode->upper_margin + mode->yres + mode->lower_margin;
1326         writel(crtc_total.val, remapped_regs + mmCRTC_TOTAL);
1327
1328         writel(mode->crtc_ss, remapped_regs + mmCRTC_SS);
1329         writel(mode->crtc_ls, remapped_regs + mmCRTC_LS);
1330         writel(mode->crtc_gs, remapped_regs + mmCRTC_GS);
1331         writel(mode->crtc_vpos_gs, remapped_regs + mmCRTC_VPOS_GS);
1332         writel(mode->crtc_rev, remapped_regs + mmCRTC_REV);
1333         writel(mode->crtc_dclk, remapped_regs + mmCRTC_DCLK);
1334         writel(mode->crtc_gclk, remapped_regs + mmCRTC_GCLK);
1335         writel(mode->crtc_goe, remapped_regs + mmCRTC_GOE);
1336         writel(mode->crtc_ps1_active, remapped_regs + mmCRTC_PS1_ACTIVE);
1337
1338         writel(regs->lcd_format, remapped_regs + mmLCD_FORMAT);
1339         writel(regs->lcdd_cntl1, remapped_regs + mmLCDD_CNTL1);
1340         writel(regs->lcdd_cntl2, remapped_regs + mmLCDD_CNTL2);
1341         writel(regs->genlcd_cntl1, remapped_regs + mmGENLCD_CNTL1);
1342         writel(regs->genlcd_cntl2, remapped_regs + mmGENLCD_CNTL2);
1343         writel(regs->genlcd_cntl3, remapped_regs + mmGENLCD_CNTL3);
1344
1345         writel(0x00000000, remapped_regs + mmCRTC_FRAME);
1346         writel(0x00000000, remapped_regs + mmCRTC_FRAME_VPOS);
1347         writel(0x00000000, remapped_regs + mmCRTC_DEFAULT_COUNT);
1348         writel(0x0000FF00, remapped_regs + mmLCD_BACKGROUND_COLOR);
1349
1350         /* Hack for overlay in ext memory */
1351         temp32 = readl(remapped_regs + mmDISP_DEBUG2);
1352         temp32 |= 0xc0000000;
1353         writel(temp32, remapped_regs + mmDISP_DEBUG2);
1354 }
1355
1356
1357 static void w100_setup_memory(struct w100fb_par *par)
1358 {
1359         union mc_ext_mem_location_u extmem_location;
1360         union mc_fb_location_u intmem_location;
1361         struct w100_mem_info *mem = par->mach->mem;
1362         struct w100_bm_mem_info *bm_mem = par->mach->bm_mem;
1363
1364         if (!par->extmem_active) {
1365                 w100_suspend(W100_SUSPEND_EXTMEM);
1366
1367                 /* Map Internal Memory at FB Base */
1368                 intmem_location.f.mc_fb_start = W100_FB_BASE >> 8;
1369                 intmem_location.f.mc_fb_top = (W100_FB_BASE+MEM_INT_SIZE) >> 8;
1370                 writel((u32) (intmem_location.val), remapped_regs + mmMC_FB_LOCATION);
1371
1372                 /* Unmap External Memory - value is *probably* irrelevant but may have meaning
1373                    to acceleration libraries */
1374                 extmem_location.f.mc_ext_mem_start = MEM_EXT_BASE_VALUE >> 8;
1375                 extmem_location.f.mc_ext_mem_top = (MEM_EXT_BASE_VALUE-1) >> 8;
1376                 writel((u32) (extmem_location.val), remapped_regs + mmMC_EXT_MEM_LOCATION);
1377         } else {
1378                 /* Map Internal Memory to its default location */
1379                 intmem_location.f.mc_fb_start = MEM_INT_BASE_VALUE >> 8;
1380                 intmem_location.f.mc_fb_top = (MEM_INT_BASE_VALUE+MEM_INT_SIZE) >> 8;
1381                 writel((u32) (intmem_location.val), remapped_regs + mmMC_FB_LOCATION);
1382
1383                 /* Map External Memory at FB Base */
1384                 extmem_location.f.mc_ext_mem_start = W100_FB_BASE >> 8;
1385                 extmem_location.f.mc_ext_mem_top = (W100_FB_BASE+par->mach->mem->size) >> 8;
1386                 writel((u32) (extmem_location.val), remapped_regs + mmMC_EXT_MEM_LOCATION);
1387
1388                 writel(0x00007800, remapped_regs + mmMC_BIST_CTRL);
1389                 writel(mem->ext_cntl, remapped_regs + mmMEM_EXT_CNTL);
1390                 writel(0x00200021, remapped_regs + mmMEM_SDRAM_MODE_REG);
1391                 udelay(100);
1392                 writel(0x80200021, remapped_regs + mmMEM_SDRAM_MODE_REG);
1393                 udelay(100);
1394                 writel(mem->sdram_mode_reg, remapped_regs + mmMEM_SDRAM_MODE_REG);
1395                 udelay(100);
1396                 writel(mem->ext_timing_cntl, remapped_regs + mmMEM_EXT_TIMING_CNTL);
1397                 writel(mem->io_cntl, remapped_regs + mmMEM_IO_CNTL);
1398                 if (bm_mem) {
1399                         writel(bm_mem->ext_mem_bw, remapped_regs + mmBM_EXT_MEM_BANDWIDTH);
1400                         writel(bm_mem->offset, remapped_regs + mmBM_OFFSET);
1401                         writel(bm_mem->ext_timing_ctl, remapped_regs + mmBM_MEM_EXT_TIMING_CNTL);
1402                         writel(bm_mem->ext_cntl, remapped_regs + mmBM_MEM_EXT_CNTL);
1403                         writel(bm_mem->mode_reg, remapped_regs + mmBM_MEM_MODE_REG);
1404                         writel(bm_mem->io_cntl, remapped_regs + mmBM_MEM_IO_CNTL);
1405                         writel(bm_mem->config, remapped_regs + mmBM_CONFIG);
1406                 }
1407         }
1408 }
1409
1410 static void w100_set_dispregs(struct w100fb_par *par)
1411 {
1412         unsigned long rot=0, divider, offset=0;
1413         union graphic_ctrl_u graphic_ctrl;
1414
1415         /* See if the mode has been rotated */
1416         if (par->xres == par->mode->xres) {
1417                 if (par->flip) {
1418                         rot=3; /* 180 degree */
1419                         offset=(par->xres * par->yres) - 1;
1420                 } /* else 0 degree */
1421                 divider = par->mode->pixclk_divider;
1422         } else {
1423                 if (par->flip) {
1424                         rot=2; /* 270 degree */
1425                         offset=par->xres - 1;
1426                 } else {
1427                         rot=1; /* 90 degree */
1428                         offset=par->xres * (par->yres - 1);
1429                 }
1430                 divider = par->mode->pixclk_divider_rotated;
1431         }
1432
1433         graphic_ctrl.val = 0; /* w32xx doesn't like undefined bits */
1434         switch (par->chip_id) {
1435                 case CHIP_ID_W100:
1436                         graphic_ctrl.f_w100.color_depth=6;
1437                         graphic_ctrl.f_w100.en_crtc=1;
1438                         graphic_ctrl.f_w100.en_graphic_req=1;
1439                         graphic_ctrl.f_w100.en_graphic_crtc=1;
1440                         graphic_ctrl.f_w100.lcd_pclk_on=1;
1441                         graphic_ctrl.f_w100.lcd_sclk_on=1;
1442                         graphic_ctrl.f_w100.low_power_on=0;
1443                         graphic_ctrl.f_w100.req_freq=0;
1444                         graphic_ctrl.f_w100.portrait_mode=rot;
1445
1446                         /* Zaurus needs this */
1447                         switch(par->xres) {
1448                                 case 240:
1449                                 case 320:
1450                                 default:
1451                                         graphic_ctrl.f_w100.total_req_graphic=0xa0;
1452                                         break;
1453                                 case 480:
1454                                 case 640:
1455                                         switch(rot) {
1456                                                 case 0:  /* 0 */
1457                                                 case 3:  /* 180 */
1458                                                         graphic_ctrl.f_w100.low_power_on=1;
1459                                                         graphic_ctrl.f_w100.req_freq=5;
1460                                                 break;
1461                                                 case 1:  /* 90 */
1462                                                 case 2:  /* 270 */
1463                                                         graphic_ctrl.f_w100.req_freq=4;
1464                                                         break;
1465                                                 default:
1466                                                         break;
1467                                         }
1468                                         graphic_ctrl.f_w100.total_req_graphic=0xf0;
1469                                         break;
1470                         }
1471                         break;
1472                 case CHIP_ID_W3200:
1473                 case CHIP_ID_W3220:
1474                         graphic_ctrl.f_w32xx.color_depth=6;
1475                         graphic_ctrl.f_w32xx.en_crtc=1;
1476                         graphic_ctrl.f_w32xx.en_graphic_req=1;
1477                         graphic_ctrl.f_w32xx.en_graphic_crtc=1;
1478                         graphic_ctrl.f_w32xx.lcd_pclk_on=1;
1479                         graphic_ctrl.f_w32xx.lcd_sclk_on=1;
1480                         graphic_ctrl.f_w32xx.low_power_on=0;
1481                         graphic_ctrl.f_w32xx.req_freq=0;
1482                         graphic_ctrl.f_w32xx.total_req_graphic=par->mode->xres >> 1; /* panel xres, not mode */
1483                         graphic_ctrl.f_w32xx.portrait_mode=rot;
1484                         break;
1485         }
1486
1487         /* Set the pixel clock source and divider */
1488         w100_pwr_state.pclk_cntl.f.pclk_src_sel = par->mode->pixclk_src;
1489         w100_pwr_state.pclk_cntl.f.pclk_post_div = divider;
1490         writel((u32) (w100_pwr_state.pclk_cntl.val), remapped_regs + mmPCLK_CNTL);
1491
1492         writel(graphic_ctrl.val, remapped_regs + mmGRAPHIC_CTRL);
1493         writel(W100_FB_BASE + ((offset * BITS_PER_PIXEL/8)&~0x03UL), remapped_regs + mmGRAPHIC_OFFSET);
1494         writel((par->xres*BITS_PER_PIXEL/8), remapped_regs + mmGRAPHIC_PITCH);
1495 }
1496
1497
1498 /*
1499  * Work out how long the sync pulse lasts
1500  * Value is 1/(time in seconds)
1501  */
1502 static void calc_hsync(struct w100fb_par *par)
1503 {
1504         unsigned long hsync;
1505         struct w100_mode *mode = par->mode;
1506         union crtc_ss_u crtc_ss;
1507
1508         if (mode->pixclk_src == CLK_SRC_XTAL)
1509                 hsync=par->mach->xtal_freq;
1510         else
1511                 hsync=((par->fastpll_mode && mode->fast_pll_freq) ? mode->fast_pll_freq : mode->pll_freq)*100000;
1512
1513         hsync /= (w100_pwr_state.pclk_cntl.f.pclk_post_div + 1);
1514
1515         crtc_ss.val = readl(remapped_regs + mmCRTC_SS);
1516         if (crtc_ss.val)
1517                 par->hsync_len = hsync / (crtc_ss.f.ss_end-crtc_ss.f.ss_start);
1518         else
1519                 par->hsync_len = 0;
1520 }
1521
1522 static void w100_suspend(u32 mode)
1523 {
1524         u32 val;
1525
1526         writel(0x7FFF8000, remapped_regs + mmMC_EXT_MEM_LOCATION);
1527         writel(0x00FF0000, remapped_regs + mmMC_PERF_MON_CNTL);
1528
1529         val = readl(remapped_regs + mmMEM_EXT_TIMING_CNTL);
1530         val &= ~(0x00100000);  /* bit20=0 */
1531         val |= 0xFF000000;     /* bit31:24=0xff */
1532         writel(val, remapped_regs + mmMEM_EXT_TIMING_CNTL);
1533
1534         val = readl(remapped_regs + mmMEM_EXT_CNTL);
1535         val &= ~(0x00040000);  /* bit18=0 */
1536         val |= 0x00080000;     /* bit19=1 */
1537         writel(val, remapped_regs + mmMEM_EXT_CNTL);
1538
1539         udelay(1);  /* wait 1us */
1540
1541         if (mode == W100_SUSPEND_EXTMEM) {
1542                 /* CKE: Tri-State */
1543                 val = readl(remapped_regs + mmMEM_EXT_CNTL);
1544                 val |= 0x40000000;  /* bit30=1 */
1545                 writel(val, remapped_regs + mmMEM_EXT_CNTL);
1546
1547                 /* CLK: Stop */
1548                 val = readl(remapped_regs + mmMEM_EXT_CNTL);
1549                 val &= ~(0x00000001);  /* bit0=0 */
1550                 writel(val, remapped_regs + mmMEM_EXT_CNTL);
1551         } else {
1552                 writel(0x00000000, remapped_regs + mmSCLK_CNTL);
1553                 writel(0x000000BF, remapped_regs + mmCLK_PIN_CNTL);
1554                 writel(0x00000015, remapped_regs + mmPWRMGT_CNTL);
1555
1556                 udelay(5);
1557
1558                 val = readl(remapped_regs + mmPLL_CNTL);
1559                 val |= 0x00000004;  /* bit2=1 */
1560                 writel(val, remapped_regs + mmPLL_CNTL);
1561                 writel(0x0000001d, remapped_regs + mmPWRMGT_CNTL);
1562         }
1563 }
1564
1565 static void w100_vsync(void)
1566 {
1567         u32 tmp;
1568         int timeout = 30000;  /* VSync timeout = 30[ms] > 16.8[ms] */
1569
1570         tmp = readl(remapped_regs + mmACTIVE_V_DISP);
1571
1572         /* set vline pos  */
1573         writel((tmp >> 16) & 0x3ff, remapped_regs + mmDISP_INT_CNTL);
1574
1575         /* disable vline irq */
1576         tmp = readl(remapped_regs + mmGEN_INT_CNTL);
1577
1578         tmp &= ~0x00000002;
1579         writel(tmp, remapped_regs + mmGEN_INT_CNTL);
1580
1581         /* clear vline irq status */
1582         writel(0x00000002, remapped_regs + mmGEN_INT_STATUS);
1583
1584         /* enable vline irq */
1585         writel((tmp | 0x00000002), remapped_regs + mmGEN_INT_CNTL);
1586
1587         /* clear vline irq status */
1588         writel(0x00000002, remapped_regs + mmGEN_INT_STATUS);
1589
1590         while(timeout > 0) {
1591                 if (readl(remapped_regs + mmGEN_INT_STATUS) & 0x00000002)
1592                         break;
1593                 udelay(1);
1594                 timeout--;
1595         }
1596
1597         /* disable vline irq */
1598         writel(tmp, remapped_regs + mmGEN_INT_CNTL);
1599
1600         /* clear vline irq status */
1601         writel(0x00000002, remapped_regs + mmGEN_INT_STATUS);
1602 }
1603
1604 static struct platform_driver w100fb_driver = {
1605         .probe          = w100fb_probe,
1606         .remove         = w100fb_remove,
1607         .suspend        = w100fb_suspend,
1608         .resume         = w100fb_resume,
1609         .driver         = {
1610                 .name   = "w100fb",
1611         },
1612 };
1613
1614 int __devinit w100fb_init(void)
1615 {
1616         return platform_driver_register(&w100fb_driver);
1617 }
1618
1619 void __exit w100fb_cleanup(void)
1620 {
1621         platform_driver_unregister(&w100fb_driver);
1622 }
1623
1624 module_init(w100fb_init);
1625 module_exit(w100fb_cleanup);
1626
1627 MODULE_DESCRIPTION("ATI Imageon w100 framebuffer driver");
1628 MODULE_LICENSE("GPL");