diff options
Diffstat (limited to 'drivers/video/geode/gxfb_core.c')
-rw-r--r-- | drivers/video/geode/gxfb_core.c | 423 |
1 files changed, 423 insertions, 0 deletions
diff --git a/drivers/video/geode/gxfb_core.c b/drivers/video/geode/gxfb_core.c new file mode 100644 index 00000000000..89c34b15f5d --- /dev/null +++ b/drivers/video/geode/gxfb_core.c | |||
@@ -0,0 +1,423 @@ | |||
1 | /* | ||
2 | * Geode GX framebuffer driver. | ||
3 | * | ||
4 | * Copyright (C) 2006 Arcom Control Systems Ltd. | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify it | ||
7 | * under the terms of the GNU General Public License as published by the | ||
8 | * Free Software Foundation; either version 2 of the License, or (at your | ||
9 | * option) any later version. | ||
10 | * | ||
11 | * | ||
12 | * This driver assumes that the BIOS has created a virtual PCI device header | ||
13 | * for the video device. The PCI header is assumed to contain the following | ||
14 | * BARs: | ||
15 | * | ||
16 | * BAR0 - framebuffer memory | ||
17 | * BAR1 - graphics processor registers | ||
18 | * BAR2 - display controller registers | ||
19 | * BAR3 - video processor and flat panel control registers. | ||
20 | * | ||
21 | * 16 MiB of framebuffer memory is assumed to be available. | ||
22 | */ | ||
23 | #include <linux/module.h> | ||
24 | #include <linux/kernel.h> | ||
25 | #include <linux/errno.h> | ||
26 | #include <linux/string.h> | ||
27 | #include <linux/mm.h> | ||
28 | #include <linux/tty.h> | ||
29 | #include <linux/slab.h> | ||
30 | #include <linux/delay.h> | ||
31 | #include <linux/fb.h> | ||
32 | #include <linux/init.h> | ||
33 | #include <linux/pci.h> | ||
34 | |||
35 | #include "geodefb.h" | ||
36 | #include "display_gx.h" | ||
37 | #include "video_gx.h" | ||
38 | |||
39 | static char mode_option[32] = "640x480-16@60"; | ||
40 | |||
41 | /* Modes relevant to the GX (taken from modedb.c) */ | ||
42 | static const struct fb_videomode __initdata gx_modedb[] = { | ||
43 | /* 640x480-60 VESA */ | ||
44 | { NULL, 60, 640, 480, 39682, 48, 16, 33, 10, 96, 2, | ||
45 | 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
46 | /* 640x480-75 VESA */ | ||
47 | { NULL, 75, 640, 480, 31746, 120, 16, 16, 01, 64, 3, | ||
48 | 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
49 | /* 640x480-85 VESA */ | ||
50 | { NULL, 85, 640, 480, 27777, 80, 56, 25, 01, 56, 3, | ||
51 | 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
52 | /* 800x600-60 VESA */ | ||
53 | { NULL, 60, 800, 600, 25000, 88, 40, 23, 01, 128, 4, | ||
54 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
55 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
56 | /* 800x600-75 VESA */ | ||
57 | { NULL, 75, 800, 600, 20202, 160, 16, 21, 01, 80, 3, | ||
58 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
59 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
60 | /* 800x600-85 VESA */ | ||
61 | { NULL, 85, 800, 600, 17761, 152, 32, 27, 01, 64, 3, | ||
62 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
63 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
64 | /* 1024x768-60 VESA */ | ||
65 | { NULL, 60, 1024, 768, 15384, 160, 24, 29, 3, 136, 6, | ||
66 | 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
67 | /* 1024x768-75 VESA */ | ||
68 | { NULL, 75, 1024, 768, 12690, 176, 16, 28, 1, 96, 3, | ||
69 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
70 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
71 | /* 1024x768-85 VESA */ | ||
72 | { NULL, 85, 1024, 768, 10582, 208, 48, 36, 1, 96, 3, | ||
73 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
74 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
75 | /* 1280x960-60 VESA */ | ||
76 | { NULL, 60, 1280, 960, 9259, 312, 96, 36, 1, 112, 3, | ||
77 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
78 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
79 | /* 1280x960-85 VESA */ | ||
80 | { NULL, 85, 1280, 960, 6734, 224, 64, 47, 1, 160, 3, | ||
81 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
82 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
83 | /* 1280x1024-60 VESA */ | ||
84 | { NULL, 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3, | ||
85 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
86 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
87 | /* 1280x1024-75 VESA */ | ||
88 | { NULL, 75, 1280, 1024, 7407, 248, 16, 38, 1, 144, 3, | ||
89 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
90 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
91 | /* 1280x1024-85 VESA */ | ||
92 | { NULL, 85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3, | ||
93 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
94 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
95 | /* 1600x1200-60 VESA */ | ||
96 | { NULL, 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3, | ||
97 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
98 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
99 | /* 1600x1200-75 VESA */ | ||
100 | { NULL, 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3, | ||
101 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
102 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
103 | /* 1600x1200-85 VESA */ | ||
104 | { NULL, 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3, | ||
105 | FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
106 | FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA }, | ||
107 | }; | ||
108 | |||
109 | static int gxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info) | ||
110 | { | ||
111 | if (var->xres > 1600 || var->yres > 1200) | ||
112 | return -EINVAL; | ||
113 | if ((var->xres > 1280 || var->yres > 1024) && var->bits_per_pixel > 16) | ||
114 | return -EINVAL; | ||
115 | |||
116 | if (var->bits_per_pixel == 32) { | ||
117 | var->red.offset = 16; var->red.length = 8; | ||
118 | var->green.offset = 8; var->green.length = 8; | ||
119 | var->blue.offset = 0; var->blue.length = 8; | ||
120 | } else if (var->bits_per_pixel == 16) { | ||
121 | var->red.offset = 11; var->red.length = 5; | ||
122 | var->green.offset = 5; var->green.length = 6; | ||
123 | var->blue.offset = 0; var->blue.length = 5; | ||
124 | } else if (var->bits_per_pixel == 8) { | ||
125 | var->red.offset = 0; var->red.length = 8; | ||
126 | var->green.offset = 0; var->green.length = 8; | ||
127 | var->blue.offset = 0; var->blue.length = 8; | ||
128 | } else | ||
129 | return -EINVAL; | ||
130 | var->transp.offset = 0; var->transp.length = 0; | ||
131 | |||
132 | /* Enough video memory? */ | ||
133 | if (gx_line_delta(var->xres, var->bits_per_pixel) * var->yres > info->fix.smem_len) | ||
134 | return -EINVAL; | ||
135 | |||
136 | /* FIXME: Check timing parameters here? */ | ||
137 | |||
138 | return 0; | ||
139 | } | ||
140 | |||
141 | static int gxfb_set_par(struct fb_info *info) | ||
142 | { | ||
143 | struct geodefb_par *par = info->par; | ||
144 | |||
145 | if (info->var.bits_per_pixel > 8) { | ||
146 | info->fix.visual = FB_VISUAL_TRUECOLOR; | ||
147 | fb_dealloc_cmap(&info->cmap); | ||
148 | } else { | ||
149 | info->fix.visual = FB_VISUAL_PSEUDOCOLOR; | ||
150 | fb_alloc_cmap(&info->cmap, 1<<info->var.bits_per_pixel, 0); | ||
151 | } | ||
152 | |||
153 | info->fix.line_length = gx_line_delta(info->var.xres, info->var.bits_per_pixel); | ||
154 | |||
155 | par->dc_ops->set_mode(info); | ||
156 | |||
157 | return 0; | ||
158 | } | ||
159 | |||
160 | static inline u_int chan_to_field(u_int chan, struct fb_bitfield *bf) | ||
161 | { | ||
162 | chan &= 0xffff; | ||
163 | chan >>= 16 - bf->length; | ||
164 | return chan << bf->offset; | ||
165 | } | ||
166 | |||
167 | static int gxfb_setcolreg(unsigned regno, unsigned red, unsigned green, | ||
168 | unsigned blue, unsigned transp, | ||
169 | struct fb_info *info) | ||
170 | { | ||
171 | struct geodefb_par *par = info->par; | ||
172 | |||
173 | if (info->var.grayscale) { | ||
174 | /* grayscale = 0.30*R + 0.59*G + 0.11*B */ | ||
175 | red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8; | ||
176 | } | ||
177 | |||
178 | /* Truecolor has hardware independent palette */ | ||
179 | if (info->fix.visual == FB_VISUAL_TRUECOLOR) { | ||
180 | u32 *pal = info->pseudo_palette; | ||
181 | u32 v; | ||
182 | |||
183 | if (regno >= 16) | ||
184 | return -EINVAL; | ||
185 | |||
186 | v = chan_to_field(red, &info->var.red); | ||
187 | v |= chan_to_field(green, &info->var.green); | ||
188 | v |= chan_to_field(blue, &info->var.blue); | ||
189 | |||
190 | pal[regno] = v; | ||
191 | } else { | ||
192 | if (regno >= 256) | ||
193 | return -EINVAL; | ||
194 | |||
195 | par->dc_ops->set_palette_reg(info, regno, red, green, blue); | ||
196 | } | ||
197 | |||
198 | return 0; | ||
199 | } | ||
200 | |||
201 | static int gxfb_blank(int blank_mode, struct fb_info *info) | ||
202 | { | ||
203 | struct geodefb_par *par = info->par; | ||
204 | |||
205 | return par->vid_ops->blank_display(info, blank_mode); | ||
206 | } | ||
207 | |||
208 | static int __init gxfb_map_video_memory(struct fb_info *info, struct pci_dev *dev) | ||
209 | { | ||
210 | struct geodefb_par *par = info->par; | ||
211 | int fb_len; | ||
212 | int ret; | ||
213 | |||
214 | ret = pci_enable_device(dev); | ||
215 | if (ret < 0) | ||
216 | return ret; | ||
217 | |||
218 | ret = pci_request_region(dev, 3, "gxfb (video processor)"); | ||
219 | if (ret < 0) | ||
220 | return ret; | ||
221 | par->vid_regs = ioremap(pci_resource_start(dev, 3), | ||
222 | pci_resource_len(dev, 3)); | ||
223 | if (!par->vid_regs) | ||
224 | return -ENOMEM; | ||
225 | |||
226 | ret = pci_request_region(dev, 2, "gxfb (display controller)"); | ||
227 | if (ret < 0) | ||
228 | return ret; | ||
229 | par->dc_regs = ioremap(pci_resource_start(dev, 2), pci_resource_len(dev, 2)); | ||
230 | if (!par->dc_regs) | ||
231 | return -ENOMEM; | ||
232 | |||
233 | ret = pci_request_region(dev, 0, "gxfb (framebuffer)"); | ||
234 | if (ret < 0) | ||
235 | return ret; | ||
236 | if ((fb_len = gx_frame_buffer_size()) < 0) | ||
237 | return -ENOMEM; | ||
238 | info->fix.smem_start = pci_resource_start(dev, 0); | ||
239 | info->fix.smem_len = fb_len; | ||
240 | info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len); | ||
241 | if (!info->screen_base) | ||
242 | return -ENOMEM; | ||
243 | |||
244 | dev_info(&dev->dev, "%d Kibyte of video memory at 0x%lx\n", | ||
245 | info->fix.smem_len / 1024, info->fix.smem_start); | ||
246 | |||
247 | return 0; | ||
248 | } | ||
249 | |||
250 | static struct fb_ops gxfb_ops = { | ||
251 | .owner = THIS_MODULE, | ||
252 | .fb_check_var = gxfb_check_var, | ||
253 | .fb_set_par = gxfb_set_par, | ||
254 | .fb_setcolreg = gxfb_setcolreg, | ||
255 | .fb_blank = gxfb_blank, | ||
256 | /* No HW acceleration for now. */ | ||
257 | .fb_fillrect = cfb_fillrect, | ||
258 | .fb_copyarea = cfb_copyarea, | ||
259 | .fb_imageblit = cfb_imageblit, | ||
260 | }; | ||
261 | |||
262 | static struct fb_info * __init gxfb_init_fbinfo(struct device *dev) | ||
263 | { | ||
264 | struct geodefb_par *par; | ||
265 | struct fb_info *info; | ||
266 | |||
267 | /* Alloc enough space for the pseudo palette. */ | ||
268 | info = framebuffer_alloc(sizeof(struct geodefb_par) + sizeof(u32) * 16, dev); | ||
269 | if (!info) | ||
270 | return NULL; | ||
271 | |||
272 | par = info->par; | ||
273 | |||
274 | strcpy(info->fix.id, "Geode GX"); | ||
275 | |||
276 | info->fix.type = FB_TYPE_PACKED_PIXELS; | ||
277 | info->fix.type_aux = 0; | ||
278 | info->fix.xpanstep = 0; | ||
279 | info->fix.ypanstep = 0; | ||
280 | info->fix.ywrapstep = 0; | ||
281 | info->fix.accel = FB_ACCEL_NONE; | ||
282 | |||
283 | info->var.nonstd = 0; | ||
284 | info->var.activate = FB_ACTIVATE_NOW; | ||
285 | info->var.height = -1; | ||
286 | info->var.width = -1; | ||
287 | info->var.accel_flags = 0; | ||
288 | info->var.vmode = FB_VMODE_NONINTERLACED; | ||
289 | |||
290 | info->fbops = &gxfb_ops; | ||
291 | info->flags = FBINFO_DEFAULT; | ||
292 | info->node = -1; | ||
293 | |||
294 | info->pseudo_palette = (void *)par + sizeof(struct geodefb_par); | ||
295 | |||
296 | info->var.grayscale = 0; | ||
297 | |||
298 | return info; | ||
299 | } | ||
300 | |||
301 | static int __init gxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id) | ||
302 | { | ||
303 | struct geodefb_par *par; | ||
304 | struct fb_info *info; | ||
305 | int ret; | ||
306 | |||
307 | info = gxfb_init_fbinfo(&pdev->dev); | ||
308 | if (!info) | ||
309 | return -ENOMEM; | ||
310 | par = info->par; | ||
311 | |||
312 | /* GX display controller and GX video device. */ | ||
313 | par->dc_ops = &gx_dc_ops; | ||
314 | par->vid_ops = &gx_vid_ops; | ||
315 | |||
316 | if ((ret = gxfb_map_video_memory(info, pdev)) < 0) { | ||
317 | dev_err(&pdev->dev, "failed to map frame buffer or controller registers\n"); | ||
318 | goto err; | ||
319 | } | ||
320 | |||
321 | ret = fb_find_mode(&info->var, info, mode_option, | ||
322 | gx_modedb, ARRAY_SIZE(gx_modedb), NULL, 16); | ||
323 | if (ret == 0 || ret == 4) { | ||
324 | dev_err(&pdev->dev, "could not find valid video mode\n"); | ||
325 | ret = -EINVAL; | ||
326 | goto err; | ||
327 | } | ||
328 | |||
329 | /* Clear the frame buffer of garbage. */ | ||
330 | memset_io(info->screen_base, 0, info->fix.smem_len); | ||
331 | |||
332 | gxfb_check_var(&info->var, info); | ||
333 | gxfb_set_par(info); | ||
334 | |||
335 | if (register_framebuffer(info) < 0) { | ||
336 | ret = -EINVAL; | ||
337 | goto err; | ||
338 | } | ||
339 | pci_set_drvdata(pdev, info); | ||
340 | printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id); | ||
341 | return 0; | ||
342 | |||
343 | err: | ||
344 | if (info->screen_base) { | ||
345 | iounmap(info->screen_base); | ||
346 | pci_release_region(pdev, 0); | ||
347 | } | ||
348 | if (par->vid_regs) { | ||
349 | iounmap(par->vid_regs); | ||
350 | pci_release_region(pdev, 3); | ||
351 | } | ||
352 | if (par->dc_regs) { | ||
353 | iounmap(par->dc_regs); | ||
354 | pci_release_region(pdev, 2); | ||
355 | } | ||
356 | |||
357 | pci_disable_device(pdev); | ||
358 | |||
359 | if (info) | ||
360 | framebuffer_release(info); | ||
361 | return ret; | ||
362 | } | ||
363 | |||
364 | static void gxfb_remove(struct pci_dev *pdev) | ||
365 | { | ||
366 | struct fb_info *info = pci_get_drvdata(pdev); | ||
367 | struct geodefb_par *par = info->par; | ||
368 | |||
369 | unregister_framebuffer(info); | ||
370 | |||
371 | iounmap((void __iomem *)info->screen_base); | ||
372 | pci_release_region(pdev, 0); | ||
373 | |||
374 | iounmap(par->vid_regs); | ||
375 | pci_release_region(pdev, 3); | ||
376 | |||
377 | iounmap(par->dc_regs); | ||
378 | pci_release_region(pdev, 2); | ||
379 | |||
380 | pci_disable_device(pdev); | ||
381 | pci_set_drvdata(pdev, NULL); | ||
382 | |||
383 | framebuffer_release(info); | ||
384 | } | ||
385 | |||
386 | static struct pci_device_id gxfb_id_table[] = { | ||
387 | { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_VIDEO, | ||
388 | PCI_ANY_ID, PCI_ANY_ID, PCI_BASE_CLASS_DISPLAY << 16, | ||
389 | 0xff0000, 0 }, | ||
390 | { 0, } | ||
391 | }; | ||
392 | |||
393 | MODULE_DEVICE_TABLE(pci, gxfb_id_table); | ||
394 | |||
395 | static struct pci_driver gxfb_driver = { | ||
396 | .name = "gxfb", | ||
397 | .id_table = gxfb_id_table, | ||
398 | .probe = gxfb_probe, | ||
399 | .remove = gxfb_remove, | ||
400 | }; | ||
401 | |||
402 | static int __init gxfb_init(void) | ||
403 | { | ||
404 | #ifndef MODULE | ||
405 | if (fb_get_options("gxfb", NULL)) | ||
406 | return -ENODEV; | ||
407 | #endif | ||
408 | return pci_register_driver(&gxfb_driver); | ||
409 | } | ||
410 | |||
411 | static void __exit gxfb_cleanup(void) | ||
412 | { | ||
413 | pci_unregister_driver(&gxfb_driver); | ||
414 | } | ||
415 | |||
416 | module_init(gxfb_init); | ||
417 | module_exit(gxfb_cleanup); | ||
418 | |||
419 | module_param_string(mode, mode_option, sizeof(mode_option), 0444); | ||
420 | MODULE_PARM_DESC(mode, "video mode (<x>x<y>[-<bpp>][@<refr>])"); | ||
421 | |||
422 | MODULE_DESCRIPTION("Framebuffer driver for the AMD Geode GX"); | ||
423 | MODULE_LICENSE("GPL"); | ||