Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1 | /* |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 2 | * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved. |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 3 | * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved. |
| 4 | |
| 5 | * This program is free software; you can redistribute it and/or |
| 6 | * modify it under the terms of the GNU General Public |
| 7 | * License as published by the Free Software Foundation; |
| 8 | * either version 2, or (at your option) any later version. |
| 9 | |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTIES OR REPRESENTATIONS; without even |
| 12 | * the implied warranty of MERCHANTABILITY or FITNESS FOR |
| 13 | * A PARTICULAR PURPOSE.See the GNU General Public License |
| 14 | * for more details. |
| 15 | |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., |
| 19 | * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 20 | */ |
| 21 | |
| 22 | #include <linux/module.h> |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 23 | #include <linux/seq_file.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 24 | #include <linux/slab.h> |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 25 | #include <linux/stat.h> |
Jonathan Corbet | ec66841 | 2010-05-05 14:44:55 -0600 | [diff] [blame] | 26 | #include <linux/via-core.h> |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 27 | |
Jonathan Corbet | ec66841 | 2010-05-05 14:44:55 -0600 | [diff] [blame] | 28 | #define _MASTER_FILE |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 29 | #include "global.h" |
| 30 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 31 | static char *viafb_name = "Via"; |
| 32 | static u32 pseudo_pal[17]; |
| 33 | |
| 34 | /* video mode */ |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 35 | static char *viafb_mode; |
| 36 | static char *viafb_mode1; |
Florian Tobias Schandinat | dba77f8 | 2010-03-10 15:21:37 -0800 | [diff] [blame] | 37 | static int viafb_bpp = 32; |
| 38 | static int viafb_bpp1 = 32; |
| 39 | |
| 40 | static unsigned int viafb_second_offset; |
| 41 | static int viafb_second_size; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 42 | |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 43 | static int viafb_accel = 1; |
| 44 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 45 | /* Added for specifying active devices.*/ |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 46 | char *viafb_active_dev; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 47 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 48 | /*Added for specify lcd output port*/ |
| 49 | char *viafb_lcd_port = ""; |
| 50 | char *viafb_dvi_port = ""; |
| 51 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 52 | static void retrieve_device_setting(struct viafb_ioctl_setting |
| 53 | *setting_info); |
Florian Tobias Schandinat | ee79d54 | 2010-03-10 15:21:32 -0800 | [diff] [blame] | 54 | static int viafb_pan_display(struct fb_var_screeninfo *var, |
| 55 | struct fb_info *info); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 56 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 57 | static struct fb_ops viafb_ops; |
| 58 | |
Florian Tobias Schandinat | 81228a3 | 2009-09-22 16:47:13 -0700 | [diff] [blame] | 59 | |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 60 | static void viafb_fill_var_color_info(struct fb_var_screeninfo *var, u8 depth) |
| 61 | { |
| 62 | var->grayscale = 0; |
| 63 | var->red.msb_right = 0; |
| 64 | var->green.msb_right = 0; |
| 65 | var->blue.msb_right = 0; |
| 66 | var->transp.offset = 0; |
| 67 | var->transp.length = 0; |
| 68 | var->transp.msb_right = 0; |
| 69 | var->nonstd = 0; |
| 70 | switch (depth) { |
| 71 | case 8: |
| 72 | var->bits_per_pixel = 8; |
| 73 | var->red.offset = 0; |
| 74 | var->green.offset = 0; |
| 75 | var->blue.offset = 0; |
Florian Tobias Schandinat | 415559f | 2010-03-10 15:21:40 -0800 | [diff] [blame] | 76 | var->red.length = 8; |
| 77 | var->green.length = 8; |
| 78 | var->blue.length = 8; |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 79 | break; |
Florian Tobias Schandinat | e17cea3 | 2010-03-10 15:21:41 -0800 | [diff] [blame] | 80 | case 15: |
| 81 | var->bits_per_pixel = 16; |
| 82 | var->red.offset = 10; |
| 83 | var->green.offset = 5; |
| 84 | var->blue.offset = 0; |
| 85 | var->red.length = 5; |
| 86 | var->green.length = 5; |
| 87 | var->blue.length = 5; |
| 88 | break; |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 89 | case 16: |
| 90 | var->bits_per_pixel = 16; |
| 91 | var->red.offset = 11; |
| 92 | var->green.offset = 5; |
| 93 | var->blue.offset = 0; |
| 94 | var->red.length = 5; |
| 95 | var->green.length = 6; |
| 96 | var->blue.length = 5; |
| 97 | break; |
| 98 | case 24: |
| 99 | var->bits_per_pixel = 32; |
| 100 | var->red.offset = 16; |
| 101 | var->green.offset = 8; |
| 102 | var->blue.offset = 0; |
| 103 | var->red.length = 8; |
| 104 | var->green.length = 8; |
| 105 | var->blue.length = 8; |
| 106 | break; |
Florian Tobias Schandinat | e17cea3 | 2010-03-10 15:21:41 -0800 | [diff] [blame] | 107 | case 30: |
| 108 | var->bits_per_pixel = 32; |
| 109 | var->red.offset = 20; |
| 110 | var->green.offset = 10; |
| 111 | var->blue.offset = 0; |
| 112 | var->red.length = 10; |
| 113 | var->green.length = 10; |
| 114 | var->blue.length = 10; |
| 115 | break; |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 116 | } |
| 117 | } |
| 118 | |
Florian Tobias Schandinat | 81228a3 | 2009-09-22 16:47:13 -0700 | [diff] [blame] | 119 | static void viafb_update_fix(struct fb_info *info) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 120 | { |
Florian Tobias Schandinat | 81228a3 | 2009-09-22 16:47:13 -0700 | [diff] [blame] | 121 | u32 bpp = info->var.bits_per_pixel; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 122 | |
Florian Tobias Schandinat | 81228a3 | 2009-09-22 16:47:13 -0700 | [diff] [blame] | 123 | info->fix.visual = |
| 124 | bpp == 8 ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR; |
Florian Tobias Schandinat | dbb7884 | 2010-03-10 15:21:39 -0800 | [diff] [blame] | 125 | info->fix.line_length = (info->var.xres_virtual * bpp / 8 + 7) & ~7; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 126 | } |
| 127 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 128 | static void viafb_setup_fixinfo(struct fb_fix_screeninfo *fix, |
| 129 | struct viafb_par *viaparinfo) |
| 130 | { |
| 131 | memset(fix, 0, sizeof(struct fb_fix_screeninfo)); |
| 132 | strcpy(fix->id, viafb_name); |
| 133 | |
| 134 | fix->smem_start = viaparinfo->fbmem; |
| 135 | fix->smem_len = viaparinfo->fbmem_free; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 136 | |
| 137 | fix->type = FB_TYPE_PACKED_PIXELS; |
| 138 | fix->type_aux = 0; |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 139 | fix->visual = FB_VISUAL_TRUECOLOR; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 140 | |
| 141 | fix->xpanstep = fix->ywrapstep = 0; |
| 142 | fix->ypanstep = 1; |
| 143 | |
| 144 | /* Just tell the accel name */ |
| 145 | viafbinfo->fix.accel = FB_ACCEL_VIA_UNICHROME; |
| 146 | } |
| 147 | static int viafb_open(struct fb_info *info, int user) |
| 148 | { |
| 149 | DEBUG_MSG(KERN_INFO "viafb_open!\n"); |
| 150 | return 0; |
| 151 | } |
| 152 | |
| 153 | static int viafb_release(struct fb_info *info, int user) |
| 154 | { |
| 155 | DEBUG_MSG(KERN_INFO "viafb_release!\n"); |
| 156 | return 0; |
| 157 | } |
| 158 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 159 | static int viafb_check_var(struct fb_var_screeninfo *var, |
| 160 | struct fb_info *info) |
| 161 | { |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 162 | int htotal, vtotal, depth; |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 163 | struct VideoModeTable *vmode_entry; |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 164 | struct viafb_par *ppar = info->par; |
Florian Tobias Schandinat | dbb7884 | 2010-03-10 15:21:39 -0800 | [diff] [blame] | 165 | u32 long_refresh, line; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 166 | |
| 167 | DEBUG_MSG(KERN_INFO "viafb_check_var!\n"); |
| 168 | /* Sanity check */ |
| 169 | /* HW neither support interlacte nor double-scaned mode */ |
| 170 | if (var->vmode & FB_VMODE_INTERLACED || var->vmode & FB_VMODE_DOUBLE) |
| 171 | return -EINVAL; |
| 172 | |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 173 | vmode_entry = viafb_get_mode(var->xres, var->yres); |
| 174 | if (!vmode_entry) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 175 | DEBUG_MSG(KERN_INFO |
| 176 | "viafb: Mode %dx%dx%d not supported!!\n", |
| 177 | var->xres, var->yres, var->bits_per_pixel); |
| 178 | return -EINVAL; |
| 179 | } |
| 180 | |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 181 | depth = fb_get_color_depth(var, &info->fix); |
| 182 | if (!depth) |
| 183 | depth = var->bits_per_pixel; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 184 | |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 185 | if (depth < 0 || depth > 32) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 186 | return -EINVAL; |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 187 | else if (!depth) |
| 188 | depth = 24; |
Florian Tobias Schandinat | e17cea3 | 2010-03-10 15:21:41 -0800 | [diff] [blame] | 189 | else if (depth == 15 && viafb_dual_fb && ppar->iga_path == IGA1) |
| 190 | depth = 15; |
| 191 | else if (depth == 30) |
| 192 | depth = 30; |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 193 | else if (depth <= 8) |
| 194 | depth = 8; |
| 195 | else if (depth <= 16) |
| 196 | depth = 16; |
| 197 | else |
| 198 | depth = 24; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 199 | |
Florian Tobias Schandinat | bd14069 | 2010-03-10 15:21:38 -0800 | [diff] [blame] | 200 | viafb_fill_var_color_info(var, depth); |
Florian Tobias Schandinat | dbb7884 | 2010-03-10 15:21:39 -0800 | [diff] [blame] | 201 | line = (var->xres_virtual * var->bits_per_pixel / 8 + 7) & ~7; |
| 202 | if (line * var->yres_virtual > ppar->memsize) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 203 | return -EINVAL; |
| 204 | |
| 205 | /* Based on var passed in to calculate the refresh, |
| 206 | * because our driver use some modes special. |
| 207 | */ |
| 208 | htotal = var->xres + var->left_margin + |
| 209 | var->right_margin + var->hsync_len; |
| 210 | vtotal = var->yres + var->upper_margin + |
| 211 | var->lower_margin + var->vsync_len; |
| 212 | long_refresh = 1000000000UL / var->pixclock * 1000; |
| 213 | long_refresh /= (htotal * vtotal); |
| 214 | |
| 215 | viafb_refresh = viafb_get_refresh(var->xres, var->yres, long_refresh); |
| 216 | |
| 217 | /* Adjust var according to our driver's own table */ |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 218 | viafb_fill_var_timing_info(var, viafb_refresh, vmode_entry); |
Florian Tobias Schandinat | af29a5b | 2010-07-23 11:32:25 +0000 | [diff] [blame^] | 219 | if (var->accel_flags & FB_ACCELF_TEXT && |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 220 | !ppar->shared->vdev->engine_mmio) |
Florian Tobias Schandinat | af29a5b | 2010-07-23 11:32:25 +0000 | [diff] [blame^] | 221 | var->accel_flags = 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 222 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 223 | return 0; |
| 224 | } |
| 225 | |
| 226 | static int viafb_set_par(struct fb_info *info) |
| 227 | { |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 228 | struct viafb_par *viapar = info->par; |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 229 | struct VideoModeTable *vmode_entry, *vmode_entry1 = NULL; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 230 | DEBUG_MSG(KERN_INFO "viafb_set_par!\n"); |
| 231 | |
Florian Tobias Schandinat | 65123c6 | 2010-07-13 17:58:06 +0000 | [diff] [blame] | 232 | viafb_update_fix(info); |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 233 | viapar->depth = fb_get_color_depth(&info->var, &info->fix); |
Florian Tobias Schandinat | 5c9443e | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 234 | viafb_update_device_setting(viafbinfo->var.xres, viafbinfo->var.yres, |
| 235 | viafbinfo->var.bits_per_pixel, viafb_refresh, 0); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 236 | |
Florian Tobias Schandinat | 5c9443e | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 237 | vmode_entry = viafb_get_mode(viafbinfo->var.xres, viafbinfo->var.yres); |
| 238 | if (viafb_dual_fb) { |
| 239 | vmode_entry1 = viafb_get_mode(viafbinfo1->var.xres, |
| 240 | viafbinfo1->var.yres); |
| 241 | viafb_update_device_setting(viafbinfo1->var.xres, |
| 242 | viafbinfo1->var.yres, viafbinfo1->var.bits_per_pixel, |
| 243 | viafb_refresh1, 1); |
| 244 | } else if (viafb_SAMM_ON == 1) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 245 | DEBUG_MSG(KERN_INFO |
| 246 | "viafb_second_xres = %d, viafb_second_yres = %d, bpp = %d\n", |
| 247 | viafb_second_xres, viafb_second_yres, viafb_bpp1); |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 248 | vmode_entry1 = viafb_get_mode(viafb_second_xres, |
Florian Tobias Schandinat | 5215944 | 2009-08-06 15:07:34 -0700 | [diff] [blame] | 249 | viafb_second_yres); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 250 | |
| 251 | viafb_update_device_setting(viafb_second_xres, |
| 252 | viafb_second_yres, viafb_bpp1, viafb_refresh1, 1); |
| 253 | } |
| 254 | |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 255 | if (vmode_entry) { |
Florian Tobias Schandinat | 5c9443e | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 256 | if (viafb_dual_fb && viapar->iga_path == IGA2) |
| 257 | viafb_bpp1 = info->var.bits_per_pixel; |
| 258 | else |
| 259 | viafb_bpp = info->var.bits_per_pixel; |
| 260 | |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 261 | if (info->var.accel_flags & FB_ACCELF_TEXT) |
| 262 | info->flags &= ~FBINFO_HWACCEL_DISABLED; |
| 263 | else |
| 264 | info->flags |= FBINFO_HWACCEL_DISABLED; |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 265 | viafb_setmode(vmode_entry, info->var.bits_per_pixel, |
| 266 | vmode_entry1, viafb_bpp1); |
Florian Tobias Schandinat | ee79d54 | 2010-03-10 15:21:32 -0800 | [diff] [blame] | 267 | viafb_pan_display(&info->var, info); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 268 | } |
| 269 | |
| 270 | return 0; |
| 271 | } |
| 272 | |
| 273 | /* Set one color register */ |
| 274 | static int viafb_setcolreg(unsigned regno, unsigned red, unsigned green, |
| 275 | unsigned blue, unsigned transp, struct fb_info *info) |
| 276 | { |
Florian Tobias Schandinat | 415559f | 2010-03-10 15:21:40 -0800 | [diff] [blame] | 277 | struct viafb_par *viapar = info->par; |
| 278 | u32 r, g, b; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 279 | |
Florian Tobias Schandinat | 415559f | 2010-03-10 15:21:40 -0800 | [diff] [blame] | 280 | if (info->fix.visual == FB_VISUAL_PSEUDOCOLOR) { |
| 281 | if (regno > 255) |
| 282 | return -EINVAL; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 283 | |
Florian Tobias Schandinat | 415559f | 2010-03-10 15:21:40 -0800 | [diff] [blame] | 284 | if (!viafb_dual_fb || viapar->iga_path == IGA1) |
| 285 | viafb_set_primary_color_register(regno, red >> 8, |
| 286 | green >> 8, blue >> 8); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 287 | |
Florian Tobias Schandinat | 415559f | 2010-03-10 15:21:40 -0800 | [diff] [blame] | 288 | if (!viafb_dual_fb || viapar->iga_path == IGA2) |
| 289 | viafb_set_secondary_color_register(regno, red >> 8, |
| 290 | green >> 8, blue >> 8); |
| 291 | } else { |
| 292 | if (regno > 15) |
| 293 | return -EINVAL; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 294 | |
Florian Tobias Schandinat | 415559f | 2010-03-10 15:21:40 -0800 | [diff] [blame] | 295 | r = (red >> (16 - info->var.red.length)) |
| 296 | << info->var.red.offset; |
| 297 | b = (blue >> (16 - info->var.blue.length)) |
| 298 | << info->var.blue.offset; |
| 299 | g = (green >> (16 - info->var.green.length)) |
| 300 | << info->var.green.offset; |
| 301 | ((u32 *) info->pseudo_palette)[regno] = r | g | b; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 302 | } |
| 303 | |
| 304 | return 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 305 | } |
| 306 | |
| 307 | static int viafb_pan_display(struct fb_var_screeninfo *var, |
| 308 | struct fb_info *info) |
| 309 | { |
Florian Tobias Schandinat | ee79d54 | 2010-03-10 15:21:32 -0800 | [diff] [blame] | 310 | struct viafb_par *viapar = info->par; |
| 311 | u32 vram_addr = (var->yoffset * var->xres_virtual + var->xoffset) |
| 312 | * (var->bits_per_pixel / 8) + viapar->vram_addr; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 313 | |
Florian Tobias Schandinat | ee79d54 | 2010-03-10 15:21:32 -0800 | [diff] [blame] | 314 | DEBUG_MSG(KERN_DEBUG "viafb_pan_display, address = %d\n", vram_addr); |
| 315 | if (!viafb_dual_fb) { |
Florian Tobias Schandinat | 2749413 | 2010-04-17 19:44:52 +0000 | [diff] [blame] | 316 | via_set_primary_address(vram_addr); |
| 317 | via_set_secondary_address(vram_addr); |
Florian Tobias Schandinat | ee79d54 | 2010-03-10 15:21:32 -0800 | [diff] [blame] | 318 | } else if (viapar->iga_path == IGA1) |
Florian Tobias Schandinat | 2749413 | 2010-04-17 19:44:52 +0000 | [diff] [blame] | 319 | via_set_primary_address(vram_addr); |
Florian Tobias Schandinat | ee79d54 | 2010-03-10 15:21:32 -0800 | [diff] [blame] | 320 | else |
Florian Tobias Schandinat | 2749413 | 2010-04-17 19:44:52 +0000 | [diff] [blame] | 321 | via_set_secondary_address(vram_addr); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 322 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 323 | return 0; |
| 324 | } |
| 325 | |
| 326 | static int viafb_blank(int blank_mode, struct fb_info *info) |
| 327 | { |
| 328 | DEBUG_MSG(KERN_INFO "viafb_blank!\n"); |
| 329 | /* clear DPMS setting */ |
| 330 | |
| 331 | switch (blank_mode) { |
| 332 | case FB_BLANK_UNBLANK: |
| 333 | /* Screen: On, HSync: On, VSync: On */ |
| 334 | /* control CRT monitor power management */ |
| 335 | viafb_write_reg_mask(CR36, VIACR, 0x00, BIT4 + BIT5); |
| 336 | break; |
| 337 | case FB_BLANK_HSYNC_SUSPEND: |
| 338 | /* Screen: Off, HSync: Off, VSync: On */ |
| 339 | /* control CRT monitor power management */ |
| 340 | viafb_write_reg_mask(CR36, VIACR, 0x10, BIT4 + BIT5); |
| 341 | break; |
| 342 | case FB_BLANK_VSYNC_SUSPEND: |
| 343 | /* Screen: Off, HSync: On, VSync: Off */ |
| 344 | /* control CRT monitor power management */ |
| 345 | viafb_write_reg_mask(CR36, VIACR, 0x20, BIT4 + BIT5); |
| 346 | break; |
| 347 | case FB_BLANK_POWERDOWN: |
| 348 | /* Screen: Off, HSync: Off, VSync: Off */ |
| 349 | /* control CRT monitor power management */ |
| 350 | viafb_write_reg_mask(CR36, VIACR, 0x30, BIT4 + BIT5); |
| 351 | break; |
| 352 | } |
| 353 | |
| 354 | return 0; |
| 355 | } |
| 356 | |
| 357 | static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg) |
| 358 | { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 359 | union { |
| 360 | struct viafb_ioctl_mode viamode; |
| 361 | struct viafb_ioctl_samm viasamm; |
| 362 | struct viafb_driver_version driver_version; |
| 363 | struct fb_var_screeninfo sec_var; |
| 364 | struct _panel_size_pos_info panel_pos_size_para; |
| 365 | struct viafb_ioctl_setting viafb_setting; |
| 366 | struct device_t active_dev; |
| 367 | } u; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 368 | u32 state_info = 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 369 | u32 *viafb_gamma_table; |
| 370 | char driver_name[] = "viafb"; |
| 371 | |
| 372 | u32 __user *argp = (u32 __user *) arg; |
| 373 | u32 gpu32; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 374 | |
| 375 | DEBUG_MSG(KERN_INFO "viafb_ioctl: 0x%X !!\n", cmd); |
Florian Tobias Schandinat | cc8b82f | 2010-03-10 15:21:26 -0800 | [diff] [blame] | 376 | printk(KERN_WARNING "viafb_ioctl: Please avoid this interface as it is unstable and might change or vanish at any time!\n"); |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 377 | memset(&u, 0, sizeof(u)); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 378 | |
| 379 | switch (cmd) { |
| 380 | case VIAFB_GET_CHIP_INFO: |
| 381 | if (copy_to_user(argp, viaparinfo->chip_info, |
| 382 | sizeof(struct chip_information))) |
| 383 | return -EFAULT; |
| 384 | break; |
| 385 | case VIAFB_GET_INFO_SIZE: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 386 | return put_user((u32)sizeof(struct viafb_ioctl_info), argp); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 387 | case VIAFB_GET_INFO: |
| 388 | return viafb_ioctl_get_viafb_info(arg); |
| 389 | case VIAFB_HOTPLUG: |
| 390 | return put_user(viafb_ioctl_hotplug(info->var.xres, |
| 391 | info->var.yres, |
| 392 | info->var.bits_per_pixel), argp); |
| 393 | case VIAFB_SET_HOTPLUG_FLAG: |
| 394 | if (copy_from_user(&gpu32, argp, sizeof(gpu32))) |
| 395 | return -EFAULT; |
| 396 | viafb_hotplug = (gpu32) ? 1 : 0; |
| 397 | break; |
| 398 | case VIAFB_GET_RESOLUTION: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 399 | u.viamode.xres = (u32) viafb_hotplug_Xres; |
| 400 | u.viamode.yres = (u32) viafb_hotplug_Yres; |
| 401 | u.viamode.refresh = (u32) viafb_hotplug_refresh; |
| 402 | u.viamode.bpp = (u32) viafb_hotplug_bpp; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 403 | if (viafb_SAMM_ON == 1) { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 404 | u.viamode.xres_sec = viafb_second_xres; |
| 405 | u.viamode.yres_sec = viafb_second_yres; |
| 406 | u.viamode.virtual_xres_sec = viafb_second_virtual_xres; |
| 407 | u.viamode.virtual_yres_sec = viafb_second_virtual_yres; |
| 408 | u.viamode.refresh_sec = viafb_refresh1; |
| 409 | u.viamode.bpp_sec = viafb_bpp1; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 410 | } else { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 411 | u.viamode.xres_sec = 0; |
| 412 | u.viamode.yres_sec = 0; |
| 413 | u.viamode.virtual_xres_sec = 0; |
| 414 | u.viamode.virtual_yres_sec = 0; |
| 415 | u.viamode.refresh_sec = 0; |
| 416 | u.viamode.bpp_sec = 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 417 | } |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 418 | if (copy_to_user(argp, &u.viamode, sizeof(u.viamode))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 419 | return -EFAULT; |
| 420 | break; |
| 421 | case VIAFB_GET_SAMM_INFO: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 422 | u.viasamm.samm_status = viafb_SAMM_ON; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 423 | |
| 424 | if (viafb_SAMM_ON == 1) { |
| 425 | if (viafb_dual_fb) { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 426 | u.viasamm.size_prim = viaparinfo->fbmem_free; |
| 427 | u.viasamm.size_sec = viaparinfo1->fbmem_free; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 428 | } else { |
| 429 | if (viafb_second_size) { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 430 | u.viasamm.size_prim = |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 431 | viaparinfo->fbmem_free - |
| 432 | viafb_second_size * 1024 * 1024; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 433 | u.viasamm.size_sec = |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 434 | viafb_second_size * 1024 * 1024; |
| 435 | } else { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 436 | u.viasamm.size_prim = |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 437 | viaparinfo->fbmem_free >> 1; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 438 | u.viasamm.size_sec = |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 439 | (viaparinfo->fbmem_free >> 1); |
| 440 | } |
| 441 | } |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 442 | u.viasamm.mem_base = viaparinfo->fbmem; |
| 443 | u.viasamm.offset_sec = viafb_second_offset; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 444 | } else { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 445 | u.viasamm.size_prim = |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 446 | viaparinfo->memsize - viaparinfo->fbmem_used; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 447 | u.viasamm.size_sec = 0; |
| 448 | u.viasamm.mem_base = viaparinfo->fbmem; |
| 449 | u.viasamm.offset_sec = 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 450 | } |
| 451 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 452 | if (copy_to_user(argp, &u.viasamm, sizeof(u.viasamm))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 453 | return -EFAULT; |
| 454 | |
| 455 | break; |
| 456 | case VIAFB_TURN_ON_OUTPUT_DEVICE: |
| 457 | if (copy_from_user(&gpu32, argp, sizeof(gpu32))) |
| 458 | return -EFAULT; |
| 459 | if (gpu32 & CRT_Device) |
| 460 | viafb_crt_enable(); |
| 461 | if (gpu32 & DVI_Device) |
| 462 | viafb_dvi_enable(); |
| 463 | if (gpu32 & LCD_Device) |
| 464 | viafb_lcd_enable(); |
| 465 | break; |
| 466 | case VIAFB_TURN_OFF_OUTPUT_DEVICE: |
| 467 | if (copy_from_user(&gpu32, argp, sizeof(gpu32))) |
| 468 | return -EFAULT; |
| 469 | if (gpu32 & CRT_Device) |
| 470 | viafb_crt_disable(); |
| 471 | if (gpu32 & DVI_Device) |
| 472 | viafb_dvi_disable(); |
| 473 | if (gpu32 & LCD_Device) |
| 474 | viafb_lcd_disable(); |
| 475 | break; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 476 | case VIAFB_GET_DEVICE: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 477 | u.active_dev.crt = viafb_CRT_ON; |
| 478 | u.active_dev.dvi = viafb_DVI_ON; |
| 479 | u.active_dev.lcd = viafb_LCD_ON; |
| 480 | u.active_dev.samm = viafb_SAMM_ON; |
| 481 | u.active_dev.primary_dev = viafb_primary_dev; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 482 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 483 | u.active_dev.lcd_dsp_cent = viafb_lcd_dsp_method; |
| 484 | u.active_dev.lcd_panel_id = viafb_lcd_panel_id; |
| 485 | u.active_dev.lcd_mode = viafb_lcd_mode; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 486 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 487 | u.active_dev.xres = viafb_hotplug_Xres; |
| 488 | u.active_dev.yres = viafb_hotplug_Yres; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 489 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 490 | u.active_dev.xres1 = viafb_second_xres; |
| 491 | u.active_dev.yres1 = viafb_second_yres; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 492 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 493 | u.active_dev.bpp = viafb_bpp; |
| 494 | u.active_dev.bpp1 = viafb_bpp1; |
| 495 | u.active_dev.refresh = viafb_refresh; |
| 496 | u.active_dev.refresh1 = viafb_refresh1; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 497 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 498 | u.active_dev.epia_dvi = viafb_platform_epia_dvi; |
| 499 | u.active_dev.lcd_dual_edge = viafb_device_lcd_dualedge; |
| 500 | u.active_dev.bus_width = viafb_bus_width; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 501 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 502 | if (copy_to_user(argp, &u.active_dev, sizeof(u.active_dev))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 503 | return -EFAULT; |
| 504 | break; |
| 505 | |
| 506 | case VIAFB_GET_DRIVER_VERSION: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 507 | u.driver_version.iMajorNum = VERSION_MAJOR; |
| 508 | u.driver_version.iKernelNum = VERSION_KERNEL; |
| 509 | u.driver_version.iOSNum = VERSION_OS; |
| 510 | u.driver_version.iMinorNum = VERSION_MINOR; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 511 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 512 | if (copy_to_user(argp, &u.driver_version, |
| 513 | sizeof(u.driver_version))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 514 | return -EFAULT; |
| 515 | |
| 516 | break; |
| 517 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 518 | case VIAFB_GET_DEVICE_INFO: |
| 519 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 520 | retrieve_device_setting(&u.viafb_setting); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 521 | |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 522 | if (copy_to_user(argp, &u.viafb_setting, |
| 523 | sizeof(u.viafb_setting))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 524 | return -EFAULT; |
| 525 | |
| 526 | break; |
| 527 | |
| 528 | case VIAFB_GET_DEVICE_SUPPORT: |
| 529 | viafb_get_device_support_state(&state_info); |
| 530 | if (put_user(state_info, argp)) |
| 531 | return -EFAULT; |
| 532 | break; |
| 533 | |
| 534 | case VIAFB_GET_DEVICE_CONNECT: |
| 535 | viafb_get_device_connect_state(&state_info); |
| 536 | if (put_user(state_info, argp)) |
| 537 | return -EFAULT; |
| 538 | break; |
| 539 | |
| 540 | case VIAFB_GET_PANEL_SUPPORT_EXPAND: |
| 541 | state_info = |
| 542 | viafb_lcd_get_support_expand_state(info->var.xres, |
| 543 | info->var.yres); |
| 544 | if (put_user(state_info, argp)) |
| 545 | return -EFAULT; |
| 546 | break; |
| 547 | |
| 548 | case VIAFB_GET_DRIVER_NAME: |
| 549 | if (copy_to_user(argp, driver_name, sizeof(driver_name))) |
| 550 | return -EFAULT; |
| 551 | break; |
| 552 | |
| 553 | case VIAFB_SET_GAMMA_LUT: |
Julia Lawall | a51faab | 2010-05-26 14:42:29 -0700 | [diff] [blame] | 554 | viafb_gamma_table = memdup_user(argp, 256 * sizeof(u32)); |
| 555 | if (IS_ERR(viafb_gamma_table)) |
| 556 | return PTR_ERR(viafb_gamma_table); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 557 | viafb_set_gamma_table(viafb_bpp, viafb_gamma_table); |
| 558 | kfree(viafb_gamma_table); |
| 559 | break; |
| 560 | |
| 561 | case VIAFB_GET_GAMMA_LUT: |
| 562 | viafb_gamma_table = kmalloc(256 * sizeof(u32), GFP_KERNEL); |
| 563 | if (!viafb_gamma_table) |
| 564 | return -ENOMEM; |
| 565 | viafb_get_gamma_table(viafb_gamma_table); |
| 566 | if (copy_to_user(argp, viafb_gamma_table, |
Julia Lawall | 0f05058 | 2009-12-17 15:27:09 -0800 | [diff] [blame] | 567 | 256 * sizeof(u32))) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 568 | kfree(viafb_gamma_table); |
| 569 | return -EFAULT; |
| 570 | } |
| 571 | kfree(viafb_gamma_table); |
| 572 | break; |
| 573 | |
| 574 | case VIAFB_GET_GAMMA_SUPPORT_STATE: |
| 575 | viafb_get_gamma_support_state(viafb_bpp, &state_info); |
| 576 | if (put_user(state_info, argp)) |
| 577 | return -EFAULT; |
| 578 | break; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 579 | case VIAFB_SYNC_SURFACE: |
| 580 | DEBUG_MSG(KERN_INFO "lobo VIAFB_SYNC_SURFACE\n"); |
| 581 | break; |
| 582 | case VIAFB_GET_DRIVER_CAPS: |
| 583 | break; |
| 584 | |
| 585 | case VIAFB_GET_PANEL_MAX_SIZE: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 586 | if (copy_from_user(&u.panel_pos_size_para, argp, |
| 587 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 588 | return -EFAULT; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 589 | u.panel_pos_size_para.x = u.panel_pos_size_para.y = 0; |
| 590 | if (copy_to_user(argp, &u.panel_pos_size_para, |
| 591 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 592 | return -EFAULT; |
| 593 | break; |
| 594 | case VIAFB_GET_PANEL_MAX_POSITION: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 595 | if (copy_from_user(&u.panel_pos_size_para, argp, |
| 596 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 597 | return -EFAULT; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 598 | u.panel_pos_size_para.x = u.panel_pos_size_para.y = 0; |
| 599 | if (copy_to_user(argp, &u.panel_pos_size_para, |
| 600 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 601 | return -EFAULT; |
| 602 | break; |
| 603 | |
| 604 | case VIAFB_GET_PANEL_POSITION: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 605 | if (copy_from_user(&u.panel_pos_size_para, argp, |
| 606 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 607 | return -EFAULT; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 608 | u.panel_pos_size_para.x = u.panel_pos_size_para.y = 0; |
| 609 | if (copy_to_user(argp, &u.panel_pos_size_para, |
| 610 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 611 | return -EFAULT; |
| 612 | break; |
| 613 | case VIAFB_GET_PANEL_SIZE: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 614 | if (copy_from_user(&u.panel_pos_size_para, argp, |
| 615 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 616 | return -EFAULT; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 617 | u.panel_pos_size_para.x = u.panel_pos_size_para.y = 0; |
| 618 | if (copy_to_user(argp, &u.panel_pos_size_para, |
| 619 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 620 | return -EFAULT; |
| 621 | break; |
| 622 | |
| 623 | case VIAFB_SET_PANEL_POSITION: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 624 | if (copy_from_user(&u.panel_pos_size_para, argp, |
| 625 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 626 | return -EFAULT; |
| 627 | break; |
| 628 | case VIAFB_SET_PANEL_SIZE: |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 629 | if (copy_from_user(&u.panel_pos_size_para, argp, |
| 630 | sizeof(u.panel_pos_size_para))) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 631 | return -EFAULT; |
| 632 | break; |
| 633 | |
| 634 | default: |
| 635 | return -EINVAL; |
| 636 | } |
| 637 | |
| 638 | return 0; |
| 639 | } |
| 640 | |
| 641 | static void viafb_fillrect(struct fb_info *info, |
| 642 | const struct fb_fillrect *rect) |
| 643 | { |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 644 | struct viafb_par *viapar = info->par; |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 645 | struct viafb_shared *shared = viapar->shared; |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 646 | u32 fg_color; |
| 647 | u8 rop; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 648 | |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 649 | if (info->flags & FBINFO_HWACCEL_DISABLED || !shared->hw_bitblt) { |
Hannes Eder | 2899bb0 | 2009-01-06 14:42:32 -0800 | [diff] [blame] | 650 | cfb_fillrect(info, rect); |
| 651 | return; |
| 652 | } |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 653 | |
| 654 | if (!rect->width || !rect->height) |
| 655 | return; |
| 656 | |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 657 | if (info->fix.visual == FB_VISUAL_TRUECOLOR) |
| 658 | fg_color = ((u32 *)info->pseudo_palette)[rect->color]; |
| 659 | else |
| 660 | fg_color = rect->color; |
| 661 | |
| 662 | if (rect->rop == ROP_XOR) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 663 | rop = 0x5A; |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 664 | else |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 665 | rop = 0xF0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 666 | |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 667 | DEBUG_MSG(KERN_DEBUG "viafb 2D engine: fillrect\n"); |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 668 | if (shared->hw_bitblt(shared->vdev->engine_mmio, VIA_BITBLT_FILL, |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 669 | rect->width, rect->height, info->var.bits_per_pixel, |
| 670 | viapar->vram_addr, info->fix.line_length, rect->dx, rect->dy, |
| 671 | NULL, 0, 0, 0, 0, fg_color, 0, rop)) |
| 672 | cfb_fillrect(info, rect); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 673 | } |
| 674 | |
| 675 | static void viafb_copyarea(struct fb_info *info, |
| 676 | const struct fb_copyarea *area) |
| 677 | { |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 678 | struct viafb_par *viapar = info->par; |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 679 | struct viafb_shared *shared = viapar->shared; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 680 | |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 681 | if (info->flags & FBINFO_HWACCEL_DISABLED || !shared->hw_bitblt) { |
Hannes Eder | 2899bb0 | 2009-01-06 14:42:32 -0800 | [diff] [blame] | 682 | cfb_copyarea(info, area); |
| 683 | return; |
| 684 | } |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 685 | |
| 686 | if (!area->width || !area->height) |
| 687 | return; |
| 688 | |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 689 | DEBUG_MSG(KERN_DEBUG "viafb 2D engine: copyarea\n"); |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 690 | if (shared->hw_bitblt(shared->vdev->engine_mmio, VIA_BITBLT_COLOR, |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 691 | area->width, area->height, info->var.bits_per_pixel, |
| 692 | viapar->vram_addr, info->fix.line_length, area->dx, area->dy, |
| 693 | NULL, viapar->vram_addr, info->fix.line_length, |
| 694 | area->sx, area->sy, 0, 0, 0)) |
| 695 | cfb_copyarea(info, area); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 696 | } |
| 697 | |
| 698 | static void viafb_imageblit(struct fb_info *info, |
| 699 | const struct fb_image *image) |
| 700 | { |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 701 | struct viafb_par *viapar = info->par; |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 702 | struct viafb_shared *shared = viapar->shared; |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 703 | u32 fg_color = 0, bg_color = 0; |
| 704 | u8 op; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 705 | |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 706 | if (info->flags & FBINFO_HWACCEL_DISABLED || !shared->hw_bitblt || |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 707 | (image->depth != 1 && image->depth != viapar->depth)) { |
Hannes Eder | 2899bb0 | 2009-01-06 14:42:32 -0800 | [diff] [blame] | 708 | cfb_imageblit(info, image); |
| 709 | return; |
| 710 | } |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 711 | |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 712 | if (image->depth == 1) { |
| 713 | op = VIA_BITBLT_MONO; |
| 714 | if (info->fix.visual == FB_VISUAL_TRUECOLOR) { |
| 715 | fg_color = |
| 716 | ((u32 *)info->pseudo_palette)[image->fg_color]; |
| 717 | bg_color = |
| 718 | ((u32 *)info->pseudo_palette)[image->bg_color]; |
| 719 | } else { |
| 720 | fg_color = image->fg_color; |
| 721 | bg_color = image->bg_color; |
| 722 | } |
| 723 | } else |
| 724 | op = VIA_BITBLT_COLOR; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 725 | |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 726 | DEBUG_MSG(KERN_DEBUG "viafb 2D engine: imageblit\n"); |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 727 | if (shared->hw_bitblt(shared->vdev->engine_mmio, op, |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 728 | image->width, image->height, info->var.bits_per_pixel, |
| 729 | viapar->vram_addr, info->fix.line_length, image->dx, image->dy, |
| 730 | (u32 *)image->data, 0, 0, 0, 0, fg_color, bg_color, 0)) |
| 731 | cfb_imageblit(info, image); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 732 | } |
| 733 | |
| 734 | static int viafb_cursor(struct fb_info *info, struct fb_cursor *cursor) |
| 735 | { |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 736 | struct viafb_par *viapar = info->par; |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 737 | void __iomem *engine = viapar->shared->vdev->engine_mmio; |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 738 | u32 temp, xx, yy, bg_color = 0, fg_color = 0, |
| 739 | chip_name = viapar->shared->chip_info.gfx_chip_name; |
| 740 | int i, j = 0, cur_size = 64; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 741 | |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 742 | if (info->flags & FBINFO_HWACCEL_DISABLED || info != viafbinfo) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 743 | return -ENODEV; |
| 744 | |
Florian Tobias Schandinat | 0b94190 | 2010-01-15 17:01:03 -0800 | [diff] [blame] | 745 | /* LCD ouput does not support hw cursors (at least on VN896) */ |
| 746 | if ((chip_name == UNICHROME_CLE266 && viapar->iga_path == IGA2) || |
| 747 | viafb_LCD_ON) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 748 | return -ENODEV; |
| 749 | |
| 750 | viafb_show_hw_cursor(info, HW_Cursor_OFF); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 751 | |
| 752 | if (cursor->set & FB_CUR_SETHOT) { |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 753 | temp = (cursor->hot.x << 16) + cursor->hot.y; |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 754 | writel(temp, engine + VIA_REG_CURSOR_ORG); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 755 | } |
| 756 | |
| 757 | if (cursor->set & FB_CUR_SETPOS) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 758 | yy = cursor->image.dy - info->var.yoffset; |
| 759 | xx = cursor->image.dx - info->var.xoffset; |
| 760 | temp = yy & 0xFFFF; |
| 761 | temp |= (xx << 16); |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 762 | writel(temp, engine + VIA_REG_CURSOR_POS); |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 763 | } |
| 764 | |
| 765 | if (cursor->image.width <= 32 && cursor->image.height <= 32) |
| 766 | cur_size = 32; |
| 767 | else if (cursor->image.width <= 64 && cursor->image.height <= 64) |
| 768 | cur_size = 64; |
| 769 | else { |
| 770 | printk(KERN_WARNING "viafb_cursor: The cursor is too large " |
| 771 | "%dx%d", cursor->image.width, cursor->image.height); |
| 772 | return -ENXIO; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 773 | } |
| 774 | |
| 775 | if (cursor->set & FB_CUR_SETSIZE) { |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 776 | temp = readl(engine + VIA_REG_CURSOR_MODE); |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 777 | if (cur_size == 32) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 778 | temp |= 0x2; |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 779 | else |
| 780 | temp &= ~0x2; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 781 | |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 782 | writel(temp, engine + VIA_REG_CURSOR_MODE); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 783 | } |
| 784 | |
| 785 | if (cursor->set & FB_CUR_SETCMAP) { |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 786 | fg_color = cursor->image.fg_color; |
| 787 | bg_color = cursor->image.bg_color; |
| 788 | if (chip_name == UNICHROME_CX700 || |
Harald Welte | 0306ab1 | 2009-09-22 16:47:35 -0700 | [diff] [blame] | 789 | chip_name == UNICHROME_VX800 || |
| 790 | chip_name == UNICHROME_VX855) { |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 791 | fg_color = |
| 792 | ((info->cmap.red[fg_color] & 0xFFC0) << 14) | |
| 793 | ((info->cmap.green[fg_color] & 0xFFC0) << 4) | |
| 794 | ((info->cmap.blue[fg_color] & 0xFFC0) >> 6); |
| 795 | bg_color = |
| 796 | ((info->cmap.red[bg_color] & 0xFFC0) << 14) | |
| 797 | ((info->cmap.green[bg_color] & 0xFFC0) << 4) | |
| 798 | ((info->cmap.blue[bg_color] & 0xFFC0) >> 6); |
| 799 | } else { |
| 800 | fg_color = |
| 801 | ((info->cmap.red[fg_color] & 0xFF00) << 8) | |
| 802 | (info->cmap.green[fg_color] & 0xFF00) | |
| 803 | ((info->cmap.blue[fg_color] & 0xFF00) >> 8); |
| 804 | bg_color = |
| 805 | ((info->cmap.red[bg_color] & 0xFF00) << 8) | |
| 806 | (info->cmap.green[bg_color] & 0xFF00) | |
| 807 | ((info->cmap.blue[bg_color] & 0xFF00) >> 8); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 808 | } |
| 809 | |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 810 | writel(bg_color, engine + VIA_REG_CURSOR_BG); |
| 811 | writel(fg_color, engine + VIA_REG_CURSOR_FG); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 812 | } |
| 813 | |
| 814 | if (cursor->set & FB_CUR_SETSHAPE) { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 815 | struct { |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 816 | u8 data[CURSOR_SIZE]; |
| 817 | u32 bak[CURSOR_SIZE / 4]; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 818 | } *cr_data = kzalloc(sizeof(*cr_data), GFP_ATOMIC); |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 819 | int size = ((cursor->image.width + 7) >> 3) * |
| 820 | cursor->image.height; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 821 | |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 822 | if (!cr_data) |
| 823 | return -ENOMEM; |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 824 | |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 825 | if (cur_size == 32) { |
| 826 | for (i = 0; i < (CURSOR_SIZE / 4); i++) { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 827 | cr_data->bak[i] = 0x0; |
| 828 | cr_data->bak[i + 1] = 0xFFFFFFFF; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 829 | i += 1; |
| 830 | } |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 831 | } else { |
| 832 | for (i = 0; i < (CURSOR_SIZE / 4); i++) { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 833 | cr_data->bak[i] = 0x0; |
| 834 | cr_data->bak[i + 1] = 0x0; |
| 835 | cr_data->bak[i + 2] = 0xFFFFFFFF; |
| 836 | cr_data->bak[i + 3] = 0xFFFFFFFF; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 837 | i += 3; |
| 838 | } |
| 839 | } |
| 840 | |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 841 | switch (cursor->rop) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 842 | case ROP_XOR: |
| 843 | for (i = 0; i < size; i++) |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 844 | cr_data->data[i] = cursor->mask[i]; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 845 | break; |
| 846 | case ROP_COPY: |
| 847 | |
| 848 | for (i = 0; i < size; i++) |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 849 | cr_data->data[i] = cursor->mask[i]; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 850 | break; |
| 851 | default: |
| 852 | break; |
| 853 | } |
| 854 | |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 855 | if (cur_size == 32) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 856 | for (i = 0; i < size; i++) { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 857 | cr_data->bak[j] = (u32) cr_data->data[i]; |
| 858 | cr_data->bak[j + 1] = ~cr_data->bak[j]; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 859 | j += 2; |
| 860 | } |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 861 | } else { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 862 | for (i = 0; i < size; i++) { |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 863 | cr_data->bak[j] = (u32) cr_data->data[i]; |
| 864 | cr_data->bak[j + 1] = 0x0; |
| 865 | cr_data->bak[j + 2] = ~cr_data->bak[j]; |
| 866 | cr_data->bak[j + 3] = ~cr_data->bak[j + 1]; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 867 | j += 4; |
| 868 | } |
| 869 | } |
| 870 | |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 871 | memcpy_toio(viafbinfo->screen_base + viapar->shared-> |
| 872 | cursor_vram_addr, cr_data->bak, CURSOR_SIZE); |
Bruno Prémont | e687d69 | 2009-01-04 13:11:54 -0800 | [diff] [blame] | 873 | kfree(cr_data); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 874 | } |
| 875 | |
Florian Tobias Schandinat | 5016af53 | 2009-09-22 16:47:28 -0700 | [diff] [blame] | 876 | if (cursor->enable) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 877 | viafb_show_hw_cursor(info, HW_Cursor_ON); |
| 878 | |
| 879 | return 0; |
| 880 | } |
| 881 | |
| 882 | static int viafb_sync(struct fb_info *info) |
| 883 | { |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 884 | if (!(info->flags & FBINFO_HWACCEL_DISABLED)) |
| 885 | viafb_wait_engine_idle(info); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 886 | return 0; |
| 887 | } |
| 888 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 889 | static int get_primary_device(void) |
| 890 | { |
| 891 | int primary_device = 0; |
| 892 | /* Rule: device on iga1 path are the primary device. */ |
| 893 | if (viafb_SAMM_ON) { |
| 894 | if (viafb_CRT_ON) { |
| 895 | if (viaparinfo->crt_setting_info->iga_path == IGA1) { |
| 896 | DEBUG_MSG(KERN_INFO "CRT IGA Path:%d\n", |
| 897 | viaparinfo-> |
| 898 | crt_setting_info->iga_path); |
| 899 | primary_device = CRT_Device; |
| 900 | } |
| 901 | } |
| 902 | if (viafb_DVI_ON) { |
| 903 | if (viaparinfo->tmds_setting_info->iga_path == IGA1) { |
| 904 | DEBUG_MSG(KERN_INFO "DVI IGA Path:%d\n", |
| 905 | viaparinfo-> |
| 906 | tmds_setting_info->iga_path); |
| 907 | primary_device = DVI_Device; |
| 908 | } |
| 909 | } |
| 910 | if (viafb_LCD_ON) { |
| 911 | if (viaparinfo->lvds_setting_info->iga_path == IGA1) { |
| 912 | DEBUG_MSG(KERN_INFO "LCD IGA Path:%d\n", |
| 913 | viaparinfo-> |
| 914 | lvds_setting_info->iga_path); |
| 915 | primary_device = LCD_Device; |
| 916 | } |
| 917 | } |
| 918 | if (viafb_LCD2_ON) { |
| 919 | if (viaparinfo->lvds_setting_info2->iga_path == IGA1) { |
| 920 | DEBUG_MSG(KERN_INFO "LCD2 IGA Path:%d\n", |
| 921 | viaparinfo-> |
| 922 | lvds_setting_info2->iga_path); |
| 923 | primary_device = LCD2_Device; |
| 924 | } |
| 925 | } |
| 926 | } |
| 927 | return primary_device; |
| 928 | } |
| 929 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 930 | static void retrieve_device_setting(struct viafb_ioctl_setting |
| 931 | *setting_info) |
| 932 | { |
| 933 | |
| 934 | /* get device status */ |
| 935 | if (viafb_CRT_ON == 1) |
| 936 | setting_info->device_status = CRT_Device; |
| 937 | if (viafb_DVI_ON == 1) |
| 938 | setting_info->device_status |= DVI_Device; |
| 939 | if (viafb_LCD_ON == 1) |
| 940 | setting_info->device_status |= LCD_Device; |
| 941 | if (viafb_LCD2_ON == 1) |
| 942 | setting_info->device_status |= LCD2_Device; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 943 | |
| 944 | setting_info->samm_status = viafb_SAMM_ON; |
| 945 | setting_info->primary_device = get_primary_device(); |
| 946 | |
| 947 | setting_info->first_dev_bpp = viafb_bpp; |
| 948 | setting_info->second_dev_bpp = viafb_bpp1; |
| 949 | |
| 950 | setting_info->first_dev_refresh = viafb_refresh; |
| 951 | setting_info->second_dev_refresh = viafb_refresh1; |
| 952 | |
| 953 | setting_info->first_dev_hor_res = viafb_hotplug_Xres; |
| 954 | setting_info->first_dev_ver_res = viafb_hotplug_Yres; |
| 955 | setting_info->second_dev_hor_res = viafb_second_xres; |
| 956 | setting_info->second_dev_ver_res = viafb_second_yres; |
| 957 | |
| 958 | /* Get lcd attributes */ |
| 959 | setting_info->lcd_attributes.display_center = viafb_lcd_dsp_method; |
| 960 | setting_info->lcd_attributes.panel_id = viafb_lcd_panel_id; |
| 961 | setting_info->lcd_attributes.lcd_mode = viafb_lcd_mode; |
| 962 | } |
| 963 | |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 964 | static int parse_active_dev(void) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 965 | { |
| 966 | viafb_CRT_ON = STATE_OFF; |
| 967 | viafb_DVI_ON = STATE_OFF; |
| 968 | viafb_LCD_ON = STATE_OFF; |
| 969 | viafb_LCD2_ON = STATE_OFF; |
| 970 | /* 1. Modify the active status of devices. */ |
| 971 | /* 2. Keep the order of devices, so we can set corresponding |
| 972 | IGA path to devices in SAMM case. */ |
| 973 | /* Note: The previous of active_dev is primary device, |
| 974 | and the following is secondary device. */ |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 975 | if (!viafb_active_dev) { |
| 976 | viafb_CRT_ON = STATE_ON; |
| 977 | viafb_SAMM_ON = STATE_OFF; |
| 978 | } else if (!strcmp(viafb_active_dev, "CRT+DVI")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 979 | /* CRT+DVI */ |
| 980 | viafb_CRT_ON = STATE_ON; |
| 981 | viafb_DVI_ON = STATE_ON; |
| 982 | viafb_primary_dev = CRT_Device; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 983 | } else if (!strcmp(viafb_active_dev, "DVI+CRT")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 984 | /* DVI+CRT */ |
| 985 | viafb_CRT_ON = STATE_ON; |
| 986 | viafb_DVI_ON = STATE_ON; |
| 987 | viafb_primary_dev = DVI_Device; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 988 | } else if (!strcmp(viafb_active_dev, "CRT+LCD")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 989 | /* CRT+LCD */ |
| 990 | viafb_CRT_ON = STATE_ON; |
| 991 | viafb_LCD_ON = STATE_ON; |
| 992 | viafb_primary_dev = CRT_Device; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 993 | } else if (!strcmp(viafb_active_dev, "LCD+CRT")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 994 | /* LCD+CRT */ |
| 995 | viafb_CRT_ON = STATE_ON; |
| 996 | viafb_LCD_ON = STATE_ON; |
| 997 | viafb_primary_dev = LCD_Device; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 998 | } else if (!strcmp(viafb_active_dev, "DVI+LCD")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 999 | /* DVI+LCD */ |
| 1000 | viafb_DVI_ON = STATE_ON; |
| 1001 | viafb_LCD_ON = STATE_ON; |
| 1002 | viafb_primary_dev = DVI_Device; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1003 | } else if (!strcmp(viafb_active_dev, "LCD+DVI")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1004 | /* LCD+DVI */ |
| 1005 | viafb_DVI_ON = STATE_ON; |
| 1006 | viafb_LCD_ON = STATE_ON; |
| 1007 | viafb_primary_dev = LCD_Device; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1008 | } else if (!strcmp(viafb_active_dev, "LCD+LCD2")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1009 | viafb_LCD_ON = STATE_ON; |
| 1010 | viafb_LCD2_ON = STATE_ON; |
| 1011 | viafb_primary_dev = LCD_Device; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1012 | } else if (!strcmp(viafb_active_dev, "LCD2+LCD")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1013 | viafb_LCD_ON = STATE_ON; |
| 1014 | viafb_LCD2_ON = STATE_ON; |
| 1015 | viafb_primary_dev = LCD2_Device; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1016 | } else if (!strcmp(viafb_active_dev, "CRT")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1017 | /* CRT only */ |
| 1018 | viafb_CRT_ON = STATE_ON; |
| 1019 | viafb_SAMM_ON = STATE_OFF; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1020 | } else if (!strcmp(viafb_active_dev, "DVI")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1021 | /* DVI only */ |
| 1022 | viafb_DVI_ON = STATE_ON; |
| 1023 | viafb_SAMM_ON = STATE_OFF; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1024 | } else if (!strcmp(viafb_active_dev, "LCD")) { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1025 | /* LCD only */ |
| 1026 | viafb_LCD_ON = STATE_ON; |
| 1027 | viafb_SAMM_ON = STATE_OFF; |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1028 | } else |
| 1029 | return -EINVAL; |
| 1030 | |
| 1031 | return 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1032 | } |
| 1033 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1034 | static int parse_port(char *opt_str, int *output_interface) |
| 1035 | { |
| 1036 | if (!strncmp(opt_str, "DVP0", 4)) |
| 1037 | *output_interface = INTERFACE_DVP0; |
| 1038 | else if (!strncmp(opt_str, "DVP1", 4)) |
| 1039 | *output_interface = INTERFACE_DVP1; |
| 1040 | else if (!strncmp(opt_str, "DFP_HIGHLOW", 11)) |
| 1041 | *output_interface = INTERFACE_DFP; |
| 1042 | else if (!strncmp(opt_str, "DFP_HIGH", 8)) |
| 1043 | *output_interface = INTERFACE_DFP_HIGH; |
| 1044 | else if (!strncmp(opt_str, "DFP_LOW", 7)) |
| 1045 | *output_interface = INTERFACE_DFP_LOW; |
| 1046 | else |
| 1047 | *output_interface = INTERFACE_NONE; |
| 1048 | return 0; |
| 1049 | } |
| 1050 | |
| 1051 | static void parse_lcd_port(void) |
| 1052 | { |
| 1053 | parse_port(viafb_lcd_port, &viaparinfo->chip_info->lvds_chip_info. |
| 1054 | output_interface); |
| 1055 | /*Initialize to avoid unexpected behavior */ |
| 1056 | viaparinfo->chip_info->lvds_chip_info2.output_interface = |
| 1057 | INTERFACE_NONE; |
| 1058 | |
| 1059 | DEBUG_MSG(KERN_INFO "parse_lcd_port: viafb_lcd_port:%s,interface:%d\n", |
| 1060 | viafb_lcd_port, viaparinfo->chip_info->lvds_chip_info. |
| 1061 | output_interface); |
| 1062 | } |
| 1063 | |
| 1064 | static void parse_dvi_port(void) |
| 1065 | { |
| 1066 | parse_port(viafb_dvi_port, &viaparinfo->chip_info->tmds_chip_info. |
| 1067 | output_interface); |
| 1068 | |
| 1069 | DEBUG_MSG(KERN_INFO "parse_dvi_port: viafb_dvi_port:%s,interface:%d\n", |
| 1070 | viafb_dvi_port, viaparinfo->chip_info->tmds_chip_info. |
| 1071 | output_interface); |
| 1072 | } |
| 1073 | |
Florian Tobias Schandinat | 2b78a96 | 2010-04-17 19:44:57 +0000 | [diff] [blame] | 1074 | #ifdef CONFIG_FB_VIA_DIRECT_PROCFS |
| 1075 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1076 | /* |
| 1077 | * The proc filesystem read/write function, a simple proc implement to |
| 1078 | * get/set the value of DPA DVP0, DVP0DataDriving, DVP0ClockDriving, DVP1, |
| 1079 | * DVP1Driving, DFPHigh, DFPLow CR96, SR2A[5], SR1B[1], SR2A[4], SR1E[2], |
| 1080 | * CR9B, SR65, CR97, CR99 |
| 1081 | */ |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1082 | static int viafb_dvp0_proc_show(struct seq_file *m, void *v) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1083 | { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1084 | u8 dvp0_data_dri = 0, dvp0_clk_dri = 0, dvp0 = 0; |
| 1085 | dvp0_data_dri = |
| 1086 | (viafb_read_reg(VIASR, SR2A) & BIT5) >> 4 | |
| 1087 | (viafb_read_reg(VIASR, SR1B) & BIT1) >> 1; |
| 1088 | dvp0_clk_dri = |
| 1089 | (viafb_read_reg(VIASR, SR2A) & BIT4) >> 3 | |
| 1090 | (viafb_read_reg(VIASR, SR1E) & BIT2) >> 2; |
| 1091 | dvp0 = viafb_read_reg(VIACR, CR96) & 0x0f; |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1092 | seq_printf(m, "%x %x %x\n", dvp0, dvp0_data_dri, dvp0_clk_dri); |
| 1093 | return 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1094 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1095 | |
| 1096 | static int viafb_dvp0_proc_open(struct inode *inode, struct file *file) |
| 1097 | { |
| 1098 | return single_open(file, viafb_dvp0_proc_show, NULL); |
| 1099 | } |
| 1100 | |
| 1101 | static ssize_t viafb_dvp0_proc_write(struct file *file, |
| 1102 | const char __user *buffer, size_t count, loff_t *pos) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1103 | { |
| 1104 | char buf[20], *value, *pbuf; |
| 1105 | u8 reg_val = 0; |
| 1106 | unsigned long length, i; |
| 1107 | if (count < 1) |
| 1108 | return -EINVAL; |
| 1109 | length = count > 20 ? 20 : count; |
| 1110 | if (copy_from_user(&buf[0], buffer, length)) |
| 1111 | return -EFAULT; |
| 1112 | buf[length - 1] = '\0'; /*Ensure end string */ |
| 1113 | pbuf = &buf[0]; |
| 1114 | for (i = 0; i < 3; i++) { |
| 1115 | value = strsep(&pbuf, " "); |
| 1116 | if (value != NULL) { |
| 1117 | strict_strtoul(value, 0, (unsigned long *)®_val); |
| 1118 | DEBUG_MSG(KERN_INFO "DVP0:reg_val[%l]=:%x\n", i, |
| 1119 | reg_val); |
| 1120 | switch (i) { |
| 1121 | case 0: |
| 1122 | viafb_write_reg_mask(CR96, VIACR, |
| 1123 | reg_val, 0x0f); |
| 1124 | break; |
| 1125 | case 1: |
| 1126 | viafb_write_reg_mask(SR2A, VIASR, |
| 1127 | reg_val << 4, BIT5); |
| 1128 | viafb_write_reg_mask(SR1B, VIASR, |
| 1129 | reg_val << 1, BIT1); |
| 1130 | break; |
| 1131 | case 2: |
| 1132 | viafb_write_reg_mask(SR2A, VIASR, |
| 1133 | reg_val << 3, BIT4); |
| 1134 | viafb_write_reg_mask(SR1E, VIASR, |
| 1135 | reg_val << 2, BIT2); |
| 1136 | break; |
| 1137 | default: |
| 1138 | break; |
| 1139 | } |
| 1140 | } else { |
| 1141 | break; |
| 1142 | } |
| 1143 | } |
| 1144 | return count; |
| 1145 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1146 | |
| 1147 | static const struct file_operations viafb_dvp0_proc_fops = { |
| 1148 | .owner = THIS_MODULE, |
| 1149 | .open = viafb_dvp0_proc_open, |
| 1150 | .read = seq_read, |
| 1151 | .llseek = seq_lseek, |
| 1152 | .release = single_release, |
| 1153 | .write = viafb_dvp0_proc_write, |
| 1154 | }; |
| 1155 | |
| 1156 | static int viafb_dvp1_proc_show(struct seq_file *m, void *v) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1157 | { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1158 | u8 dvp1 = 0, dvp1_data_dri = 0, dvp1_clk_dri = 0; |
| 1159 | dvp1 = viafb_read_reg(VIACR, CR9B) & 0x0f; |
| 1160 | dvp1_data_dri = (viafb_read_reg(VIASR, SR65) & 0x0c) >> 2; |
| 1161 | dvp1_clk_dri = viafb_read_reg(VIASR, SR65) & 0x03; |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1162 | seq_printf(m, "%x %x %x\n", dvp1, dvp1_data_dri, dvp1_clk_dri); |
| 1163 | return 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1164 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1165 | |
| 1166 | static int viafb_dvp1_proc_open(struct inode *inode, struct file *file) |
| 1167 | { |
| 1168 | return single_open(file, viafb_dvp1_proc_show, NULL); |
| 1169 | } |
| 1170 | |
| 1171 | static ssize_t viafb_dvp1_proc_write(struct file *file, |
| 1172 | const char __user *buffer, size_t count, loff_t *pos) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1173 | { |
| 1174 | char buf[20], *value, *pbuf; |
| 1175 | u8 reg_val = 0; |
| 1176 | unsigned long length, i; |
| 1177 | if (count < 1) |
| 1178 | return -EINVAL; |
| 1179 | length = count > 20 ? 20 : count; |
| 1180 | if (copy_from_user(&buf[0], buffer, length)) |
| 1181 | return -EFAULT; |
| 1182 | buf[length - 1] = '\0'; /*Ensure end string */ |
| 1183 | pbuf = &buf[0]; |
| 1184 | for (i = 0; i < 3; i++) { |
| 1185 | value = strsep(&pbuf, " "); |
| 1186 | if (value != NULL) { |
| 1187 | strict_strtoul(value, 0, (unsigned long *)®_val); |
| 1188 | switch (i) { |
| 1189 | case 0: |
| 1190 | viafb_write_reg_mask(CR9B, VIACR, |
| 1191 | reg_val, 0x0f); |
| 1192 | break; |
| 1193 | case 1: |
| 1194 | viafb_write_reg_mask(SR65, VIASR, |
| 1195 | reg_val << 2, 0x0c); |
| 1196 | break; |
| 1197 | case 2: |
| 1198 | viafb_write_reg_mask(SR65, VIASR, |
| 1199 | reg_val, 0x03); |
| 1200 | break; |
| 1201 | default: |
| 1202 | break; |
| 1203 | } |
| 1204 | } else { |
| 1205 | break; |
| 1206 | } |
| 1207 | } |
| 1208 | return count; |
| 1209 | } |
| 1210 | |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1211 | static const struct file_operations viafb_dvp1_proc_fops = { |
| 1212 | .owner = THIS_MODULE, |
| 1213 | .open = viafb_dvp1_proc_open, |
| 1214 | .read = seq_read, |
| 1215 | .llseek = seq_lseek, |
| 1216 | .release = single_release, |
| 1217 | .write = viafb_dvp1_proc_write, |
| 1218 | }; |
| 1219 | |
| 1220 | static int viafb_dfph_proc_show(struct seq_file *m, void *v) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1221 | { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1222 | u8 dfp_high = 0; |
| 1223 | dfp_high = viafb_read_reg(VIACR, CR97) & 0x0f; |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1224 | seq_printf(m, "%x\n", dfp_high); |
| 1225 | return 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1226 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1227 | |
| 1228 | static int viafb_dfph_proc_open(struct inode *inode, struct file *file) |
| 1229 | { |
| 1230 | return single_open(file, viafb_dfph_proc_show, NULL); |
| 1231 | } |
| 1232 | |
| 1233 | static ssize_t viafb_dfph_proc_write(struct file *file, |
| 1234 | const char __user *buffer, size_t count, loff_t *pos) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1235 | { |
| 1236 | char buf[20]; |
| 1237 | u8 reg_val = 0; |
| 1238 | unsigned long length; |
| 1239 | if (count < 1) |
| 1240 | return -EINVAL; |
| 1241 | length = count > 20 ? 20 : count; |
| 1242 | if (copy_from_user(&buf[0], buffer, length)) |
| 1243 | return -EFAULT; |
| 1244 | buf[length - 1] = '\0'; /*Ensure end string */ |
| 1245 | strict_strtoul(&buf[0], 0, (unsigned long *)®_val); |
| 1246 | viafb_write_reg_mask(CR97, VIACR, reg_val, 0x0f); |
| 1247 | return count; |
| 1248 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1249 | |
| 1250 | static const struct file_operations viafb_dfph_proc_fops = { |
| 1251 | .owner = THIS_MODULE, |
| 1252 | .open = viafb_dfph_proc_open, |
| 1253 | .read = seq_read, |
| 1254 | .llseek = seq_lseek, |
| 1255 | .release = single_release, |
| 1256 | .write = viafb_dfph_proc_write, |
| 1257 | }; |
| 1258 | |
| 1259 | static int viafb_dfpl_proc_show(struct seq_file *m, void *v) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1260 | { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1261 | u8 dfp_low = 0; |
| 1262 | dfp_low = viafb_read_reg(VIACR, CR99) & 0x0f; |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1263 | seq_printf(m, "%x\n", dfp_low); |
| 1264 | return 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1265 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1266 | |
| 1267 | static int viafb_dfpl_proc_open(struct inode *inode, struct file *file) |
| 1268 | { |
| 1269 | return single_open(file, viafb_dfpl_proc_show, NULL); |
| 1270 | } |
| 1271 | |
| 1272 | static ssize_t viafb_dfpl_proc_write(struct file *file, |
| 1273 | const char __user *buffer, size_t count, loff_t *pos) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1274 | { |
| 1275 | char buf[20]; |
| 1276 | u8 reg_val = 0; |
| 1277 | unsigned long length; |
| 1278 | if (count < 1) |
| 1279 | return -EINVAL; |
| 1280 | length = count > 20 ? 20 : count; |
| 1281 | if (copy_from_user(&buf[0], buffer, length)) |
| 1282 | return -EFAULT; |
| 1283 | buf[length - 1] = '\0'; /*Ensure end string */ |
| 1284 | strict_strtoul(&buf[0], 0, (unsigned long *)®_val); |
| 1285 | viafb_write_reg_mask(CR99, VIACR, reg_val, 0x0f); |
| 1286 | return count; |
| 1287 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1288 | |
| 1289 | static const struct file_operations viafb_dfpl_proc_fops = { |
| 1290 | .owner = THIS_MODULE, |
| 1291 | .open = viafb_dfpl_proc_open, |
| 1292 | .read = seq_read, |
| 1293 | .llseek = seq_lseek, |
| 1294 | .release = single_release, |
| 1295 | .write = viafb_dfpl_proc_write, |
| 1296 | }; |
| 1297 | |
| 1298 | static int viafb_vt1636_proc_show(struct seq_file *m, void *v) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1299 | { |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1300 | u8 vt1636_08 = 0, vt1636_09 = 0; |
| 1301 | switch (viaparinfo->chip_info->lvds_chip_info.lvds_chip_name) { |
| 1302 | case VT1636_LVDS: |
| 1303 | vt1636_08 = |
| 1304 | viafb_gpio_i2c_read_lvds(viaparinfo->lvds_setting_info, |
| 1305 | &viaparinfo->chip_info->lvds_chip_info, 0x08) & 0x0f; |
| 1306 | vt1636_09 = |
| 1307 | viafb_gpio_i2c_read_lvds(viaparinfo->lvds_setting_info, |
| 1308 | &viaparinfo->chip_info->lvds_chip_info, 0x09) & 0x1f; |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1309 | seq_printf(m, "%x %x\n", vt1636_08, vt1636_09); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1310 | break; |
| 1311 | default: |
| 1312 | break; |
| 1313 | } |
| 1314 | switch (viaparinfo->chip_info->lvds_chip_info2.lvds_chip_name) { |
| 1315 | case VT1636_LVDS: |
| 1316 | vt1636_08 = |
| 1317 | viafb_gpio_i2c_read_lvds(viaparinfo->lvds_setting_info2, |
| 1318 | &viaparinfo->chip_info->lvds_chip_info2, 0x08) & 0x0f; |
| 1319 | vt1636_09 = |
| 1320 | viafb_gpio_i2c_read_lvds(viaparinfo->lvds_setting_info2, |
| 1321 | &viaparinfo->chip_info->lvds_chip_info2, 0x09) & 0x1f; |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1322 | seq_printf(m, " %x %x\n", vt1636_08, vt1636_09); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1323 | break; |
| 1324 | default: |
| 1325 | break; |
| 1326 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1327 | return 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1328 | } |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1329 | |
| 1330 | static int viafb_vt1636_proc_open(struct inode *inode, struct file *file) |
| 1331 | { |
| 1332 | return single_open(file, viafb_vt1636_proc_show, NULL); |
| 1333 | } |
| 1334 | |
| 1335 | static ssize_t viafb_vt1636_proc_write(struct file *file, |
| 1336 | const char __user *buffer, size_t count, loff_t *pos) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1337 | { |
| 1338 | char buf[30], *value, *pbuf; |
| 1339 | struct IODATA reg_val; |
| 1340 | unsigned long length, i; |
| 1341 | if (count < 1) |
| 1342 | return -EINVAL; |
| 1343 | length = count > 30 ? 30 : count; |
| 1344 | if (copy_from_user(&buf[0], buffer, length)) |
| 1345 | return -EFAULT; |
| 1346 | buf[length - 1] = '\0'; /*Ensure end string */ |
| 1347 | pbuf = &buf[0]; |
| 1348 | switch (viaparinfo->chip_info->lvds_chip_info.lvds_chip_name) { |
| 1349 | case VT1636_LVDS: |
| 1350 | for (i = 0; i < 2; i++) { |
| 1351 | value = strsep(&pbuf, " "); |
| 1352 | if (value != NULL) { |
| 1353 | strict_strtoul(value, 0, |
| 1354 | (unsigned long *)®_val.Data); |
| 1355 | switch (i) { |
| 1356 | case 0: |
| 1357 | reg_val.Index = 0x08; |
| 1358 | reg_val.Mask = 0x0f; |
| 1359 | viafb_gpio_i2c_write_mask_lvds |
| 1360 | (viaparinfo->lvds_setting_info, |
| 1361 | &viaparinfo-> |
| 1362 | chip_info->lvds_chip_info, |
| 1363 | reg_val); |
| 1364 | break; |
| 1365 | case 1: |
| 1366 | reg_val.Index = 0x09; |
| 1367 | reg_val.Mask = 0x1f; |
| 1368 | viafb_gpio_i2c_write_mask_lvds |
| 1369 | (viaparinfo->lvds_setting_info, |
| 1370 | &viaparinfo-> |
| 1371 | chip_info->lvds_chip_info, |
| 1372 | reg_val); |
| 1373 | break; |
| 1374 | default: |
| 1375 | break; |
| 1376 | } |
| 1377 | } else { |
| 1378 | break; |
| 1379 | } |
| 1380 | } |
| 1381 | break; |
| 1382 | default: |
| 1383 | break; |
| 1384 | } |
| 1385 | switch (viaparinfo->chip_info->lvds_chip_info2.lvds_chip_name) { |
| 1386 | case VT1636_LVDS: |
| 1387 | for (i = 0; i < 2; i++) { |
| 1388 | value = strsep(&pbuf, " "); |
| 1389 | if (value != NULL) { |
| 1390 | strict_strtoul(value, 0, |
| 1391 | (unsigned long *)®_val.Data); |
| 1392 | switch (i) { |
| 1393 | case 0: |
| 1394 | reg_val.Index = 0x08; |
| 1395 | reg_val.Mask = 0x0f; |
| 1396 | viafb_gpio_i2c_write_mask_lvds |
| 1397 | (viaparinfo->lvds_setting_info2, |
| 1398 | &viaparinfo-> |
| 1399 | chip_info->lvds_chip_info2, |
| 1400 | reg_val); |
| 1401 | break; |
| 1402 | case 1: |
| 1403 | reg_val.Index = 0x09; |
| 1404 | reg_val.Mask = 0x1f; |
| 1405 | viafb_gpio_i2c_write_mask_lvds |
| 1406 | (viaparinfo->lvds_setting_info2, |
| 1407 | &viaparinfo-> |
| 1408 | chip_info->lvds_chip_info2, |
| 1409 | reg_val); |
| 1410 | break; |
| 1411 | default: |
| 1412 | break; |
| 1413 | } |
| 1414 | } else { |
| 1415 | break; |
| 1416 | } |
| 1417 | } |
| 1418 | break; |
| 1419 | default: |
| 1420 | break; |
| 1421 | } |
| 1422 | return count; |
| 1423 | } |
| 1424 | |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1425 | static const struct file_operations viafb_vt1636_proc_fops = { |
| 1426 | .owner = THIS_MODULE, |
| 1427 | .open = viafb_vt1636_proc_open, |
| 1428 | .read = seq_read, |
| 1429 | .llseek = seq_lseek, |
| 1430 | .release = single_release, |
| 1431 | .write = viafb_vt1636_proc_write, |
| 1432 | }; |
| 1433 | |
Bruno Prémont | c267fd7 | 2008-11-19 15:36:23 -0800 | [diff] [blame] | 1434 | static void viafb_init_proc(struct proc_dir_entry **viafb_entry) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1435 | { |
Bruno Prémont | c267fd7 | 2008-11-19 15:36:23 -0800 | [diff] [blame] | 1436 | *viafb_entry = proc_mkdir("viafb", NULL); |
Dan Carpenter | 8130b3b | 2009-12-15 16:46:36 -0800 | [diff] [blame] | 1437 | if (*viafb_entry) { |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1438 | proc_create("dvp0", 0, *viafb_entry, &viafb_dvp0_proc_fops); |
| 1439 | proc_create("dvp1", 0, *viafb_entry, &viafb_dvp1_proc_fops); |
| 1440 | proc_create("dfph", 0, *viafb_entry, &viafb_dfph_proc_fops); |
| 1441 | proc_create("dfpl", 0, *viafb_entry, &viafb_dfpl_proc_fops); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1442 | if (VT1636_LVDS == viaparinfo->chip_info->lvds_chip_info. |
| 1443 | lvds_chip_name || VT1636_LVDS == |
| 1444 | viaparinfo->chip_info->lvds_chip_info2.lvds_chip_name) { |
Alexey Dobriyan | afbd3c1 | 2009-09-22 16:47:27 -0700 | [diff] [blame] | 1445 | proc_create("vt1636", 0, *viafb_entry, &viafb_vt1636_proc_fops); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1446 | } |
| 1447 | |
| 1448 | } |
| 1449 | } |
| 1450 | static void viafb_remove_proc(struct proc_dir_entry *viafb_entry) |
| 1451 | { |
Florian Tobias Schandinat | 2fed547 | 2010-04-17 19:44:56 +0000 | [diff] [blame] | 1452 | struct chip_information *chip_info = &viaparinfo->shared->chip_info; |
| 1453 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1454 | remove_proc_entry("dvp0", viafb_entry);/* parent dir */ |
| 1455 | remove_proc_entry("dvp1", viafb_entry); |
| 1456 | remove_proc_entry("dfph", viafb_entry); |
| 1457 | remove_proc_entry("dfpl", viafb_entry); |
Florian Tobias Schandinat | 2fed547 | 2010-04-17 19:44:56 +0000 | [diff] [blame] | 1458 | if (chip_info->lvds_chip_info.lvds_chip_name == VT1636_LVDS |
| 1459 | || chip_info->lvds_chip_info2.lvds_chip_name == VT1636_LVDS) |
| 1460 | remove_proc_entry("vt1636", viafb_entry); |
| 1461 | |
Bruno Prémont | c267fd7 | 2008-11-19 15:36:23 -0800 | [diff] [blame] | 1462 | remove_proc_entry("viafb", NULL); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1463 | } |
| 1464 | |
Florian Tobias Schandinat | 2b78a96 | 2010-04-17 19:44:57 +0000 | [diff] [blame] | 1465 | #endif /* CONFIG_FB_VIA_DIRECT_PROCFS */ |
| 1466 | |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1467 | static int parse_mode(const char *str, u32 *xres, u32 *yres) |
Florian Tobias Schandinat | 5ff32f6 | 2009-09-22 16:47:34 -0700 | [diff] [blame] | 1468 | { |
| 1469 | char *ptr; |
| 1470 | |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1471 | if (!str) { |
| 1472 | *xres = 640; |
| 1473 | *yres = 480; |
| 1474 | return 0; |
| 1475 | } |
| 1476 | |
Florian Tobias Schandinat | 5ff32f6 | 2009-09-22 16:47:34 -0700 | [diff] [blame] | 1477 | *xres = simple_strtoul(str, &ptr, 10); |
| 1478 | if (ptr[0] != 'x') |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1479 | return -EINVAL; |
Florian Tobias Schandinat | 5ff32f6 | 2009-09-22 16:47:34 -0700 | [diff] [blame] | 1480 | |
| 1481 | *yres = simple_strtoul(&ptr[1], &ptr, 10); |
| 1482 | if (ptr[0]) |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1483 | return -EINVAL; |
Florian Tobias Schandinat | 5ff32f6 | 2009-09-22 16:47:34 -0700 | [diff] [blame] | 1484 | |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1485 | return 0; |
Florian Tobias Schandinat | 5ff32f6 | 2009-09-22 16:47:34 -0700 | [diff] [blame] | 1486 | } |
| 1487 | |
Jonathan Corbet | f045f77 | 2009-12-01 20:29:39 -0700 | [diff] [blame] | 1488 | |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 1489 | int __devinit via_fb_pci_probe(struct viafb_dev *vdev) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1490 | { |
Florian Tobias Schandinat | 5ff32f6 | 2009-09-22 16:47:34 -0700 | [diff] [blame] | 1491 | u32 default_xres, default_yres; |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 1492 | struct VideoModeTable *vmode_entry; |
Florian Tobias Schandinat | dba77f8 | 2010-03-10 15:21:37 -0800 | [diff] [blame] | 1493 | struct fb_var_screeninfo default_var; |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1494 | int rc; |
Florian Tobias Schandinat | c4df548 | 2009-09-22 16:47:24 -0700 | [diff] [blame] | 1495 | u32 viafb_par_length; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1496 | |
| 1497 | DEBUG_MSG(KERN_INFO "VIAFB PCI Probe!!\n"); |
Florian Tobias Schandinat | dba77f8 | 2010-03-10 15:21:37 -0800 | [diff] [blame] | 1498 | memset(&default_var, 0, sizeof(default_var)); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1499 | viafb_par_length = ALIGN(sizeof(struct viafb_par), BITS_PER_LONG/8); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1500 | |
| 1501 | /* Allocate fb_info and ***_par here, also including some other needed |
| 1502 | * variables |
| 1503 | */ |
Florian Tobias Schandinat | c4df548 | 2009-09-22 16:47:24 -0700 | [diff] [blame] | 1504 | viafbinfo = framebuffer_alloc(viafb_par_length + |
Harald Welte | db8df7b | 2009-09-22 16:47:38 -0700 | [diff] [blame] | 1505 | ALIGN(sizeof(struct viafb_shared), BITS_PER_LONG/8), |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 1506 | &vdev->pdev->dev); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1507 | if (!viafbinfo) { |
| 1508 | printk(KERN_ERR"Could not allocate memory for viafb_info.\n"); |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1509 | return -ENOMEM; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1510 | } |
| 1511 | |
| 1512 | viaparinfo = (struct viafb_par *)viafbinfo->par; |
Florian Tobias Schandinat | c4df548 | 2009-09-22 16:47:24 -0700 | [diff] [blame] | 1513 | viaparinfo->shared = viafbinfo->par + viafb_par_length; |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 1514 | viaparinfo->shared->vdev = vdev; |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 1515 | viaparinfo->vram_addr = 0; |
Florian Tobias Schandinat | c4df548 | 2009-09-22 16:47:24 -0700 | [diff] [blame] | 1516 | viaparinfo->tmds_setting_info = &viaparinfo->shared->tmds_setting_info; |
| 1517 | viaparinfo->lvds_setting_info = &viaparinfo->shared->lvds_setting_info; |
| 1518 | viaparinfo->lvds_setting_info2 = |
| 1519 | &viaparinfo->shared->lvds_setting_info2; |
| 1520 | viaparinfo->crt_setting_info = &viaparinfo->shared->crt_setting_info; |
| 1521 | viaparinfo->chip_info = &viaparinfo->shared->chip_info; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1522 | |
| 1523 | if (viafb_dual_fb) |
| 1524 | viafb_SAMM_ON = 1; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1525 | parse_lcd_port(); |
| 1526 | parse_dvi_port(); |
| 1527 | |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 1528 | viafb_init_chip_info(vdev->chip_type); |
| 1529 | /* |
| 1530 | * The framebuffer will have been successfully mapped by |
| 1531 | * the core (or we'd not be here), but we still need to |
| 1532 | * set up our own accounting. |
| 1533 | */ |
| 1534 | viaparinfo->fbmem = vdev->fbmem_start; |
| 1535 | viaparinfo->memsize = vdev->fbmem_len; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1536 | viaparinfo->fbmem_free = viaparinfo->memsize; |
| 1537 | viaparinfo->fbmem_used = 0; |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 1538 | viafbinfo->screen_base = vdev->fbmem; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1539 | |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 1540 | viafbinfo->fix.mmio_start = vdev->engine_start; |
| 1541 | viafbinfo->fix.mmio_len = vdev->engine_len; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1542 | viafbinfo->node = 0; |
| 1543 | viafbinfo->fbops = &viafb_ops; |
| 1544 | viafbinfo->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN; |
| 1545 | |
| 1546 | viafbinfo->pseudo_palette = pseudo_pal; |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 1547 | if (viafb_accel && !viafb_init_engine(viafbinfo)) { |
| 1548 | viafbinfo->flags |= FBINFO_HWACCEL_COPYAREA | |
| 1549 | FBINFO_HWACCEL_FILLRECT | FBINFO_HWACCEL_IMAGEBLIT; |
| 1550 | default_var.accel_flags = FB_ACCELF_TEXT; |
| 1551 | } else { |
| 1552 | viafbinfo->flags |= FBINFO_HWACCEL_DISABLED; |
| 1553 | default_var.accel_flags = 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1554 | } |
| 1555 | |
| 1556 | if (viafb_second_size && (viafb_second_size < 8)) { |
| 1557 | viafb_second_offset = viaparinfo->fbmem_free - |
| 1558 | viafb_second_size * 1024 * 1024; |
| 1559 | } else { |
| 1560 | viafb_second_size = 8; |
| 1561 | viafb_second_offset = viaparinfo->fbmem_free - |
| 1562 | viafb_second_size * 1024 * 1024; |
| 1563 | } |
| 1564 | |
Florian Tobias Schandinat | 5ff32f6 | 2009-09-22 16:47:34 -0700 | [diff] [blame] | 1565 | parse_mode(viafb_mode, &default_xres, &default_yres); |
Florian Tobias Schandinat | dd73d68 | 2010-03-10 15:21:28 -0800 | [diff] [blame] | 1566 | vmode_entry = viafb_get_mode(default_xres, default_yres); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1567 | if (viafb_SAMM_ON == 1) { |
Florian Tobias Schandinat | 5ff32f6 | 2009-09-22 16:47:34 -0700 | [diff] [blame] | 1568 | parse_mode(viafb_mode1, &viafb_second_xres, |
| 1569 | &viafb_second_yres); |
| 1570 | |
Florian Tobias Schandinat | cd58995 | 2010-07-13 19:44:05 +0000 | [diff] [blame] | 1571 | viafb_second_virtual_xres = viafb_second_xres; |
| 1572 | viafb_second_virtual_yres = viafb_second_yres; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1573 | } |
| 1574 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1575 | default_var.xres = default_xres; |
| 1576 | default_var.yres = default_yres; |
Florian Tobias Schandinat | cd58995 | 2010-07-13 19:44:05 +0000 | [diff] [blame] | 1577 | default_var.xres_virtual = default_xres; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1578 | default_var.yres_virtual = default_yres; |
| 1579 | default_var.bits_per_pixel = viafb_bpp; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1580 | default_var.pixclock = |
| 1581 | viafb_get_pixclock(default_xres, default_yres, viafb_refresh); |
| 1582 | default_var.left_margin = (default_xres >> 3) & 0xf8; |
| 1583 | default_var.right_margin = 32; |
| 1584 | default_var.upper_margin = 16; |
| 1585 | default_var.lower_margin = 4; |
| 1586 | default_var.hsync_len = default_var.left_margin; |
| 1587 | default_var.vsync_len = 4; |
Florian Tobias Schandinat | 7cf6079 | 2010-03-10 15:21:31 -0800 | [diff] [blame] | 1588 | viafb_setup_fixinfo(&viafbinfo->fix, viaparinfo); |
Florian Tobias Schandinat | 7cf6079 | 2010-03-10 15:21:31 -0800 | [diff] [blame] | 1589 | viafbinfo->var = default_var; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1590 | |
| 1591 | if (viafb_dual_fb) { |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 1592 | viafbinfo1 = framebuffer_alloc(viafb_par_length, |
| 1593 | &vdev->pdev->dev); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1594 | if (!viafbinfo1) { |
| 1595 | printk(KERN_ERR |
| 1596 | "allocate the second framebuffer struct error\n"); |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1597 | rc = -ENOMEM; |
Jonathan Corbet | 24b4d82 | 2010-04-22 13:48:09 -0600 | [diff] [blame] | 1598 | goto out_fb_release; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1599 | } |
| 1600 | viaparinfo1 = viafbinfo1->par; |
| 1601 | memcpy(viaparinfo1, viaparinfo, viafb_par_length); |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 1602 | viaparinfo1->vram_addr = viafb_second_offset; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1603 | viaparinfo1->memsize = viaparinfo->memsize - |
| 1604 | viafb_second_offset; |
| 1605 | viaparinfo->memsize = viafb_second_offset; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1606 | viaparinfo1->fbmem = viaparinfo->fbmem + viafb_second_offset; |
| 1607 | |
| 1608 | viaparinfo1->fbmem_used = viaparinfo->fbmem_used; |
| 1609 | viaparinfo1->fbmem_free = viaparinfo1->memsize - |
| 1610 | viaparinfo1->fbmem_used; |
| 1611 | viaparinfo->fbmem_free = viaparinfo->memsize; |
| 1612 | viaparinfo->fbmem_used = 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1613 | |
Florian Tobias Schandinat | 09cf118 | 2009-09-22 16:47:14 -0700 | [diff] [blame] | 1614 | viaparinfo->iga_path = IGA1; |
| 1615 | viaparinfo1->iga_path = IGA2; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1616 | memcpy(viafbinfo1, viafbinfo, sizeof(struct fb_info)); |
Florian Tobias Schandinat | c4df548 | 2009-09-22 16:47:24 -0700 | [diff] [blame] | 1617 | viafbinfo1->par = viaparinfo1; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1618 | viafbinfo1->screen_base = viafbinfo->screen_base + |
| 1619 | viafb_second_offset; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1620 | |
| 1621 | default_var.xres = viafb_second_xres; |
| 1622 | default_var.yres = viafb_second_yres; |
| 1623 | default_var.xres_virtual = viafb_second_virtual_xres; |
| 1624 | default_var.yres_virtual = viafb_second_virtual_yres; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1625 | default_var.bits_per_pixel = viafb_bpp1; |
| 1626 | default_var.pixclock = |
| 1627 | viafb_get_pixclock(viafb_second_xres, viafb_second_yres, |
| 1628 | viafb_refresh); |
| 1629 | default_var.left_margin = (viafb_second_xres >> 3) & 0xf8; |
| 1630 | default_var.right_margin = 32; |
| 1631 | default_var.upper_margin = 16; |
| 1632 | default_var.lower_margin = 4; |
| 1633 | default_var.hsync_len = default_var.left_margin; |
| 1634 | default_var.vsync_len = 4; |
| 1635 | |
| 1636 | viafb_setup_fixinfo(&viafbinfo1->fix, viaparinfo1); |
| 1637 | viafb_check_var(&default_var, viafbinfo1); |
| 1638 | viafbinfo1->var = default_var; |
Florian Tobias Schandinat | 81228a3 | 2009-09-22 16:47:13 -0700 | [diff] [blame] | 1639 | viafb_update_fix(viafbinfo1); |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 1640 | viaparinfo1->depth = fb_get_color_depth(&viafbinfo1->var, |
| 1641 | &viafbinfo1->fix); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1642 | } |
| 1643 | |
Florian Tobias Schandinat | e17cea3 | 2010-03-10 15:21:41 -0800 | [diff] [blame] | 1644 | viafb_check_var(&viafbinfo->var, viafbinfo); |
Florian Tobias Schandinat | 81228a3 | 2009-09-22 16:47:13 -0700 | [diff] [blame] | 1645 | viafb_update_fix(viafbinfo); |
Florian Tobias Schandinat | c3e2567 | 2009-09-22 16:47:26 -0700 | [diff] [blame] | 1646 | viaparinfo->depth = fb_get_color_depth(&viafbinfo->var, |
| 1647 | &viafbinfo->fix); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1648 | default_var.activate = FB_ACTIVATE_NOW; |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1649 | rc = fb_alloc_cmap(&viafbinfo->cmap, 256, 0); |
| 1650 | if (rc) |
| 1651 | goto out_fb1_release; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1652 | |
| 1653 | if (viafb_dual_fb && (viafb_primary_dev == LCD_Device) |
| 1654 | && (viaparinfo->chip_info->gfx_chip_name == UNICHROME_CLE266)) { |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1655 | rc = register_framebuffer(viafbinfo1); |
| 1656 | if (rc) |
| 1657 | goto out_dealloc_cmap; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1658 | } |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1659 | rc = register_framebuffer(viafbinfo); |
| 1660 | if (rc) |
| 1661 | goto out_fb1_unreg_lcd_cle266; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1662 | |
| 1663 | if (viafb_dual_fb && ((viafb_primary_dev != LCD_Device) |
| 1664 | || (viaparinfo->chip_info->gfx_chip_name != |
| 1665 | UNICHROME_CLE266))) { |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1666 | rc = register_framebuffer(viafbinfo1); |
| 1667 | if (rc) |
| 1668 | goto out_fb_unreg; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1669 | } |
| 1670 | DEBUG_MSG(KERN_INFO "fb%d: %s frame buffer device %dx%d-%dbpp\n", |
| 1671 | viafbinfo->node, viafbinfo->fix.id, default_var.xres, |
| 1672 | default_var.yres, default_var.bits_per_pixel); |
| 1673 | |
Florian Tobias Schandinat | 2b78a96 | 2010-04-17 19:44:57 +0000 | [diff] [blame] | 1674 | #ifdef CONFIG_FB_VIA_DIRECT_PROCFS |
Florian Tobias Schandinat | c4df548 | 2009-09-22 16:47:24 -0700 | [diff] [blame] | 1675 | viafb_init_proc(&viaparinfo->shared->proc_entry); |
Florian Tobias Schandinat | 2b78a96 | 2010-04-17 19:44:57 +0000 | [diff] [blame] | 1676 | #endif |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1677 | viafb_init_dac(IGA2); |
| 1678 | return 0; |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1679 | |
| 1680 | out_fb_unreg: |
| 1681 | unregister_framebuffer(viafbinfo); |
| 1682 | out_fb1_unreg_lcd_cle266: |
| 1683 | if (viafb_dual_fb && (viafb_primary_dev == LCD_Device) |
| 1684 | && (viaparinfo->chip_info->gfx_chip_name == UNICHROME_CLE266)) |
| 1685 | unregister_framebuffer(viafbinfo1); |
| 1686 | out_dealloc_cmap: |
| 1687 | fb_dealloc_cmap(&viafbinfo->cmap); |
| 1688 | out_fb1_release: |
| 1689 | if (viafbinfo1) |
| 1690 | framebuffer_release(viafbinfo1); |
Harald Welte | 109771a | 2009-05-19 17:12:58 +0800 | [diff] [blame] | 1691 | out_fb_release: |
| 1692 | framebuffer_release(viafbinfo); |
| 1693 | return rc; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1694 | } |
| 1695 | |
Jonathan Corbet | f045f77 | 2009-12-01 20:29:39 -0700 | [diff] [blame] | 1696 | void __devexit via_fb_pci_remove(struct pci_dev *pdev) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1697 | { |
| 1698 | DEBUG_MSG(KERN_INFO "via_pci_remove!\n"); |
| 1699 | fb_dealloc_cmap(&viafbinfo->cmap); |
| 1700 | unregister_framebuffer(viafbinfo); |
| 1701 | if (viafb_dual_fb) |
| 1702 | unregister_framebuffer(viafbinfo1); |
Florian Tobias Schandinat | 2b78a96 | 2010-04-17 19:44:57 +0000 | [diff] [blame] | 1703 | #ifdef CONFIG_FB_VIA_DIRECT_PROCFS |
Florian Tobias Schandinat | 2fed547 | 2010-04-17 19:44:56 +0000 | [diff] [blame] | 1704 | viafb_remove_proc(viaparinfo->shared->proc_entry); |
Florian Tobias Schandinat | 2b78a96 | 2010-04-17 19:44:57 +0000 | [diff] [blame] | 1705 | #endif |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1706 | framebuffer_release(viafbinfo); |
| 1707 | if (viafb_dual_fb) |
| 1708 | framebuffer_release(viafbinfo1); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1709 | } |
| 1710 | |
| 1711 | #ifndef MODULE |
| 1712 | static int __init viafb_setup(char *options) |
| 1713 | { |
| 1714 | char *this_opt; |
| 1715 | DEBUG_MSG(KERN_INFO "viafb_setup!\n"); |
| 1716 | |
| 1717 | if (!options || !*options) |
| 1718 | return 0; |
| 1719 | |
| 1720 | while ((this_opt = strsep(&options, ",")) != NULL) { |
| 1721 | if (!*this_opt) |
| 1722 | continue; |
| 1723 | |
| 1724 | if (!strncmp(this_opt, "viafb_mode1=", 12)) |
| 1725 | viafb_mode1 = kstrdup(this_opt + 12, GFP_KERNEL); |
| 1726 | else if (!strncmp(this_opt, "viafb_mode=", 11)) |
| 1727 | viafb_mode = kstrdup(this_opt + 11, GFP_KERNEL); |
| 1728 | else if (!strncmp(this_opt, "viafb_bpp1=", 11)) |
| 1729 | strict_strtoul(this_opt + 11, 0, |
| 1730 | (unsigned long *)&viafb_bpp1); |
| 1731 | else if (!strncmp(this_opt, "viafb_bpp=", 10)) |
| 1732 | strict_strtoul(this_opt + 10, 0, |
| 1733 | (unsigned long *)&viafb_bpp); |
| 1734 | else if (!strncmp(this_opt, "viafb_refresh1=", 15)) |
| 1735 | strict_strtoul(this_opt + 15, 0, |
| 1736 | (unsigned long *)&viafb_refresh1); |
| 1737 | else if (!strncmp(this_opt, "viafb_refresh=", 14)) |
| 1738 | strict_strtoul(this_opt + 14, 0, |
| 1739 | (unsigned long *)&viafb_refresh); |
| 1740 | else if (!strncmp(this_opt, "viafb_lcd_dsp_method=", 21)) |
| 1741 | strict_strtoul(this_opt + 21, 0, |
| 1742 | (unsigned long *)&viafb_lcd_dsp_method); |
| 1743 | else if (!strncmp(this_opt, "viafb_lcd_panel_id=", 19)) |
| 1744 | strict_strtoul(this_opt + 19, 0, |
| 1745 | (unsigned long *)&viafb_lcd_panel_id); |
| 1746 | else if (!strncmp(this_opt, "viafb_accel=", 12)) |
| 1747 | strict_strtoul(this_opt + 12, 0, |
| 1748 | (unsigned long *)&viafb_accel); |
| 1749 | else if (!strncmp(this_opt, "viafb_SAMM_ON=", 14)) |
| 1750 | strict_strtoul(this_opt + 14, 0, |
| 1751 | (unsigned long *)&viafb_SAMM_ON); |
| 1752 | else if (!strncmp(this_opt, "viafb_active_dev=", 17)) |
| 1753 | viafb_active_dev = kstrdup(this_opt + 17, GFP_KERNEL); |
| 1754 | else if (!strncmp(this_opt, |
| 1755 | "viafb_display_hardware_layout=", 30)) |
| 1756 | strict_strtoul(this_opt + 30, 0, |
| 1757 | (unsigned long *)&viafb_display_hardware_layout); |
| 1758 | else if (!strncmp(this_opt, "viafb_second_size=", 18)) |
| 1759 | strict_strtoul(this_opt + 18, 0, |
| 1760 | (unsigned long *)&viafb_second_size); |
| 1761 | else if (!strncmp(this_opt, |
| 1762 | "viafb_platform_epia_dvi=", 24)) |
| 1763 | strict_strtoul(this_opt + 24, 0, |
| 1764 | (unsigned long *)&viafb_platform_epia_dvi); |
| 1765 | else if (!strncmp(this_opt, |
| 1766 | "viafb_device_lcd_dualedge=", 26)) |
| 1767 | strict_strtoul(this_opt + 26, 0, |
| 1768 | (unsigned long *)&viafb_device_lcd_dualedge); |
| 1769 | else if (!strncmp(this_opt, "viafb_bus_width=", 16)) |
| 1770 | strict_strtoul(this_opt + 16, 0, |
| 1771 | (unsigned long *)&viafb_bus_width); |
| 1772 | else if (!strncmp(this_opt, "viafb_lcd_mode=", 15)) |
| 1773 | strict_strtoul(this_opt + 15, 0, |
| 1774 | (unsigned long *)&viafb_lcd_mode); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1775 | else if (!strncmp(this_opt, "viafb_lcd_port=", 15)) |
| 1776 | viafb_lcd_port = kstrdup(this_opt + 15, GFP_KERNEL); |
| 1777 | else if (!strncmp(this_opt, "viafb_dvi_port=", 15)) |
| 1778 | viafb_dvi_port = kstrdup(this_opt + 15, GFP_KERNEL); |
| 1779 | } |
| 1780 | return 0; |
| 1781 | } |
| 1782 | #endif |
| 1783 | |
Jonathan Corbet | f045f77 | 2009-12-01 20:29:39 -0700 | [diff] [blame] | 1784 | /* |
| 1785 | * These are called out of via-core for now. |
| 1786 | */ |
| 1787 | int __init viafb_init(void) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1788 | { |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1789 | u32 dummy; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1790 | #ifndef MODULE |
| 1791 | char *option = NULL; |
| 1792 | if (fb_get_options("viafb", &option)) |
| 1793 | return -ENODEV; |
| 1794 | viafb_setup(option); |
| 1795 | #endif |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1796 | if (parse_mode(viafb_mode, &dummy, &dummy) |
| 1797 | || parse_mode(viafb_mode1, &dummy, &dummy) |
Florian Tobias Schandinat | e17cea3 | 2010-03-10 15:21:41 -0800 | [diff] [blame] | 1798 | || viafb_bpp < 0 || viafb_bpp > 32 |
| 1799 | || viafb_bpp1 < 0 || viafb_bpp1 > 32 |
Florian Tobias Schandinat | fe9aab8 | 2010-03-10 15:21:34 -0800 | [diff] [blame] | 1800 | || parse_active_dev()) |
| 1801 | return -EINVAL; |
| 1802 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1803 | printk(KERN_INFO |
| 1804 | "VIA Graphics Intergration Chipset framebuffer %d.%d initializing\n", |
| 1805 | VERSION_MAJOR, VERSION_MINOR); |
Jonathan Corbet | f045f77 | 2009-12-01 20:29:39 -0700 | [diff] [blame] | 1806 | return 0; |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1807 | } |
| 1808 | |
Jonathan Corbet | f045f77 | 2009-12-01 20:29:39 -0700 | [diff] [blame] | 1809 | void __exit viafb_exit(void) |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1810 | { |
| 1811 | DEBUG_MSG(KERN_INFO "viafb_exit!\n"); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1812 | } |
| 1813 | |
| 1814 | static struct fb_ops viafb_ops = { |
| 1815 | .owner = THIS_MODULE, |
| 1816 | .fb_open = viafb_open, |
| 1817 | .fb_release = viafb_release, |
| 1818 | .fb_check_var = viafb_check_var, |
| 1819 | .fb_set_par = viafb_set_par, |
| 1820 | .fb_setcolreg = viafb_setcolreg, |
| 1821 | .fb_pan_display = viafb_pan_display, |
| 1822 | .fb_blank = viafb_blank, |
| 1823 | .fb_fillrect = viafb_fillrect, |
| 1824 | .fb_copyarea = viafb_copyarea, |
| 1825 | .fb_imageblit = viafb_imageblit, |
| 1826 | .fb_cursor = viafb_cursor, |
| 1827 | .fb_ioctl = viafb_ioctl, |
| 1828 | .fb_sync = viafb_sync, |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1829 | }; |
| 1830 | |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1831 | |
| 1832 | #ifdef MODULE |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1833 | module_param(viafb_mode, charp, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1834 | MODULE_PARM_DESC(viafb_mode, "Set resolution (default=640x480)"); |
| 1835 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1836 | module_param(viafb_mode1, charp, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1837 | MODULE_PARM_DESC(viafb_mode1, "Set resolution (default=640x480)"); |
| 1838 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1839 | module_param(viafb_bpp, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1840 | MODULE_PARM_DESC(viafb_bpp, "Set color depth (default=32bpp)"); |
| 1841 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1842 | module_param(viafb_bpp1, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1843 | MODULE_PARM_DESC(viafb_bpp1, "Set color depth (default=32bpp)"); |
| 1844 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1845 | module_param(viafb_refresh, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1846 | MODULE_PARM_DESC(viafb_refresh, |
| 1847 | "Set CRT viafb_refresh rate (default = 60)"); |
| 1848 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1849 | module_param(viafb_refresh1, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1850 | MODULE_PARM_DESC(viafb_refresh1, |
| 1851 | "Set CRT refresh rate (default = 60)"); |
| 1852 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1853 | module_param(viafb_lcd_panel_id, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1854 | MODULE_PARM_DESC(viafb_lcd_panel_id, |
| 1855 | "Set Flat Panel type(Default=1024x768)"); |
| 1856 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1857 | module_param(viafb_lcd_dsp_method, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1858 | MODULE_PARM_DESC(viafb_lcd_dsp_method, |
| 1859 | "Set Flat Panel display scaling method.(Default=Expandsion)"); |
| 1860 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1861 | module_param(viafb_SAMM_ON, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1862 | MODULE_PARM_DESC(viafb_SAMM_ON, |
| 1863 | "Turn on/off flag of SAMM(Default=OFF)"); |
| 1864 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1865 | module_param(viafb_accel, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1866 | MODULE_PARM_DESC(viafb_accel, |
Florian Tobias Schandinat | 31de59d | 2009-09-22 16:47:31 -0700 | [diff] [blame] | 1867 | "Set 2D Hardware Acceleration: 0 = OFF, 1 = ON (default)"); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1868 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1869 | module_param(viafb_active_dev, charp, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1870 | MODULE_PARM_DESC(viafb_active_dev, "Specify active devices."); |
| 1871 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1872 | module_param(viafb_display_hardware_layout, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1873 | MODULE_PARM_DESC(viafb_display_hardware_layout, |
| 1874 | "Display Hardware Layout (LCD Only, DVI Only...,etc)"); |
| 1875 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1876 | module_param(viafb_second_size, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1877 | MODULE_PARM_DESC(viafb_second_size, |
| 1878 | "Set secondary device memory size"); |
| 1879 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1880 | module_param(viafb_dual_fb, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1881 | MODULE_PARM_DESC(viafb_dual_fb, |
| 1882 | "Turn on/off flag of dual framebuffer devices.(Default = OFF)"); |
| 1883 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1884 | module_param(viafb_platform_epia_dvi, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1885 | MODULE_PARM_DESC(viafb_platform_epia_dvi, |
| 1886 | "Turn on/off flag of DVI devices on EPIA board.(Default = OFF)"); |
| 1887 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1888 | module_param(viafb_device_lcd_dualedge, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1889 | MODULE_PARM_DESC(viafb_device_lcd_dualedge, |
| 1890 | "Turn on/off flag of dual edge panel.(Default = OFF)"); |
| 1891 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1892 | module_param(viafb_bus_width, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1893 | MODULE_PARM_DESC(viafb_bus_width, |
| 1894 | "Set bus width of panel.(Default = 12)"); |
| 1895 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1896 | module_param(viafb_lcd_mode, int, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1897 | MODULE_PARM_DESC(viafb_lcd_mode, |
| 1898 | "Set Flat Panel mode(Default=OPENLDI)"); |
| 1899 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1900 | module_param(viafb_lcd_port, charp, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1901 | MODULE_PARM_DESC(viafb_lcd_port, "Specify LCD output port."); |
| 1902 | |
Harald Welte | 93967be | 2009-09-22 16:47:32 -0700 | [diff] [blame] | 1903 | module_param(viafb_dvi_port, charp, S_IRUSR); |
Joseph Chan | 29b619f | 2008-10-15 22:03:27 -0700 | [diff] [blame] | 1904 | MODULE_PARM_DESC(viafb_dvi_port, "Specify DVI output port."); |
| 1905 | |
| 1906 | MODULE_LICENSE("GPL"); |
| 1907 | #endif |