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