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