drivers/video/fbdev/sm712fb.c

   1 /*
   2  * Silicon Motion SM7XX frame buffer device
   3  *
   4  * Copyright (C) 2006 Silicon Motion Technology Corp.
   5  * Authors:  Ge Wang, gewang@siliconmotion.com
   6  *           Boyod boyod.yang@siliconmotion.com.cn
   7  *
   8  * Copyright (C) 2009 Lemote, Inc.
   9  * Author:   Wu Zhangjin, wuzhangjin@gmail.com
  10  *
  11  * Copyright (C) 2011 Igalia, S.L.
  12  * Author:   Javier M. Mellid <jmunhoz@igalia.com>
  13  *
  14  * This file is subject to the terms and conditions of the GNU General Public
  15  * License. See the file COPYING in the main directory of this archive for
  16  * more details.
  17  *
  18  * Framebuffer driver for Silicon Motion SM710, SM712, SM721 and SM722 chips
  19  */
  20
  21 #include <linux/io.h>
  22 #include <linux/fb.h>
  23 #include <linux/pci.h>
  24 #include <linux/init.h>
  25 #include <linux/slab.h>
  26 #include <linux/uaccess.h>
  27 #include <linux/module.h>
  28 #include <linux/console.h>
  29 #include <linux/screen_info.h>
  30
  31 #ifdef CONFIG_PM
  32 #include <linux/pm.h>
  33 #endif
  34
  35 #include "sm712.h"
  36
  37 /*
  38 * Private structure
  39 */
  40 struct smtcfb_info {
  41         struct pci_dev *pdev;
  42         struct fb_info *fb;
  43         u16 chip_id;
  44         u8  chip_rev_id;
  45
  46         void __iomem *lfb;      /* linear frame buffer */
  47         void __iomem *dp_regs;  /* drawing processor control regs */
  48         void __iomem *vp_regs;  /* video processor control regs */
  49         void __iomem *cp_regs;  /* capture processor control regs */
  50         void __iomem *mmio;     /* memory map IO port */
  51
  52         u_int width;
  53         u_int height;
  54         u_int hz;
  55
  56         u32 colreg[17];
  57 };
  58
  59 void __iomem *smtc_regbaseaddress;      /* Memory Map IO starting address */
  60
  61 static struct fb_var_screeninfo smtcfb_var = {
  62         .xres           = 1024,
  63         .yres           = 600,
  64         .xres_virtual   = 1024,
  65         .yres_virtual   = 600,
  66         .bits_per_pixel = 16,
  67         .red            = {16, 8, 0},
  68         .green          = {8, 8, 0},
  69         .blue           = {0, 8, 0},
  70         .activate       = FB_ACTIVATE_NOW,
  71         .height         = -1,
  72         .width          = -1,
  73         .vmode          = FB_VMODE_NONINTERLACED,
  74         .nonstd         = 0,
  75         .accel_flags    = FB_ACCELF_TEXT,
  76 };
  77
  78 static struct fb_fix_screeninfo smtcfb_fix = {
  79         .id             = "smXXXfb",
  80         .type           = FB_TYPE_PACKED_PIXELS,
  81         .visual         = FB_VISUAL_TRUECOLOR,
  82         .line_length    = 800 * 3,
  83         .accel          = FB_ACCEL_SMI_LYNX,
  84         .type_aux       = 0,
  85         .xpanstep       = 0,
  86         .ypanstep       = 0,
  87         .ywrapstep      = 0,
  88 };
  89
  90 struct vesa_mode {
  91         char index[6];
  92         u16  lfb_width;
  93         u16  lfb_height;
  94         u16  lfb_depth;
  95 };
  96
  97 static const struct vesa_mode vesa_mode_table[] = {
  98         {"0x301", 640,  480,  8},
  99         {"0x303", 800,  600,  8},
 100         {"0x305", 1024, 768,  8},
 101         {"0x307", 1280, 1024, 8},
 102
 103         {"0x311", 640,  480,  16},
 104         {"0x314", 800,  600,  16},
 105         {"0x317", 1024, 768,  16},
 106         {"0x31A", 1280, 1024, 16},
 107
 108         {"0x312", 640,  480,  24},
 109         {"0x315", 800,  600,  24},
 110         {"0x318", 1024, 768,  24},
 111         {"0x31B", 1280, 1024, 24},
 112 };
 113
 114 /**********************************************************************
 115                          SM712 Mode table.
 116  **********************************************************************/
 117 static const struct modeinit vgamode[] = {
 118         {
 119                 /*  mode#0: 640 x 480  16Bpp  60Hz */
 120                 640, 480, 16, 60,
 121                 /*  Init_MISC */
 122                 0xE3,
 123                 {       /*  Init_SR0_SR4 */
 124                         0x03, 0x01, 0x0F, 0x00, 0x0E,
 125                 },
 126                 {       /*  Init_SR10_SR24 */
 127                         0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
 128                         0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 129                         0xC4, 0x30, 0x02, 0x01, 0x01,
 130                 },
 131                 {       /*  Init_SR30_SR75 */
 132                         0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
 133                         0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
 134                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 135                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
 136                         0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
 137                         0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
 138                         0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 139                         0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
 140                         0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
 141                 },
 142                 {       /*  Init_SR80_SR93 */
 143                         0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
 144                         0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
 145                         0x00, 0x00, 0x00, 0x00,
 146                 },
 147                 {       /*  Init_SRA0_SRAF */
 148                         0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
 149                         0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
 150                 },
 151                 {       /*  Init_GR00_GR08 */
 152                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 153                         0xFF,
 154                 },
 155                 {       /*  Init_AR00_AR14 */
 156                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 157                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 158                         0x41, 0x00, 0x0F, 0x00, 0x00,
 159                 },
 160                 {       /*  Init_CR00_CR18 */
 161                         0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
 162                         0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 163                         0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
 164                         0xFF,
 165                 },
 166                 {       /*  Init_CR30_CR4D */
 167                         0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
 168                         0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
 169                         0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
 170                         0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
 171                 },
 172                 {       /*  Init_CR90_CRA7 */
 173                         0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
 174                         0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
 175                         0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
 176                 },
 177         },
 178         {
 179                 /*  mode#1: 640 x 480  24Bpp  60Hz */
 180                 640, 480, 24, 60,
 181                 /*  Init_MISC */
 182                 0xE3,
 183                 {       /*  Init_SR0_SR4 */
 184                         0x03, 0x01, 0x0F, 0x00, 0x0E,
 185                 },
 186                 {       /*  Init_SR10_SR24 */
 187                         0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
 188                         0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 189                         0xC4, 0x30, 0x02, 0x01, 0x01,
 190                 },
 191                 {       /*  Init_SR30_SR75 */
 192                         0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
 193                         0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
 194                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 195                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
 196                         0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
 197                         0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
 198                         0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 199                         0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
 200                         0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
 201                 },
 202                 {       /*  Init_SR80_SR93 */
 203                         0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
 204                         0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
 205                         0x00, 0x00, 0x00, 0x00,
 206                 },
 207                 {       /*  Init_SRA0_SRAF */
 208                         0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
 209                         0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
 210                 },
 211                 {       /*  Init_GR00_GR08 */
 212                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 213                         0xFF,
 214                 },
 215                 {       /*  Init_AR00_AR14 */
 216                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 217                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 218                         0x41, 0x00, 0x0F, 0x00, 0x00,
 219                 },
 220                 {       /*  Init_CR00_CR18 */
 221                         0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
 222                         0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 223                         0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
 224                         0xFF,
 225                 },
 226                 {       /*  Init_CR30_CR4D */
 227                         0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
 228                         0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
 229                         0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
 230                         0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
 231                 },
 232                 {       /*  Init_CR90_CRA7 */
 233                         0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
 234                         0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
 235                         0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
 236                 },
 237         },
 238         {
 239                 /*  mode#0: 640 x 480  32Bpp  60Hz */
 240                 640, 480, 32, 60,
 241                 /*  Init_MISC */
 242                 0xE3,
 243                 {       /*  Init_SR0_SR4 */
 244                         0x03, 0x01, 0x0F, 0x00, 0x0E,
 245                 },
 246                 {       /*  Init_SR10_SR24 */
 247                         0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
 248                         0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 249                         0xC4, 0x30, 0x02, 0x01, 0x01,
 250                 },
 251                 {       /*  Init_SR30_SR75 */
 252                         0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
 253                         0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
 254                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 255                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
 256                         0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
 257                         0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
 258                         0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 259                         0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
 260                         0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
 261                 },
 262                 {       /*  Init_SR80_SR93 */
 263                         0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
 264                         0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
 265                         0x00, 0x00, 0x00, 0x00,
 266                 },
 267                 {       /*  Init_SRA0_SRAF */
 268                         0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
 269                         0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
 270                 },
 271                 {       /*  Init_GR00_GR08 */
 272                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 273                         0xFF,
 274                 },
 275                 {       /*  Init_AR00_AR14 */
 276                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 277                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 278                         0x41, 0x00, 0x0F, 0x00, 0x00,
 279                 },
 280                 {       /*  Init_CR00_CR18 */
 281                         0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
 282                         0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 283                         0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
 284                         0xFF,
 285                 },
 286                 {       /*  Init_CR30_CR4D */
 287                         0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
 288                         0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
 289                         0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
 290                         0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
 291                 },
 292                 {       /*  Init_CR90_CRA7 */
 293                         0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
 294                         0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
 295                         0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
 296                 },
 297         },
 298
 299         {       /*  mode#2: 800 x 600  16Bpp  60Hz */
 300                 800, 600, 16, 60,
 301                 /*  Init_MISC */
 302                 0x2B,
 303                 {       /*  Init_SR0_SR4 */
 304                         0x03, 0x01, 0x0F, 0x03, 0x0E,
 305                 },
 306                 {       /*  Init_SR10_SR24 */
 307                         0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
 308                         0x99, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 309                         0xC4, 0x30, 0x02, 0x01, 0x01,
 310                 },
 311                 {       /*  Init_SR30_SR75 */
 312                         0x34, 0x03, 0x20, 0x09, 0xC0, 0x24, 0x24, 0x24,
 313                         0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x03, 0xFF,
 314                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x38, 0x00, 0xFC,
 315                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x24, 0x24, 0x24,
 316                         0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
 317                         0x04, 0x55, 0x59, 0x24, 0x24, 0x00, 0x00, 0x24,
 318                         0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 319                         0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
 320                         0x02, 0x45, 0x30, 0x35, 0x40, 0x20,
 321                 },
 322                 {       /*  Init_SR80_SR93 */
 323                         0x00, 0x00, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x24,
 324                         0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x24, 0x24,
 325                         0x00, 0x00, 0x00, 0x00,
 326                 },
 327                 {       /*  Init_SRA0_SRAF */
 328                         0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
 329                         0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
 330                 },
 331                 {       /*  Init_GR00_GR08 */
 332                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 333                         0xFF,
 334                 },
 335                 {       /*  Init_AR00_AR14 */
 336                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 337                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 338                         0x41, 0x00, 0x0F, 0x00, 0x00,
 339                 },
 340                 {       /*  Init_CR00_CR18 */
 341                         0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
 342                         0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 343                         0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
 344                         0xFF,
 345                 },
 346                 {       /*  Init_CR30_CR4D */
 347                         0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
 348                         0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
 349                         0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
 350                         0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
 351                 },
 352                 {       /*  Init_CR90_CRA7 */
 353                         0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
 354                         0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
 355                         0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
 356                 },
 357         },
 358         {       /*  mode#3: 800 x 600  24Bpp  60Hz */
 359                 800, 600, 24, 60,
 360                 0x2B,
 361                 {       /*  Init_SR0_SR4 */
 362                         0x03, 0x01, 0x0F, 0x03, 0x0E,
 363                 },
 364                 {       /*  Init_SR10_SR24 */
 365                         0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
 366                         0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 367                         0xC4, 0x30, 0x02, 0x01, 0x01,
 368                 },
 369                 {       /*  Init_SR30_SR75 */
 370                         0x36, 0x03, 0x20, 0x09, 0xC0, 0x36, 0x36, 0x36,
 371                         0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x03, 0xFF,
 372                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 373                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x36, 0x36, 0x36,
 374                         0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
 375                         0x04, 0x55, 0x59, 0x36, 0x36, 0x00, 0x00, 0x36,
 376                         0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 377                         0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
 378                         0x02, 0x45, 0x30, 0x30, 0x40, 0x20,
 379                 },
 380                 {       /*  Init_SR80_SR93 */
 381                         0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x36,
 382                         0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x36, 0x36,
 383                         0x00, 0x00, 0x00, 0x00,
 384                 },
 385                 {       /*  Init_SRA0_SRAF */
 386                         0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
 387                         0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
 388                 },
 389                 {       /*  Init_GR00_GR08 */
 390                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 391                         0xFF,
 392                 },
 393                 {       /*  Init_AR00_AR14 */
 394                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 395                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 396                         0x41, 0x00, 0x0F, 0x00, 0x00,
 397                 },
 398                 {       /*  Init_CR00_CR18 */
 399                         0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
 400                         0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 401                         0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
 402                         0xFF,
 403                 },
 404                 {       /*  Init_CR30_CR4D */
 405                         0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
 406                         0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
 407                         0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
 408                         0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
 409                 },
 410                 {       /*  Init_CR90_CRA7 */
 411                         0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
 412                         0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
 413                         0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
 414                 },
 415         },
 416         {       /*  mode#7: 800 x 600  32Bpp  60Hz */
 417                 800, 600, 32, 60,
 418                 /*  Init_MISC */
 419                 0x2B,
 420                 {       /*  Init_SR0_SR4 */
 421                         0x03, 0x01, 0x0F, 0x03, 0x0E,
 422                 },
 423                 {       /*  Init_SR10_SR24 */
 424                         0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
 425                         0x99, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 426                         0xC4, 0x30, 0x02, 0x01, 0x01,
 427                 },
 428                 {       /*  Init_SR30_SR75 */
 429                         0x34, 0x03, 0x20, 0x09, 0xC0, 0x24, 0x24, 0x24,
 430                         0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x03, 0xFF,
 431                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x38, 0x00, 0xFC,
 432                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x24, 0x24, 0x24,
 433                         0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
 434                         0x04, 0x55, 0x59, 0x24, 0x24, 0x00, 0x00, 0x24,
 435                         0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 436                         0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
 437                         0x02, 0x45, 0x30, 0x35, 0x40, 0x20,
 438                 },
 439                 {       /*  Init_SR80_SR93 */
 440                         0x00, 0x00, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x24,
 441                         0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x24, 0x24,
 442                         0x00, 0x00, 0x00, 0x00,
 443                 },
 444                 {       /*  Init_SRA0_SRAF */
 445                         0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
 446                         0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
 447                 },
 448                 {       /*  Init_GR00_GR08 */
 449                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 450                         0xFF,
 451                 },
 452                 {       /*  Init_AR00_AR14 */
 453                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 454                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 455                         0x41, 0x00, 0x0F, 0x00, 0x00,
 456                 },
 457                 {       /*  Init_CR00_CR18 */
 458                         0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
 459                         0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 460                         0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
 461                         0xFF,
 462                 },
 463                 {       /*  Init_CR30_CR4D */
 464                         0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
 465                         0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
 466                         0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
 467                         0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
 468                 },
 469                 {       /*  Init_CR90_CRA7 */
 470                         0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
 471                         0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
 472                         0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
 473                 },
 474         },
 475         /* We use 1024x768 table to light 1024x600 panel for lemote */
 476         {       /*  mode#4: 1024 x 600  16Bpp  60Hz  */
 477                 1024, 600, 16, 60,
 478                 /*  Init_MISC */
 479                 0xEB,
 480                 {       /*  Init_SR0_SR4 */
 481                         0x03, 0x01, 0x0F, 0x00, 0x0E,
 482                 },
 483                 {       /*  Init_SR10_SR24 */
 484                         0xC8, 0x40, 0x14, 0x60, 0x00, 0x0A, 0x17, 0x20,
 485                         0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 486                         0xC4, 0x30, 0x02, 0x00, 0x01,
 487                 },
 488                 {       /*  Init_SR30_SR75 */
 489                         0x22, 0x03, 0x24, 0x09, 0xC0, 0x22, 0x22, 0x22,
 490                         0x22, 0x22, 0x22, 0x22, 0x00, 0x00, 0x03, 0xFF,
 491                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 492                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x22, 0x22, 0x22,
 493                         0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
 494                         0x00, 0x60, 0x59, 0x22, 0x22, 0x00, 0x00, 0x22,
 495                         0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 496                         0x50, 0x03, 0x16, 0x02, 0x0D, 0x82, 0x09, 0x02,
 497                         0x04, 0x45, 0x3F, 0x30, 0x40, 0x20,
 498                 },
 499                 {       /*  Init_SR80_SR93 */
 500                         0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
 501                         0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
 502                         0x00, 0x00, 0x00, 0x00,
 503                 },
 504                 {       /*  Init_SRA0_SRAF */
 505                         0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
 506                         0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
 507                 },
 508                 {       /*  Init_GR00_GR08 */
 509                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 510                         0xFF,
 511                 },
 512                 {       /*  Init_AR00_AR14 */
 513                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 514                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 515                         0x41, 0x00, 0x0F, 0x00, 0x00,
 516                 },
 517                 {       /*  Init_CR00_CR18 */
 518                         0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
 519                         0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 520                         0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
 521                         0xFF,
 522                 },
 523                 {       /*  Init_CR30_CR4D */
 524                         0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
 525                         0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
 526                         0xA3, 0x7F, 0x00, 0x82, 0x0b, 0x6f, 0x57, 0x00,
 527                         0x5c, 0x0f, 0xE0, 0xe0, 0x7F, 0x57,
 528                 },
 529                 {       /*  Init_CR90_CRA7 */
 530                         0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
 531                         0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
 532                         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
 533                 },
 534         },
 535         {       /*  mode#5: 1024 x 768  24Bpp  60Hz */
 536                 1024, 768, 24, 60,
 537                 /*  Init_MISC */
 538                 0xEB,
 539                 {       /*  Init_SR0_SR4 */
 540                         0x03, 0x01, 0x0F, 0x03, 0x0E,
 541                 },
 542                 {       /*  Init_SR10_SR24 */
 543                         0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
 544                         0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 545                         0xC4, 0x30, 0x02, 0x01, 0x01,
 546                 },
 547                 {       /*  Init_SR30_SR75 */
 548                         0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
 549                         0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
 550                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 551                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
 552                         0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
 553                         0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
 554                         0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 555                         0x50, 0x03, 0x74, 0x14, 0x3B, 0x0D, 0x09, 0x02,
 556                         0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
 557                 },
 558                 {       /*  Init_SR80_SR93 */
 559                         0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
 560                         0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
 561                         0x00, 0x00, 0x00, 0x00,
 562                 },
 563                 {       /*  Init_SRA0_SRAF */
 564                         0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
 565                         0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
 566                 },
 567                 {       /*  Init_GR00_GR08 */
 568                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 569                         0xFF,
 570                 },
 571                 {       /*  Init_AR00_AR14 */
 572                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 573                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 574                         0x41, 0x00, 0x0F, 0x00, 0x00,
 575                 },
 576                 {       /*  Init_CR00_CR18 */
 577                         0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
 578                         0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 579                         0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
 580                         0xFF,
 581                 },
 582                 {       /*  Init_CR30_CR4D */
 583                         0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
 584                         0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
 585                         0xA3, 0x7F, 0x00, 0x86, 0x15, 0x24, 0xFF, 0x00,
 586                         0x01, 0x07, 0xE5, 0x20, 0x7F, 0xFF,
 587                 },
 588                 {       /*  Init_CR90_CRA7 */
 589                         0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
 590                         0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
 591                         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
 592                 },
 593         },
 594         {       /*  mode#4: 1024 x 768  32Bpp  60Hz */
 595                 1024, 768, 32, 60,
 596                 /*  Init_MISC */
 597                 0xEB,
 598                 {       /*  Init_SR0_SR4 */
 599                         0x03, 0x01, 0x0F, 0x03, 0x0E,
 600                 },
 601                 {       /*  Init_SR10_SR24 */
 602                         0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
 603                         0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 604                         0xC4, 0x32, 0x02, 0x01, 0x01,
 605                 },
 606                 {       /*  Init_SR30_SR75 */
 607                         0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
 608                         0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
 609                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 610                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
 611                         0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
 612                         0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
 613                         0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 614                         0x50, 0x03, 0x74, 0x14, 0x3B, 0x0D, 0x09, 0x02,
 615                         0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
 616                 },
 617                 {       /*  Init_SR80_SR93 */
 618                         0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
 619                         0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
 620                         0x00, 0x00, 0x00, 0x00,
 621                 },
 622                 {       /*  Init_SRA0_SRAF */
 623                         0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
 624                         0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
 625                 },
 626                 {       /*  Init_GR00_GR08 */
 627                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 628                         0xFF,
 629                 },
 630                 {       /*  Init_AR00_AR14 */
 631                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 632                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 633                         0x41, 0x00, 0x0F, 0x00, 0x00,
 634                 },
 635                 {       /*  Init_CR00_CR18 */
 636                         0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
 637                         0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 638                         0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
 639                         0xFF,
 640                 },
 641                 {       /*  Init_CR30_CR4D */
 642                         0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
 643                         0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
 644                         0xA3, 0x7F, 0x00, 0x86, 0x15, 0x24, 0xFF, 0x00,
 645                         0x01, 0x07, 0xE5, 0x20, 0x7F, 0xFF,
 646                 },
 647                 {       /*  Init_CR90_CRA7 */
 648                         0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
 649                         0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
 650                         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
 651                 },
 652         },
 653         {       /*  mode#6: 320 x 240  16Bpp  60Hz */
 654                 320, 240, 16, 60,
 655                 /*  Init_MISC */
 656                 0xEB,
 657                 {       /*  Init_SR0_SR4 */
 658                         0x03, 0x01, 0x0F, 0x03, 0x0E,
 659                 },
 660                 {       /*  Init_SR10_SR24 */
 661                         0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
 662                         0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 663                         0xC4, 0x32, 0x02, 0x01, 0x01,
 664                 },
 665                 {       /*  Init_SR30_SR75 */
 666                         0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
 667                         0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
 668                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 669                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
 670                         0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
 671                         0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
 672                         0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 673                         0x50, 0x03, 0x74, 0x14, 0x08, 0x43, 0x08, 0x43,
 674                         0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
 675                 },
 676                 {       /*  Init_SR80_SR93 */
 677                         0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
 678                         0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
 679                         0x00, 0x00, 0x00, 0x00,
 680                 },
 681                 {       /*  Init_SRA0_SRAF */
 682                         0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
 683                         0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
 684                 },
 685                 {       /*  Init_GR00_GR08 */
 686                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 687                         0xFF,
 688                 },
 689                 {       /*  Init_AR00_AR14 */
 690                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 691                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 692                         0x41, 0x00, 0x0F, 0x00, 0x00,
 693                 },
 694                 {       /*  Init_CR00_CR18 */
 695                         0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
 696                         0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 697                         0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
 698                         0xFF,
 699                 },
 700                 {       /*  Init_CR30_CR4D */
 701                         0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
 702                         0x00, 0x00, 0x30, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
 703                         0x2E, 0x27, 0x00, 0x2b, 0x0c, 0x0F, 0xEF, 0x00,
 704                         0xFe, 0x0f, 0x01, 0xC0, 0x27, 0xEF,
 705                 },
 706                 {       /*  Init_CR90_CRA7 */
 707                         0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
 708                         0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
 709                         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
 710                 },
 711         },
 712
 713         {       /*  mode#8: 320 x 240  32Bpp  60Hz */
 714                 320, 240, 32, 60,
 715                 /*  Init_MISC */
 716                 0xEB,
 717                 {       /*  Init_SR0_SR4 */
 718                         0x03, 0x01, 0x0F, 0x03, 0x0E,
 719                 },
 720                 {       /*  Init_SR10_SR24 */
 721                         0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
 722                         0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 723                         0xC4, 0x32, 0x02, 0x01, 0x01,
 724                 },
 725                 {       /*  Init_SR30_SR75 */
 726                         0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
 727                         0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
 728                         0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
 729                         0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
 730                         0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
 731                         0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
 732                         0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
 733                         0x50, 0x03, 0x74, 0x14, 0x08, 0x43, 0x08, 0x43,
 734                         0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
 735                 },
 736                 {       /*  Init_SR80_SR93 */
 737                         0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
 738                         0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
 739                         0x00, 0x00, 0x00, 0x00,
 740                 },
 741                 {       /*  Init_SRA0_SRAF */
 742                         0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
 743                         0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
 744                 },
 745                 {       /*  Init_GR00_GR08 */
 746                         0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
 747                         0xFF,
 748                 },
 749                 {       /*  Init_AR00_AR14 */
 750                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 751                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 752                         0x41, 0x00, 0x0F, 0x00, 0x00,
 753                 },
 754                 {       /*  Init_CR00_CR18 */
 755                         0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
 756                         0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 757                         0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
 758                         0xFF,
 759                 },
 760                 {       /*  Init_CR30_CR4D */
 761                         0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
 762                         0x00, 0x00, 0x30, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
 763                         0x2E, 0x27, 0x00, 0x2b, 0x0c, 0x0F, 0xEF, 0x00,
 764                         0xFe, 0x0f, 0x01, 0xC0, 0x27, 0xEF,
 765                 },
 766                 {       /*  Init_CR90_CRA7 */
 767                         0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
 768                         0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
 769                         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
 770                 },
 771         },
 772 };
 773
 774 static struct screen_info smtc_scr_info;
 775
 776 static char *mode_option;
 777
 778 /* process command line options, get vga parameter */
 779 static void __init sm7xx_vga_setup(char *options)
 780 {
 781         int i;
 782
 783         if (!options || !*options)
 784                 return;
 785
 786         smtc_scr_info.lfb_width = 0;
 787         smtc_scr_info.lfb_height = 0;
 788         smtc_scr_info.lfb_depth = 0;
 789
 790         pr_debug("sm7xx_vga_setup = %s\n", options);
 791
 792         for (i = 0; i < ARRAY_SIZE(vesa_mode_table); i++) {
 793                 if (strstr(options, vesa_mode_table[i].index)) {
 794                         smtc_scr_info.lfb_width  = vesa_mode_table[i].lfb_width;
 795                         smtc_scr_info.lfb_height =
 796                                                 vesa_mode_table[i].lfb_height;
 797                         smtc_scr_info.lfb_depth  = vesa_mode_table[i].lfb_depth;
 798                         return;
 799                 }
 800         }
 801 }
 802
 803 static void sm712_setpalette(int regno, unsigned red, unsigned green,
 804                              unsigned blue, struct fb_info *info)
 805 {
 806         /* set bit 5:4 = 01 (write LCD RAM only) */
 807         smtc_seqw(0x66, (smtc_seqr(0x66) & 0xC3) | 0x10);
 808
 809         smtc_mmiowb(regno, dac_reg);
 810         smtc_mmiowb(red >> 10, dac_val);
 811         smtc_mmiowb(green >> 10, dac_val);
 812         smtc_mmiowb(blue >> 10, dac_val);
 813 }
 814
 815 /* chan_to_field
 816  *
 817  * convert a colour value into a field position
 818  *
 819  * from pxafb.c
 820  */
 821
 822 static inline unsigned int chan_to_field(unsigned int chan,
 823                                          struct fb_bitfield *bf)
 824 {
 825         chan &= 0xffff;
 826         chan >>= 16 - bf->length;
 827         return chan << bf->offset;
 828 }
 829
 830 static int smtc_blank(int blank_mode, struct fb_info *info)
 831 {
 832         /* clear DPMS setting */
 833         switch (blank_mode) {
 834         case FB_BLANK_UNBLANK:
 835                 /* Screen On: HSync: On, VSync : On */
 836                 smtc_seqw(0x01, (smtc_seqr(0x01) & (~0x20)));
 837                 smtc_seqw(0x6a, 0x16);
 838                 smtc_seqw(0x6b, 0x02);
 839                 smtc_seqw(0x21, (smtc_seqr(0x21) & 0x77));
 840                 smtc_seqw(0x22, (smtc_seqr(0x22) & (~0x30)));
 841                 smtc_seqw(0x23, (smtc_seqr(0x23) & (~0xc0)));
 842                 smtc_seqw(0x24, (smtc_seqr(0x24) | 0x01));
 843                 smtc_seqw(0x31, (smtc_seqr(0x31) | 0x03));
 844                 break;
 845         case FB_BLANK_NORMAL:
 846                 /* Screen Off: HSync: On, VSync : On   Soft blank */
 847                 smtc_seqw(0x01, (smtc_seqr(0x01) & (~0x20)));
 848                 smtc_seqw(0x6a, 0x16);
 849                 smtc_seqw(0x6b, 0x02);
 850                 smtc_seqw(0x22, (smtc_seqr(0x22) & (~0x30)));
 851                 smtc_seqw(0x23, (smtc_seqr(0x23) & (~0xc0)));
 852                 smtc_seqw(0x24, (smtc_seqr(0x24) | 0x01));
 853                 smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
 854                 break;
 855         case FB_BLANK_VSYNC_SUSPEND:
 856                 /* Screen On: HSync: On, VSync : Off */
 857                 smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
 858                 smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
 859                 smtc_seqw(0x6a, 0x0c);
 860                 smtc_seqw(0x6b, 0x02);
 861                 smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
 862                 smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x20));
 863                 smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0x20));
 864                 smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
 865                 smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
 866                 smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
 867                 break;
 868         case FB_BLANK_HSYNC_SUSPEND:
 869                 /* Screen On: HSync: Off, VSync : On */
 870                 smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
 871                 smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
 872                 smtc_seqw(0x6a, 0x0c);
 873                 smtc_seqw(0x6b, 0x02);
 874                 smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
 875                 smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x10));
 876                 smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0xD8));
 877                 smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
 878                 smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
 879                 smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
 880                 break;
 881         case FB_BLANK_POWERDOWN:
 882                 /* Screen On: HSync: Off, VSync : Off */
 883                 smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
 884                 smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
 885                 smtc_seqw(0x6a, 0x0c);
 886                 smtc_seqw(0x6b, 0x02);
 887                 smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
 888                 smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x30));
 889                 smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0xD8));
 890                 smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
 891                 smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
 892                 smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
 893                 break;
 894         default:
 895                 return -EINVAL;
 896         }
 897
 898         return 0;
 899 }
 900
 901 static int smtc_setcolreg(unsigned regno, unsigned red, unsigned green,
 902                           unsigned blue, unsigned trans, struct fb_info *info)
 903 {
 904         struct smtcfb_info *sfb;
 905         u32 val;
 906
 907         sfb = info->par;
 908
 909         if (regno > 255)
 910                 return 1;
 911
 912         switch (sfb->fb->fix.visual) {
 913         case FB_VISUAL_DIRECTCOLOR:
 914         case FB_VISUAL_TRUECOLOR:
 915                 /*
 916                  * 16/32 bit true-colour, use pseudo-palette for 16 base color
 917                  */
 918                 if (regno >= 16)
 919                         break;
 920                 if (sfb->fb->var.bits_per_pixel == 16) {
 921                         u32 *pal = sfb->fb->pseudo_palette;
 922
 923                         val = chan_to_field(red, &sfb->fb->var.red);
 924                         val |= chan_to_field(green, &sfb->fb->var.green);
 925                         val |= chan_to_field(blue, &sfb->fb->var.blue);
 926                         pal[regno] = pal_rgb(red, green, blue, val);
 927                 } else {
 928                         u32 *pal = sfb->fb->pseudo_palette;
 929
 930                         val = chan_to_field(red, &sfb->fb->var.red);
 931                         val |= chan_to_field(green, &sfb->fb->var.green);
 932                         val |= chan_to_field(blue, &sfb->fb->var.blue);
 933                         pal[regno] = big_swap(val);
 934                 }
 935                 break;
 936
 937         case FB_VISUAL_PSEUDOCOLOR:
 938                 /* color depth 8 bit */
 939                 sm712_setpalette(regno, red, green, blue, info);
 940                 break;
 941
 942         default:
 943                 return 1;       /* unknown type */
 944         }
 945
 946         return 0;
 947 }
 948
 949 static ssize_t smtcfb_read(struct fb_info *info, char __user *buf,
 950                            size_t count, loff_t *ppos)
 951 {
 952         unsigned long p = *ppos;
 953
 954         u32 *buffer, *dst;
 955         u32 __iomem *src;
 956         int c, i, cnt = 0, err = 0;
 957         unsigned long total_size;
 958
 959         if (!info || !info->screen_base)
 960                 return -ENODEV;
 961
 962         if (info->state != FBINFO_STATE_RUNNING)
 963                 return -EPERM;
 964
 965         total_size = info->screen_size;
 966
 967         if (total_size == 0)
 968                 total_size = info->fix.smem_len;
 969
 970         if (p >= total_size)
 971                 return 0;
 972
 973         if (count >= total_size)
 974                 count = total_size;
 975
 976         if (count + p > total_size)
 977                 count = total_size - p;
 978
 979         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
 980         if (!buffer)
 981                 return -ENOMEM;
 982
 983         src = (u32 __iomem *)(info->screen_base + p);
 984
 985         if (info->fbops->fb_sync)
 986                 info->fbops->fb_sync(info);
 987
 988         while (count) {
 989                 c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
 990                 dst = buffer;
 991                 for (i = c >> 2; i--;) {
 992                         *dst = fb_readl(src++);
 993                         *dst = big_swap(*dst);
 994                         dst++;
 995                 }
 996                 if (c & 3) {
 997                         u8 *dst8 = (u8 *)dst;
 998                         u8 __iomem *src8 = (u8 __iomem *)src;
 999
1000                         for (i = c & 3; i--;) {
1001                                 if (i & 1) {
1002                                         *dst8++ = fb_readb(++src8);
1003                                 } else {
1004                                         *dst8++ = fb_readb(--src8);
1005                                         src8 += 2;
1006                                 }
1007                         }
1008                         src = (u32 __iomem *)src8;
1009                 }
1010
1011                 if (copy_to_user(buf, buffer, c)) {
1012                         err = -EFAULT;
1013                         break;
1014                 }
1015                 *ppos += c;
1016                 buf += c;
1017                 cnt += c;
1018                 count -= c;
1019         }
1020
1021         kfree(buffer);
1022
1023         return (err) ? err : cnt;
1024 }
1025
1026 static ssize_t smtcfb_write(struct fb_info *info, const char __user *buf,
1027                             size_t count, loff_t *ppos)
1028 {
1029         unsigned long p = *ppos;
1030
1031         u32 *buffer, *src;
1032         u32 __iomem *dst;
1033         int c, i, cnt = 0, err = 0;
1034         unsigned long total_size;
1035
1036         if (!info || !info->screen_base)
1037                 return -ENODEV;
1038
1039         if (info->state != FBINFO_STATE_RUNNING)
1040                 return -EPERM;
1041
1042         total_size = info->screen_size;
1043
1044         if (total_size == 0)
1045                 total_size = info->fix.smem_len;
1046
1047         if (p > total_size)
1048                 return -EFBIG;
1049
1050         if (count > total_size) {
1051                 err = -EFBIG;
1052                 count = total_size;
1053         }
1054
1055         if (count + p > total_size) {
1056                 if (!err)
1057                         err = -ENOSPC;
1058
1059                 count = total_size - p;
1060         }
1061
1062         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
1063         if (!buffer)
1064                 return -ENOMEM;
1065
1066         dst = (u32 __iomem *)(info->screen_base + p);
1067
1068         if (info->fbops->fb_sync)
1069                 info->fbops->fb_sync(info);
1070
1071         while (count) {
1072                 c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
1073                 src = buffer;
1074
1075                 if (copy_from_user(src, buf, c)) {
1076                         err = -EFAULT;
1077                         break;
1078                 }
1079
1080                 for (i = c >> 2; i--;) {
1081                         fb_writel(big_swap(*src), dst++);
1082                         src++;
1083                 }
1084                 if (c & 3) {
1085                         u8 *src8 = (u8 *)src;
1086                         u8 __iomem *dst8 = (u8 __iomem *)dst;
1087
1088                         for (i = c & 3; i--;) {
1089                                 if (i & 1) {
1090                                         fb_writeb(*src8++, ++dst8);
1091                                 } else {
1092                                         fb_writeb(*src8++, --dst8);
1093                                         dst8 += 2;
1094                                 }
1095                         }
1096                         dst = (u32 __iomem *)dst8;
1097                 }
1098
1099                 *ppos += c;
1100                 buf += c;
1101                 cnt += c;
1102                 count -= c;
1103         }
1104
1105         kfree(buffer);
1106
1107         return (cnt) ? cnt : err;
1108 }
1109
1110 static void sm7xx_set_timing(struct smtcfb_info *sfb)
1111 {
1112         int i = 0, j = 0;
1113         u32 m_nscreenstride;
1114
1115         dev_dbg(&sfb->pdev->dev,
1116                 "sfb->width=%d sfb->height=%d sfb->fb->var.bits_per_pixel=%d sfb->hz=%d\n",
1117                 sfb->width, sfb->height, sfb->fb->var.bits_per_pixel, sfb->hz);
1118
1119         for (j = 0; j < ARRAY_SIZE(vgamode); j++) {
1120                 if (vgamode[j].mmsizex != sfb->width ||
1121                     vgamode[j].mmsizey != sfb->height ||
1122                     vgamode[j].bpp != sfb->fb->var.bits_per_pixel ||
1123                     vgamode[j].hz != sfb->hz)
1124                         continue;
1125
1126                 dev_dbg(&sfb->pdev->dev,
1127                         "vgamode[j].mmsizex=%d vgamode[j].mmSizeY=%d vgamode[j].bpp=%d vgamode[j].hz=%d\n",
1128                         vgamode[j].mmsizex, vgamode[j].mmsizey,
1129                         vgamode[j].bpp, vgamode[j].hz);
1130
1131                 dev_dbg(&sfb->pdev->dev, "vgamode index=%d\n", j);
1132
1133                 smtc_mmiowb(0x0, 0x3c6);
1134
1135                 smtc_seqw(0, 0x1);
1136
1137                 smtc_mmiowb(vgamode[j].init_misc, 0x3c2);
1138
1139                 /* init SEQ register SR00 - SR04 */
1140                 for (i = 0; i < SIZE_SR00_SR04; i++)
1141                         smtc_seqw(i, vgamode[j].init_sr00_sr04[i]);
1142
1143                 /* init SEQ register SR10 - SR24 */
1144                 for (i = 0; i < SIZE_SR10_SR24; i++)
1145                         smtc_seqw(i + 0x10, vgamode[j].init_sr10_sr24[i]);
1146
1147                 /* init SEQ register SR30 - SR75 */
1148                 for (i = 0; i < SIZE_SR30_SR75; i++)
1149                         if ((i + 0x30) != 0x62 && (i + 0x30) != 0x6a &&
1150                             (i + 0x30) != 0x6b)
1151                                 smtc_seqw(i + 0x30,
1152                                           vgamode[j].init_sr30_sr75[i]);
1153
1154                 /* init SEQ register SR80 - SR93 */
1155                 for (i = 0; i < SIZE_SR80_SR93; i++)
1156                         smtc_seqw(i + 0x80, vgamode[j].init_sr80_sr93[i]);
1157
1158                 /* init SEQ register SRA0 - SRAF */
1159                 for (i = 0; i < SIZE_SRA0_SRAF; i++)
1160                         smtc_seqw(i + 0xa0, vgamode[j].init_sra0_sraf[i]);
1161
1162                 /* init Graphic register GR00 - GR08 */
1163                 for (i = 0; i < SIZE_GR00_GR08; i++)
1164                         smtc_grphw(i, vgamode[j].init_gr00_gr08[i]);
1165
1166                 /* init Attribute register AR00 - AR14 */
1167                 for (i = 0; i < SIZE_AR00_AR14; i++)
1168                         smtc_attrw(i, vgamode[j].init_ar00_ar14[i]);
1169
1170                 /* init CRTC register CR00 - CR18 */
1171                 for (i = 0; i < SIZE_CR00_CR18; i++)
1172                         smtc_crtcw(i, vgamode[j].init_cr00_cr18[i]);
1173
1174                 /* init CRTC register CR30 - CR4D */
1175                 for (i = 0; i < SIZE_CR30_CR4D; i++)
1176                         smtc_crtcw(i + 0x30, vgamode[j].init_cr30_cr4d[i]);
1177
1178                 /* init CRTC register CR90 - CRA7 */
1179                 for (i = 0; i < SIZE_CR90_CRA7; i++)
1180                         smtc_crtcw(i + 0x90, vgamode[j].init_cr90_cra7[i]);
1181         }
1182         smtc_mmiowb(0x67, 0x3c2);
1183
1184         /* set VPR registers */
1185         writel(0x0, sfb->vp_regs + 0x0C);
1186         writel(0x0, sfb->vp_regs + 0x40);
1187
1188         /* set data width */
1189         m_nscreenstride = (sfb->width * sfb->fb->var.bits_per_pixel) / 64;
1190         switch (sfb->fb->var.bits_per_pixel) {
1191         case 8:
1192                 writel(0x0, sfb->vp_regs + 0x0);
1193                 break;
1194         case 16:
1195                 writel(0x00020000, sfb->vp_regs + 0x0);
1196                 break;
1197         case 24:
1198                 writel(0x00040000, sfb->vp_regs + 0x0);
1199                 break;
1200         case 32:
1201                 writel(0x00030000, sfb->vp_regs + 0x0);
1202                 break;
1203         }
1204         writel((u32)(((m_nscreenstride + 2) << 16) | m_nscreenstride),
1205                sfb->vp_regs + 0x10);
1206 }
1207
1208 static void smtc_set_timing(struct smtcfb_info *sfb)
1209 {
1210         switch (sfb->chip_id) {
1211         case 0x710:
1212         case 0x712:
1213         case 0x720:
1214                 sm7xx_set_timing(sfb);
1215                 break;
1216         }
1217 }
1218
1219 static void smtcfb_setmode(struct smtcfb_info *sfb)
1220 {
1221         switch (sfb->fb->var.bits_per_pixel) {
1222         case 32:
1223                 sfb->fb->fix.visual       = FB_VISUAL_TRUECOLOR;
1224                 sfb->fb->fix.line_length  = sfb->fb->var.xres * 4;
1225                 sfb->fb->var.red.length   = 8;
1226                 sfb->fb->var.green.length = 8;
1227                 sfb->fb->var.blue.length  = 8;
1228                 sfb->fb->var.red.offset   = 16;
1229                 sfb->fb->var.green.offset = 8;
1230                 sfb->fb->var.blue.offset  = 0;
1231                 break;
1232         case 24:
1233                 sfb->fb->fix.visual       = FB_VISUAL_TRUECOLOR;
1234                 sfb->fb->fix.line_length  = sfb->fb->var.xres * 3;
1235                 sfb->fb->var.red.length   = 8;
1236                 sfb->fb->var.green.length = 8;
1237                 sfb->fb->var.blue.length  = 8;
1238                 sfb->fb->var.red.offset   = 16;
1239                 sfb->fb->var.green.offset = 8;
1240                 sfb->fb->var.blue.offset  = 0;
1241                 break;
1242         case 8:
1243                 sfb->fb->fix.visual       = FB_VISUAL_PSEUDOCOLOR;
1244                 sfb->fb->fix.line_length  = sfb->fb->var.xres;
1245                 sfb->fb->var.red.length   = 3;
1246                 sfb->fb->var.green.length = 3;
1247                 sfb->fb->var.blue.length  = 2;
1248                 sfb->fb->var.red.offset   = 5;
1249                 sfb->fb->var.green.offset = 2;
1250                 sfb->fb->var.blue.offset  = 0;
1251                 break;
1252         case 16:
1253         default:
1254                 sfb->fb->fix.visual       = FB_VISUAL_TRUECOLOR;
1255                 sfb->fb->fix.line_length  = sfb->fb->var.xres * 2;
1256                 sfb->fb->var.red.length   = 5;
1257                 sfb->fb->var.green.length = 6;
1258                 sfb->fb->var.blue.length  = 5;
1259                 sfb->fb->var.red.offset   = 11;
1260                 sfb->fb->var.green.offset = 5;
1261                 sfb->fb->var.blue.offset  = 0;
1262                 break;
1263         }
1264
1265         sfb->width  = sfb->fb->var.xres;
1266         sfb->height = sfb->fb->var.yres;
1267         sfb->hz = 60;
1268         smtc_set_timing(sfb);
1269 }
1270
1271 static int smtc_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1272 {
1273         /* sanity checks */
1274         if (var->xres_virtual < var->xres)
1275                 var->xres_virtual = var->xres;
1276
1277         if (var->yres_virtual < var->yres)
1278                 var->yres_virtual = var->yres;
1279
1280         /* set valid default bpp */
1281         if ((var->bits_per_pixel != 8)  && (var->bits_per_pixel != 16) &&
1282             (var->bits_per_pixel != 24) && (var->bits_per_pixel != 32))
1283                 var->bits_per_pixel = 16;
1284
1285         return 0;
1286 }
1287
1288 static int smtc_set_par(struct fb_info *info)
1289 {
1290         smtcfb_setmode(info->par);
1291
1292         return 0;
1293 }
1294
1295 static struct fb_ops smtcfb_ops = {
1296         .owner        = THIS_MODULE,
1297         .fb_check_var = smtc_check_var,
1298         .fb_set_par   = smtc_set_par,
1299         .fb_setcolreg = smtc_setcolreg,
1300         .fb_blank     = smtc_blank,
1301         .fb_fillrect  = cfb_fillrect,
1302         .fb_imageblit = cfb_imageblit,
1303         .fb_copyarea  = cfb_copyarea,
1304         .fb_read      = smtcfb_read,
1305         .fb_write     = smtcfb_write,
1306 };
1307
1308 /*
1309  * Unmap in the memory mapped IO registers
1310  */
1311
1312 static void smtc_unmap_mmio(struct smtcfb_info *sfb)
1313 {
1314         if (sfb && smtc_regbaseaddress)
1315                 smtc_regbaseaddress = NULL;
1316 }
1317
1318 /*
1319  * Map in the screen memory
1320  */
1321
1322 static int smtc_map_smem(struct smtcfb_info *sfb,
1323                          struct pci_dev *pdev, u_long smem_len)
1324 {
1325         sfb->fb->fix.smem_start = pci_resource_start(pdev, 0);
1326
1327         if (sfb->fb->var.bits_per_pixel == 32)
1328                 sfb->fb->fix.smem_start += big_addr;
1329
1330         sfb->fb->fix.smem_len = smem_len;
1331
1332         sfb->fb->screen_base = sfb->lfb;
1333
1334         if (!sfb->fb->screen_base) {
1335                 dev_err(&pdev->dev,
1336                         "%s: unable to map screen memory\n", sfb->fb->fix.id);
1337                 return -ENOMEM;
1338         }
1339
1340         return 0;
1341 }
1342
1343 /*
1344  * Unmap in the screen memory
1345  *
1346  */
1347 static void smtc_unmap_smem(struct smtcfb_info *sfb)
1348 {
1349         if (sfb && sfb->fb->screen_base) {
1350                 iounmap(sfb->fb->screen_base);
1351                 sfb->fb->screen_base = NULL;
1352         }
1353 }
1354
1355 /*
1356  * We need to wake up the device and make sure its in linear memory mode.
1357  */
1358 static inline void sm7xx_init_hw(void)
1359 {
1360         outb_p(0x18, 0x3c4);
1361         outb_p(0x11, 0x3c5);
1362 }
1363
1364 static int smtcfb_pci_probe(struct pci_dev *pdev,
1365                             const struct pci_device_id *ent)
1366 {
1367         struct smtcfb_info *sfb;
1368         struct fb_info *info;
1369         u_long smem_size = 0x00800000;  /* default 8MB */
1370         int err;
1371         unsigned long mmio_base;
1372
1373         dev_info(&pdev->dev, "Silicon Motion display driver.\n");
1374
1375         err = pci_enable_device(pdev);  /* enable SMTC chip */
1376         if (err)
1377                 return err;
1378
1379         err = pci_request_region(pdev, 0, "sm7xxfb");
1380         if (err < 0) {
1381                 dev_err(&pdev->dev, "cannot reserve framebuffer region\n");
1382                 goto failed_regions;
1383         }
1384
1385         sprintf(smtcfb_fix.id, "sm%Xfb", ent->device);
1386
1387         info = framebuffer_alloc(sizeof(*sfb), &pdev->dev);
1388         if (!info) {
1389                 dev_err(&pdev->dev, "framebuffer_alloc failed\n");
1390                 err = -ENOMEM;
1391                 goto failed_free;
1392         }
1393
1394         sfb = info->par;
1395         sfb->fb = info;
1396         sfb->chip_id = ent->device;
1397         sfb->pdev = pdev;
1398         info->flags = FBINFO_FLAG_DEFAULT;
1399         info->fbops = &smtcfb_ops;
1400         info->fix = smtcfb_fix;
1401         info->var = smtcfb_var;
1402         info->pseudo_palette = sfb->colreg;
1403         info->par = sfb;
1404
1405         pci_set_drvdata(pdev, sfb);
1406
1407         sm7xx_init_hw();
1408
1409         /* get mode parameter from smtc_scr_info */
1410         if (smtc_scr_info.lfb_width != 0) {
1411                 sfb->fb->var.xres = smtc_scr_info.lfb_width;
1412                 sfb->fb->var.yres = smtc_scr_info.lfb_height;
1413                 sfb->fb->var.bits_per_pixel = smtc_scr_info.lfb_depth;
1414         } else {
1415                 /* default resolution 1024x600 16bit mode */
1416                 sfb->fb->var.xres = SCREEN_X_RES;
1417                 sfb->fb->var.yres = SCREEN_Y_RES;
1418                 sfb->fb->var.bits_per_pixel = SCREEN_BPP;
1419         }
1420
1421         big_pixel_depth(sfb->fb->var.bits_per_pixel, smtc_scr_info.lfb_depth);
1422         /* Map address and memory detection */
1423         mmio_base = pci_resource_start(pdev, 0);
1424         pci_read_config_byte(pdev, PCI_REVISION_ID, &sfb->chip_rev_id);
1425
1426         switch (sfb->chip_id) {
1427         case 0x710:
1428         case 0x712:
1429                 sfb->fb->fix.mmio_start = mmio_base + 0x00400000;
1430                 sfb->fb->fix.mmio_len = 0x00400000;
1431                 smem_size = SM712_VIDEOMEMORYSIZE;
1432                 sfb->lfb = ioremap(mmio_base, mmio_addr);
1433                 if (!sfb->lfb) {
1434                         dev_err(&pdev->dev,
1435                                 "%s: unable to map memory mapped IO!\n",
1436                                 sfb->fb->fix.id);
1437                         err = -ENOMEM;
1438                         goto failed_fb;
1439                 }
1440
1441                 sfb->mmio = (smtc_regbaseaddress =
1442                     sfb->lfb + 0x00700000);
1443                 sfb->dp_regs = sfb->lfb + 0x00408000;
1444                 sfb->vp_regs = sfb->lfb + 0x0040c000;
1445                 if (sfb->fb->var.bits_per_pixel == 32) {
1446                         sfb->lfb += big_addr;
1447                         dev_info(&pdev->dev, "sfb->lfb=%p\n", sfb->lfb);
1448                 }
1449
1450                 /* set MCLK = 14.31818 * (0x16 / 0x2) */
1451                 smtc_seqw(0x6a, 0x16);
1452                 smtc_seqw(0x6b, 0x02);
1453                 smtc_seqw(0x62, 0x3e);
1454                 /* enable PCI burst */
1455                 smtc_seqw(0x17, 0x20);
1456                 /* enable word swap */
1457                 if (sfb->fb->var.bits_per_pixel == 32)
1458                         seqw17();
1459                 break;
1460         case 0x720:
1461                 sfb->fb->fix.mmio_start = mmio_base;
1462                 sfb->fb->fix.mmio_len = 0x00200000;
1463                 smem_size = SM722_VIDEOMEMORYSIZE;
1464                 sfb->dp_regs = ioremap(mmio_base, 0x00a00000);
1465                 sfb->lfb = sfb->dp_regs + 0x00200000;
1466                 sfb->mmio = (smtc_regbaseaddress =
1467                     sfb->dp_regs + 0x000c0000);
1468                 sfb->vp_regs = sfb->dp_regs + 0x800;
1469
1470                 smtc_seqw(0x62, 0xff);
1471                 smtc_seqw(0x6a, 0x0d);
1472                 smtc_seqw(0x6b, 0x02);
1473                 break;
1474         default:
1475                 dev_err(&pdev->dev,
1476                         "No valid Silicon Motion display chip was detected!\n");
1477
1478                 goto failed_fb;
1479         }
1480
1481         /* can support 32 bpp */
1482         if (15 == sfb->fb->var.bits_per_pixel)
1483                 sfb->fb->var.bits_per_pixel = 16;
1484
1485         sfb->fb->var.xres_virtual = sfb->fb->var.xres;
1486         sfb->fb->var.yres_virtual = sfb->fb->var.yres;
1487         err = smtc_map_smem(sfb, pdev, smem_size);
1488         if (err)
1489                 goto failed;
1490
1491         smtcfb_setmode(sfb);
1492
1493         err = register_framebuffer(info);
1494         if (err < 0)
1495                 goto failed;
1496
1497         dev_info(&pdev->dev,
1498                  "Silicon Motion SM%X Rev%X primary display mode %dx%d-%d Init Complete.\n",
1499                  sfb->chip_id, sfb->chip_rev_id, sfb->fb->var.xres,
1500                  sfb->fb->var.yres, sfb->fb->var.bits_per_pixel);
1501
1502         return 0;
1503
1504 failed:
1505         dev_err(&pdev->dev, "Silicon Motion, Inc. primary display init fail.\n");
1506
1507         smtc_unmap_smem(sfb);
1508         smtc_unmap_mmio(sfb);
1509 failed_fb:
1510         framebuffer_release(info);
1511
1512 failed_free:
1513         pci_release_region(pdev, 0);
1514
1515 failed_regions:
1516         pci_disable_device(pdev);
1517
1518         return err;
1519 }
1520
1521 /*
1522  * 0x710 (LynxEM)
1523  * 0x712 (LynxEM+)
1524  * 0x720 (Lynx3DM, Lynx3DM+)
1525  */
1526 static const struct pci_device_id smtcfb_pci_table[] = {
1527         { PCI_DEVICE(0x126f, 0x710), },
1528         { PCI_DEVICE(0x126f, 0x712), },
1529         { PCI_DEVICE(0x126f, 0x720), },
1530         {0,}
1531 };
1532
1533 MODULE_DEVICE_TABLE(pci, smtcfb_pci_table);
1534
1535 static void smtcfb_pci_remove(struct pci_dev *pdev)
1536 {
1537         struct smtcfb_info *sfb;
1538
1539         sfb = pci_get_drvdata(pdev);
1540         smtc_unmap_smem(sfb);
1541         smtc_unmap_mmio(sfb);
1542         unregister_framebuffer(sfb->fb);
1543         framebuffer_release(sfb->fb);
1544         pci_release_region(pdev, 0);
1545         pci_disable_device(pdev);
1546 }
1547
1548 #ifdef CONFIG_PM
1549 static int smtcfb_pci_suspend(struct device *device)
1550 {
1551         struct pci_dev *pdev = to_pci_dev(device);
1552         struct smtcfb_info *sfb;
1553
1554         sfb = pci_get_drvdata(pdev);
1555
1556         /* set the hw in sleep mode use external clock and self memory refresh
1557          * so that we can turn off internal PLLs later on
1558          */
1559         smtc_seqw(0x20, (smtc_seqr(0x20) | 0xc0));
1560         smtc_seqw(0x69, (smtc_seqr(0x69) & 0xf7));
1561
1562         console_lock();
1563         fb_set_suspend(sfb->fb, 1);
1564         console_unlock();
1565
1566         /* additionally turn off all function blocks including internal PLLs */
1567         smtc_seqw(0x21, 0xff);
1568
1569         return 0;
1570 }
1571
1572 static int smtcfb_pci_resume(struct device *device)
1573 {
1574         struct pci_dev *pdev = to_pci_dev(device);
1575         struct smtcfb_info *sfb;
1576
1577         sfb = pci_get_drvdata(pdev);
1578
1579         /* reinit hardware */
1580         sm7xx_init_hw();
1581         switch (sfb->chip_id) {
1582         case 0x710:
1583         case 0x712:
1584                 /* set MCLK = 14.31818 *  (0x16 / 0x2) */
1585                 smtc_seqw(0x6a, 0x16);
1586                 smtc_seqw(0x6b, 0x02);
1587                 smtc_seqw(0x62, 0x3e);
1588                 /* enable PCI burst */
1589                 smtc_seqw(0x17, 0x20);
1590                 if (sfb->fb->var.bits_per_pixel == 32)
1591                         seqw17();
1592                 break;
1593         case 0x720:
1594                 smtc_seqw(0x62, 0xff);
1595                 smtc_seqw(0x6a, 0x0d);
1596                 smtc_seqw(0x6b, 0x02);
1597                 break;
1598         }
1599
1600         smtc_seqw(0x34, (smtc_seqr(0x34) | 0xc0));
1601         smtc_seqw(0x33, ((smtc_seqr(0x33) | 0x08) & 0xfb));
1602
1603         smtcfb_setmode(sfb);
1604
1605         console_lock();
1606         fb_set_suspend(sfb->fb, 0);
1607         console_unlock();
1608
1609         return 0;
1610 }
1611
1612 static SIMPLE_DEV_PM_OPS(sm7xx_pm_ops, smtcfb_pci_suspend, smtcfb_pci_resume);
1613 #define SM7XX_PM_OPS (&sm7xx_pm_ops)
1614
1615 #else  /* !CONFIG_PM */
1616
1617 #define SM7XX_PM_OPS NULL
1618
1619 #endif /* !CONFIG_PM */
1620
1621 static struct pci_driver smtcfb_driver = {
1622         .name = "smtcfb",
1623         .id_table = smtcfb_pci_table,
1624         .probe = smtcfb_pci_probe,
1625         .remove = smtcfb_pci_remove,
1626         .driver.pm  = SM7XX_PM_OPS,
1627 };
1628
1629 static int __init sm712fb_init(void)
1630 {
1631         char *option = NULL;
1632
1633         if (fb_get_options("sm712fb", &option))
1634                 return -ENODEV;
1635         if (option && *option)
1636                 mode_option = option;
1637         sm7xx_vga_setup(mode_option);
1638
1639         return pci_register_driver(&smtcfb_driver);
1640 }
1641
1642 module_init(sm712fb_init);
1643
1644 static void __exit sm712fb_exit(void)
1645 {
1646         pci_unregister_driver(&smtcfb_driver);
1647 }
1648
1649 module_exit(sm712fb_exit);
1650
1651 MODULE_AUTHOR("Siliconmotion ");
1652 MODULE_DESCRIPTION("Framebuffer driver for SMI Graphic Cards");
1653 MODULE_LICENSE("GPL");