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