Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

Intel FB: whitespace, bracket and other clean-ups

Intel FB: whitespace, bracket and other clean-ups

Signed-off-by: Krzysztof Halasa <khc@pm.waw.pl>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Cc: <sylvain.meyer@worldonline.fr>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

authored by

Krzysztof Halasa and committed by
Linus Torvalds
689c9568 53ee1b5b

+202 -252
+6 -6
drivers/video/intelfb/intelfb.h
··· 231 231 struct intelfb_heap_data { 232 232 u32 physical; 233 233 u8 __iomem *virtual; 234 - u32 offset; // in GATT pages 235 - u32 size; // in bytes 234 + u32 offset; /* in GATT pages */ 235 + u32 size; /* in bytes */ 236 236 }; 237 237 238 238 #ifdef CONFIG_FB_INTEL_I2C ··· 270 270 struct intelfb_hwstate save_state; 271 271 272 272 /* agpgart structs */ 273 - struct agp_memory *gtt_fb_mem; // use all stolen memory or vram 274 - struct agp_memory *gtt_ring_mem; // ring buffer 275 - struct agp_memory *gtt_cursor_mem; // hw cursor 273 + struct agp_memory *gtt_fb_mem; /* use all stolen memory or vram */ 274 + struct agp_memory *gtt_ring_mem; /* ring buffer */ 275 + struct agp_memory *gtt_cursor_mem; /* hw cursor */ 276 276 277 277 /* use a gart reserved fb mem */ 278 278 u8 fbmem_gart; ··· 346 346 347 347 /* driver registered */ 348 348 int registered; 349 - 349 + 350 350 /* index into plls */ 351 351 int pll_index; 352 352
+33 -27
drivers/video/intelfb/intelfb_i2c.c
··· 58 58 struct intelfb_info *dinfo = chan->dinfo; 59 59 u32 val; 60 60 61 - OUTREG(chan->reg, (state ? SCL_VAL_OUT : 0) | SCL_DIR | SCL_DIR_MASK | SCL_VAL_MASK); 61 + OUTREG(chan->reg, (state ? SCL_VAL_OUT : 0) | 62 + SCL_DIR | SCL_DIR_MASK | SCL_VAL_MASK); 62 63 val = INREG(chan->reg); 63 64 } 64 65 ··· 69 68 struct intelfb_info *dinfo = chan->dinfo; 70 69 u32 val; 71 70 72 - OUTREG(chan->reg, (state ? SDA_VAL_OUT : 0) | SDA_DIR | SDA_DIR_MASK | SDA_VAL_MASK); 71 + OUTREG(chan->reg, (state ? SDA_VAL_OUT : 0) | 72 + SDA_DIR | SDA_DIR_MASK | SDA_VAL_MASK); 73 73 val = INREG(chan->reg); 74 74 } 75 75 ··· 99 97 } 100 98 101 99 static int intelfb_setup_i2c_bus(struct intelfb_info *dinfo, 102 - struct intelfb_i2c_chan *chan, 103 - const u32 reg, const char *name) 100 + struct intelfb_i2c_chan *chan, 101 + const u32 reg, const char *name) 104 102 { 105 103 int rc; 106 104 107 - chan->dinfo = dinfo; 108 - chan->reg = reg; 105 + chan->dinfo = dinfo; 106 + chan->reg = reg; 109 107 snprintf(chan->adapter.name, sizeof(chan->adapter.name), 110 108 "intelfb %s", name); 111 - chan->adapter.owner = THIS_MODULE; 112 - chan->adapter.id = I2C_HW_B_INTELFB; 109 + chan->adapter.owner = THIS_MODULE; 110 + chan->adapter.id = I2C_HW_B_INTELFB; 113 111 chan->adapter.algo_data = &chan->algo; 114 112 chan->adapter.dev.parent = &chan->dinfo->pdev->dev; 115 - chan->algo.setsda = intelfb_gpio_setsda; 116 - chan->algo.setscl = intelfb_gpio_setscl; 117 - chan->algo.getsda = intelfb_gpio_getsda; 118 - chan->algo.getscl = intelfb_gpio_getscl; 119 - chan->algo.udelay = 40; 120 - chan->algo.timeout = 20; 121 - chan->algo.data = chan; 113 + chan->algo.setsda = intelfb_gpio_setsda; 114 + chan->algo.setscl = intelfb_gpio_setscl; 115 + chan->algo.getsda = intelfb_gpio_getsda; 116 + chan->algo.getscl = intelfb_gpio_getscl; 117 + chan->algo.udelay = 40; 118 + chan->algo.timeout = 20; 119 + chan->algo.data = chan; 122 120 123 121 i2c_set_adapdata(&chan->adapter, chan); 124 122 ··· 144 142 dinfo->output[i].type = INTELFB_OUTPUT_ANALOG; 145 143 146 144 /* setup the DDC bus for analog output */ 147 - intelfb_setup_i2c_bus(dinfo, &dinfo->output[i].ddc_bus, GPIOA, "CRTDDC_A"); 145 + intelfb_setup_i2c_bus(dinfo, &dinfo->output[i].ddc_bus, GPIOA, 146 + "CRTDDC_A"); 148 147 i++; 149 148 150 - /* need to add the output busses for each device 151 - - this function is very incomplete 152 - - i915GM has LVDS and TVOUT for example 153 - */ 154 - switch(dinfo->chipset) { 149 + /* need to add the output busses for each device 150 + - this function is very incomplete 151 + - i915GM has LVDS and TVOUT for example 152 + */ 153 + switch(dinfo->chipset) { 155 154 case INTEL_830M: 156 155 case INTEL_845G: 157 156 case INTEL_855GM: 158 157 case INTEL_865G: 159 158 dinfo->output[i].type = INTELFB_OUTPUT_DVO; 160 - intelfb_setup_i2c_bus(dinfo, &dinfo->output[i].ddc_bus, GPIOD, "DVODDC_D"); 161 - intelfb_setup_i2c_bus(dinfo, &dinfo->output[i].i2c_bus, GPIOE, "DVOI2C_E"); 159 + intelfb_setup_i2c_bus(dinfo, &dinfo->output[i].ddc_bus, 160 + GPIOD, "DVODDC_D"); 161 + intelfb_setup_i2c_bus(dinfo, &dinfo->output[i].i2c_bus, 162 + GPIOE, "DVOI2C_E"); 162 163 i++; 163 164 break; 164 165 case INTEL_915G: 165 166 case INTEL_915GM: 166 - /* has some LVDS + tv-out */ 167 + /* has some LVDS + tv-out */ 167 168 case INTEL_945G: 168 169 case INTEL_945GM: 169 170 /* SDVO ports have a single control bus - 2 devices */ 170 171 dinfo->output[i].type = INTELFB_OUTPUT_SDVO; 171 - intelfb_setup_i2c_bus(dinfo, &dinfo->output[i].i2c_bus, GPIOE, "SDVOCTRL_E"); 172 + intelfb_setup_i2c_bus(dinfo, &dinfo->output[i].i2c_bus, 173 + GPIOE, "SDVOCTRL_E"); 172 174 /* TODO: initialize the SDVO */ 173 - // I830SDVOInit(pScrn, i, DVOB); 175 + /* I830SDVOInit(pScrn, i, DVOB); */ 174 176 i++; 175 177 176 178 /* set up SDVOC */ 177 179 dinfo->output[i].type = INTELFB_OUTPUT_SDVO; 178 180 dinfo->output[i].i2c_bus = dinfo->output[i - 1].i2c_bus; 179 181 /* TODO: initialize the SDVO */ 180 - // I830SDVOInit(pScrn, i, DVOC); 182 + /* I830SDVOInit(pScrn, i, DVOC); */ 181 183 i++; 182 184 break; 183 185 }
+73 -105
drivers/video/intelfb/intelfbdrv.c
··· 99 99 * Add vram option to reserve more memory than stolen by BIOS 100 100 * Fix intelfbhw_pan_display typo 101 101 * Add __initdata annotations 102 - * 103 - * TODO: 104 - * 105 - * 106 - * Wish List: 107 - * 108 - * 109 102 */ 110 103 111 104 #include <linux/module.h> ··· 215 222 /* Module description/parameters */ 216 223 MODULE_AUTHOR("David Dawes <dawes@tungstengraphics.com>, " 217 224 "Sylvain Meyer <sylvain.meyer@worldonline.fr>"); 218 - MODULE_DESCRIPTION( 219 - "Framebuffer driver for Intel(R) " SUPPORTED_CHIPSETS " chipsets"); 225 + MODULE_DESCRIPTION("Framebuffer driver for Intel(R) " SUPPORTED_CHIPSETS 226 + " chipsets"); 220 227 MODULE_LICENSE("Dual BSD/GPL"); 221 228 MODULE_DEVICE_TABLE(pci, intelfb_pci_table); 222 229 ··· 264 271 #define OPT_INTVAL(opt, name) simple_strtoul(opt + strlen(name) + 1, NULL, 0) 265 272 #define OPT_STRVAL(opt, name) (opt + strlen(name)) 266 273 267 - static __inline__ char * 268 - get_opt_string(const char *this_opt, const char *name) 274 + static __inline__ char * get_opt_string(const char *this_opt, const char *name) 269 275 { 270 276 const char *p; 271 277 int i; ··· 282 290 return ret; 283 291 } 284 292 285 - static __inline__ int 286 - get_opt_int(const char *this_opt, const char *name, int *ret) 293 + static __inline__ int get_opt_int(const char *this_opt, const char *name, 294 + int *ret) 287 295 { 288 296 if (!ret) 289 297 return 0; ··· 295 303 return 1; 296 304 } 297 305 298 - static __inline__ int 299 - get_opt_bool(const char *this_opt, const char *name, int *ret) 306 + static __inline__ int get_opt_bool(const char *this_opt, const char *name, 307 + int *ret) 300 308 { 301 309 if (!ret) 302 310 return 0; ··· 316 324 return 1; 317 325 } 318 326 319 - static int __init 320 - intelfb_setup(char *options) 327 + static int __init intelfb_setup(char *options) 321 328 { 322 329 char *this_opt; 323 330 ··· 346 355 continue; 347 356 if (get_opt_bool(this_opt, "accel", &accel)) 348 357 ; 349 - else if (get_opt_int(this_opt, "vram", &vram)) 358 + else if (get_opt_int(this_opt, "vram", &vram)) 350 359 ; 351 360 else if (get_opt_bool(this_opt, "hwcursor", &hwcursor)) 352 361 ; ··· 367 376 368 377 #endif 369 378 370 - static int __init 371 - intelfb_init(void) 379 + static int __init intelfb_init(void) 372 380 { 373 381 #ifndef MODULE 374 382 char *option = NULL; ··· 391 401 return pci_register_driver(&intelfb_driver); 392 402 } 393 403 394 - static void __exit 395 - intelfb_exit(void) 404 + static void __exit intelfb_exit(void) 396 405 { 397 406 DBG_MSG("intelfb_exit\n"); 398 407 pci_unregister_driver(&intelfb_driver); ··· 417 428 } 418 429 static inline void unset_mtrr(struct intelfb_info *dinfo) 419 430 { 420 - if (dinfo->has_mtrr) 421 - mtrr_del(dinfo->mtrr_reg, dinfo->aperture.physical, 431 + if (dinfo->has_mtrr) 432 + mtrr_del(dinfo->mtrr_reg, dinfo->aperture.physical, 422 433 dinfo->aperture.size); 423 434 } 424 435 #else ··· 431 442 * driver init / cleanup * 432 443 ***************************************************************/ 433 444 434 - static void 435 - cleanup(struct intelfb_info *dinfo) 445 + static void cleanup(struct intelfb_info *dinfo) 436 446 { 437 447 DBG_MSG("cleanup\n"); 438 448 ··· 487 499 } while (0) 488 500 489 501 490 - static int __devinit 491 - intelfb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent) 502 + static int __devinit intelfb_pci_register(struct pci_dev *pdev, 503 + const struct pci_device_id *ent) 492 504 { 493 505 struct fb_info *info; 494 506 struct intelfb_info *dinfo; ··· 498 510 int agp_memtype; 499 511 const char *s; 500 512 struct agp_bridge_data *bridge; 501 - int aperture_bar = 0; 502 - int mmio_bar = 1; 513 + int aperture_bar = 0; 514 + int mmio_bar = 1; 503 515 int offset; 504 516 505 517 DBG_MSG("intelfb_pci_register\n"); ··· 625 637 dinfo->ring.size = RINGBUFFER_SIZE; 626 638 dinfo->ring_tail_mask = dinfo->ring.size - 1; 627 639 } 628 - if (dinfo->hwcursor) { 640 + if (dinfo->hwcursor) 629 641 dinfo->cursor.size = HW_CURSOR_SIZE; 630 - } 631 642 632 643 /* Use agpgart to manage the GATT */ 633 644 if (!(bridge = agp_backend_acquire(pdev))) { ··· 649 662 offset = ROUND_UP_TO_PAGE(MB(voffset))/GTT_PAGE_SIZE; 650 663 651 664 /* set the mem offsets - set them after the already used pages */ 652 - if (dinfo->accel) { 665 + if (dinfo->accel) 653 666 dinfo->ring.offset = offset + gtt_info.current_memory; 654 - } 655 - if (dinfo->hwcursor) { 667 + if (dinfo->hwcursor) 656 668 dinfo->cursor.offset = offset + 657 669 + gtt_info.current_memory + (dinfo->ring.size >> 12); 658 - } 659 - if (dinfo->fbmem_gart) { 670 + if (dinfo->fbmem_gart) 660 671 dinfo->fb.offset = offset + 661 672 + gtt_info.current_memory + (dinfo->ring.size >> 12) 662 673 + (dinfo->cursor.size >> 12); 663 - } 664 674 665 675 /* Allocate memories (which aren't stolen) */ 666 676 /* Map the fb and MMIO regions */ ··· 673 689 674 690 dinfo->mmio_base = 675 691 (u8 __iomem *)ioremap_nocache(dinfo->mmio_base_phys, 676 - INTEL_REG_SIZE); 692 + INTEL_REG_SIZE); 677 693 if (!dinfo->mmio_base) { 678 694 ERR_MSG("Cannot remap MMIO region.\n"); 679 695 cleanup(dinfo); ··· 821 837 if (bailearly == 3) 822 838 bailout(dinfo); 823 839 824 - if (FIXED_MODE(dinfo)) { 825 - /* remap fb address */ 840 + if (FIXED_MODE(dinfo)) /* remap fb address */ 826 841 update_dinfo(dinfo, &dinfo->initial_var); 827 - } 828 842 829 843 if (bailearly == 4) 830 844 bailout(dinfo); ··· 921 939 * helper functions * 922 940 ***************************************************************/ 923 941 924 - int __inline__ 925 - intelfb_var_to_depth(const struct fb_var_screeninfo *var) 942 + int __inline__ intelfb_var_to_depth(const struct fb_var_screeninfo *var) 926 943 { 927 944 DBG_MSG("intelfb_var_to_depth: bpp: %d, green.length is %d\n", 928 945 var->bits_per_pixel, var->green.length); ··· 937 956 } 938 957 939 958 940 - static __inline__ int 941 - var_to_refresh(const struct fb_var_screeninfo *var) 959 + static __inline__ int var_to_refresh(const struct fb_var_screeninfo *var) 942 960 { 943 961 int xtot = var->xres + var->left_margin + var->right_margin + 944 962 var->hsync_len; ··· 951 971 * Various intialisation functions * 952 972 ***************************************************************/ 953 973 954 - static void __devinit 955 - get_initial_mode(struct intelfb_info *dinfo) 974 + static void __devinit get_initial_mode(struct intelfb_info *dinfo) 956 975 { 957 976 struct fb_var_screeninfo *var; 958 977 int xtot, ytot; ··· 1018 1039 } 1019 1040 } 1020 1041 1021 - static int __devinit 1022 - intelfb_init_var(struct intelfb_info *dinfo) 1042 + static int __devinit intelfb_init_var(struct intelfb_info *dinfo) 1023 1043 { 1024 1044 struct fb_var_screeninfo *var; 1025 1045 int msrc = 0; ··· 1065 1087 1066 1088 } 1067 1089 1068 - if (!msrc) { 1090 + if (!msrc) 1069 1091 msrc = fb_find_mode(var, dinfo->info, PREFERRED_MODE, 1070 1092 NULL, 0, NULL, 0); 1071 - } 1072 1093 } 1073 1094 1074 1095 if (!msrc) { ··· 1099 1122 return 0; 1100 1123 } 1101 1124 1102 - static int __devinit 1103 - intelfb_set_fbinfo(struct intelfb_info *dinfo) 1125 + static int __devinit intelfb_set_fbinfo(struct intelfb_info *dinfo) 1104 1126 { 1105 1127 struct fb_info *info = dinfo->info; 1106 1128 ··· 1135 1159 } 1136 1160 1137 1161 /* Update dinfo to match the active video mode. */ 1138 - static void 1139 - update_dinfo(struct intelfb_info *dinfo, struct fb_var_screeninfo *var) 1162 + static void update_dinfo(struct intelfb_info *dinfo, 1163 + struct fb_var_screeninfo *var) 1140 1164 { 1141 1165 DBG_MSG("update_dinfo\n"); 1142 1166 ··· 1184 1208 * fbdev interface * 1185 1209 ***************************************************************/ 1186 1210 1187 - static int 1188 - intelfb_open(struct fb_info *info, int user) 1211 + static int intelfb_open(struct fb_info *info, int user) 1189 1212 { 1190 1213 struct intelfb_info *dinfo = GET_DINFO(info); 1191 1214 1192 - if (user) { 1215 + if (user) 1193 1216 dinfo->open++; 1194 - } 1195 1217 1196 1218 return 0; 1197 1219 } 1198 1220 1199 - static int 1200 - intelfb_release(struct fb_info *info, int user) 1221 + static int intelfb_release(struct fb_info *info, int user) 1201 1222 { 1202 1223 struct intelfb_info *dinfo = GET_DINFO(info); 1203 1224 1204 1225 if (user) { 1205 1226 dinfo->open--; 1206 1227 msleep(1); 1207 - if (!dinfo->open) { 1228 + if (!dinfo->open) 1208 1229 intelfbhw_disable_irq(dinfo); 1209 - } 1210 1230 } 1211 1231 1212 1232 return 0; 1213 1233 } 1214 1234 1215 - static int 1216 - intelfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info) 1235 + static int intelfb_check_var(struct fb_var_screeninfo *var, 1236 + struct fb_info *info) 1217 1237 { 1218 1238 int change_var = 0; 1219 1239 struct fb_var_screeninfo v; ··· 1243 1271 } 1244 1272 1245 1273 /* Check for a supported bpp. */ 1246 - if (v.bits_per_pixel <= 8) { 1274 + if (v.bits_per_pixel <= 8) 1247 1275 v.bits_per_pixel = 8; 1248 - } else if (v.bits_per_pixel <= 16) { 1276 + else if (v.bits_per_pixel <= 16) { 1249 1277 if (v.bits_per_pixel == 16) 1250 1278 v.green.length = 6; 1251 1279 v.bits_per_pixel = 16; 1252 - } else if (v.bits_per_pixel <= 32) { 1280 + } else if (v.bits_per_pixel <= 32) 1253 1281 v.bits_per_pixel = 32; 1254 - } else 1282 + else 1255 1283 return -EINVAL; 1256 1284 1257 1285 change_var = ((info->var.xres != var->xres) || ··· 1333 1361 return 0; 1334 1362 } 1335 1363 1336 - static int 1337 - intelfb_set_par(struct fb_info *info) 1364 + static int intelfb_set_par(struct fb_info *info) 1338 1365 { 1339 - struct intelfb_hwstate *hw; 1366 + struct intelfb_hwstate *hw; 1340 1367 struct intelfb_info *dinfo = GET_DINFO(info); 1341 1368 1342 1369 if (FIXED_MODE(dinfo)) { ··· 1343 1372 return -EINVAL; 1344 1373 } 1345 1374 1346 - hw = kmalloc(sizeof(*hw), GFP_ATOMIC); 1347 - if (!hw) 1348 - return -ENOMEM; 1375 + hw = kmalloc(sizeof(*hw), GFP_ATOMIC); 1376 + if (!hw) 1377 + return -ENOMEM; 1349 1378 1350 1379 DBG_MSG("intelfb_set_par (%dx%d-%d)\n", info->var.xres, 1351 1380 info->var.yres, info->var.bits_per_pixel); ··· 1355 1384 if (ACCEL(dinfo, info)) 1356 1385 intelfbhw_2d_stop(dinfo); 1357 1386 1358 - memcpy(hw, &dinfo->save_state, sizeof(*hw)); 1359 - if (intelfbhw_mode_to_hw(dinfo, hw, &info->var)) 1360 - goto invalid_mode; 1361 - if (intelfbhw_program_mode(dinfo, hw, 0)) 1362 - goto invalid_mode; 1387 + memcpy(hw, &dinfo->save_state, sizeof(*hw)); 1388 + if (intelfbhw_mode_to_hw(dinfo, hw, &info->var)) 1389 + goto invalid_mode; 1390 + if (intelfbhw_program_mode(dinfo, hw, 0)) 1391 + goto invalid_mode; 1363 1392 1364 1393 #if REGDUMP > 0 1365 - intelfbhw_read_hw_state(dinfo, hw, 0); 1366 - intelfbhw_print_hw_state(dinfo, hw); 1394 + intelfbhw_read_hw_state(dinfo, hw, 0); 1395 + intelfbhw_print_hw_state(dinfo, hw); 1367 1396 #endif 1368 1397 1369 1398 update_dinfo(dinfo, &info->var); ··· 1379 1408 info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN | 1380 1409 FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT | 1381 1410 FBINFO_HWACCEL_IMAGEBLIT; 1382 - } else { 1411 + } else 1383 1412 info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN; 1384 - } 1413 + 1385 1414 kfree(hw); 1386 1415 return 0; 1387 1416 invalid_mode: ··· 1389 1418 return -EINVAL; 1390 1419 } 1391 1420 1392 - static int 1393 - intelfb_setcolreg(unsigned regno, unsigned red, unsigned green, 1394 - unsigned blue, unsigned transp, struct fb_info *info) 1421 + static int intelfb_setcolreg(unsigned regno, unsigned red, unsigned green, 1422 + unsigned blue, unsigned transp, 1423 + struct fb_info *info) 1395 1424 { 1396 1425 struct intelfb_info *dinfo = GET_DINFO(info); 1397 1426 ··· 1434 1463 return 0; 1435 1464 } 1436 1465 1437 - static int 1438 - intelfb_blank(int blank, struct fb_info *info) 1466 + static int intelfb_blank(int blank, struct fb_info *info) 1439 1467 { 1440 1468 intelfbhw_do_blank(blank, info); 1441 1469 return 0; 1442 1470 } 1443 1471 1444 - static int 1445 - intelfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info) 1472 + static int intelfb_pan_display(struct fb_var_screeninfo *var, 1473 + struct fb_info *info) 1446 1474 { 1447 1475 intelfbhw_pan_display(var, info); 1448 1476 return 0; 1449 1477 } 1450 1478 1451 1479 /* When/if we have our own ioctls. */ 1452 - static int 1453 - intelfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg) 1480 + static int intelfb_ioctl(struct fb_info *info, unsigned int cmd, 1481 + unsigned long arg) 1454 1482 { 1455 1483 int retval = 0; 1456 1484 struct intelfb_info *dinfo = GET_DINFO(info); ··· 1469 1499 return retval; 1470 1500 } 1471 1501 1472 - static void 1473 - intelfb_fillrect (struct fb_info *info, const struct fb_fillrect *rect) 1502 + static void intelfb_fillrect (struct fb_info *info, 1503 + const struct fb_fillrect *rect) 1474 1504 { 1475 1505 struct intelfb_info *dinfo = GET_DINFO(info); 1476 1506 u32 rop, color; ··· 1484 1514 1485 1515 if (rect->rop == ROP_COPY) 1486 1516 rop = PAT_ROP_GXCOPY; 1487 - else // ROP_XOR 1517 + else /* ROP_XOR */ 1488 1518 rop = PAT_ROP_GXXOR; 1489 1519 1490 1520 if (dinfo->depth != 8) ··· 1498 1528 rop); 1499 1529 } 1500 1530 1501 - static void 1502 - intelfb_copyarea(struct fb_info *info, const struct fb_copyarea *region) 1531 + static void intelfb_copyarea(struct fb_info *info, 1532 + const struct fb_copyarea *region) 1503 1533 { 1504 1534 struct intelfb_info *dinfo = GET_DINFO(info); 1505 1535 ··· 1515 1545 dinfo->pitch, info->var.bits_per_pixel); 1516 1546 } 1517 1547 1518 - static void 1519 - intelfb_imageblit(struct fb_info *info, const struct fb_image *image) 1548 + static void intelfb_imageblit(struct fb_info *info, 1549 + const struct fb_image *image) 1520 1550 { 1521 1551 struct intelfb_info *dinfo = GET_DINFO(info); 1522 1552 u32 fgcolor, bgcolor; ··· 1544 1574 return cfb_imageblit(info, image); 1545 1575 } 1546 1576 1547 - static int 1548 - intelfb_cursor(struct fb_info *info, struct fb_cursor *cursor) 1577 + static int intelfb_cursor(struct fb_info *info, struct fb_cursor *cursor) 1549 1578 { 1550 1579 struct intelfb_info *dinfo = GET_DINFO(info); 1551 1580 u32 physical; ··· 1658 1689 return 0; 1659 1690 } 1660 1691 1661 - static int 1662 - intelfb_sync(struct fb_info *info) 1692 + static int intelfb_sync(struct fb_info *info) 1663 1693 { 1664 1694 struct intelfb_info *dinfo = GET_DINFO(info); 1665 1695
+83 -107
drivers/video/intelfb/intelfbhw.c
··· 56 56 6, 16, 3, 16, 57 57 4, 128, 0, 31, 58 58 930000, 1400000, 165000, 48000, 59 - 4, 2 }, //I8xx 59 + 4, 2 }, /* I8xx */ 60 60 61 61 { 75, 120, 10, 20, 62 62 5, 9, 4, 7, 63 63 5, 80, 1, 8, 64 64 1400000, 2800000, 200000, 96000, 65 - 10, 5 } //I9xx 65 + 10, 5 } /* I9xx */ 66 66 }; 67 67 68 - int 69 - intelfbhw_get_chipset(struct pci_dev *pdev, struct intelfb_info *dinfo) 68 + int intelfbhw_get_chipset(struct pci_dev *pdev, struct intelfb_info *dinfo) 70 69 { 71 70 u32 tmp; 72 71 if (!pdev || !dinfo) ··· 148 149 } 149 150 } 150 151 151 - int 152 - intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size, 153 - int *stolen_size) 152 + int intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size, 153 + int *stolen_size) 154 154 { 155 155 struct pci_dev *bridge_dev; 156 156 u16 tmp; ··· 252 254 } 253 255 } 254 256 255 - int 256 - intelfbhw_check_non_crt(struct intelfb_info *dinfo) 257 + int intelfbhw_check_non_crt(struct intelfb_info *dinfo) 257 258 { 258 259 int dvo = 0; 259 260 ··· 268 271 return dvo; 269 272 } 270 273 271 - const char * 272 - intelfbhw_dvo_to_string(int dvo) 274 + const char * intelfbhw_dvo_to_string(int dvo) 273 275 { 274 276 if (dvo & DVOA_PORT) 275 277 return "DVO port A"; ··· 283 287 } 284 288 285 289 286 - int 287 - intelfbhw_validate_mode(struct intelfb_info *dinfo, 288 - struct fb_var_screeninfo *var) 290 + int intelfbhw_validate_mode(struct intelfb_info *dinfo, 291 + struct fb_var_screeninfo *var) 289 292 { 290 293 int bytes_per_pixel; 291 294 int tmp; ··· 340 345 return 0; 341 346 } 342 347 343 - int 344 - intelfbhw_pan_display(struct fb_var_screeninfo *var, struct fb_info *info) 348 + int intelfbhw_pan_display(struct fb_var_screeninfo *var, struct fb_info *info) 345 349 { 346 350 struct intelfb_info *dinfo = GET_DINFO(info); 347 351 u32 offset, xoffset, yoffset; ··· 362 368 offset += dinfo->fb.offset << 12; 363 369 364 370 dinfo->vsync.pan_offset = offset; 365 - if ((var->activate & FB_ACTIVATE_VBL) && !intelfbhw_enable_irq(dinfo, 0)) { 371 + if ((var->activate & FB_ACTIVATE_VBL) && 372 + !intelfbhw_enable_irq(dinfo, 0)) 366 373 dinfo->vsync.pan_display = 1; 367 - } else { 374 + else { 368 375 dinfo->vsync.pan_display = 0; 369 376 OUTREG(DSPABASE, offset); 370 377 } ··· 374 379 } 375 380 376 381 /* Blank the screen. */ 377 - void 378 - intelfbhw_do_blank(int blank, struct fb_info *info) 382 + void intelfbhw_do_blank(int blank, struct fb_info *info) 379 383 { 380 384 struct intelfb_info *dinfo = GET_DINFO(info); 381 385 u32 tmp; ··· 399 405 DBG_MSG("cursor_on is %d\n", dinfo->cursor_on); 400 406 #endif 401 407 if (dinfo->cursor_on) { 402 - if (blank) { 408 + if (blank) 403 409 intelfbhw_cursor_hide(dinfo); 404 - } else { 410 + else 405 411 intelfbhw_cursor_show(dinfo); 406 - } 407 412 dinfo->cursor_on = 1; 408 413 } 409 414 dinfo->cursor_blanked = blank; ··· 430 437 } 431 438 432 439 433 - void 434 - intelfbhw_setcolreg(struct intelfb_info *dinfo, unsigned regno, 435 - unsigned red, unsigned green, unsigned blue, 436 - unsigned transp) 440 + void intelfbhw_setcolreg(struct intelfb_info *dinfo, unsigned regno, 441 + unsigned red, unsigned green, unsigned blue, 442 + unsigned transp) 437 443 { 438 444 #if VERBOSE > 0 439 445 DBG_MSG("intelfbhw_setcolreg: %d: (%d, %d, %d)\n", ··· 449 457 } 450 458 451 459 452 - int 453 - intelfbhw_read_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw, 454 - int flag) 460 + int intelfbhw_read_hw_state(struct intelfb_info *dinfo, 461 + struct intelfb_hwstate *hw, int flag) 455 462 { 456 463 int i; 457 464 ··· 597 606 return plls[index].ref_clk * m / n / p; 598 607 } 599 608 600 - static int calc_vclock(int index, int m1, int m2, int n, int p1, int p2, int lvds) 609 + static int calc_vclock(int index, int m1, int m2, int n, int p1, int p2, 610 + int lvds) 601 611 { 602 612 struct pll_min_max *pll = &plls[index]; 603 613 u32 m, vco, p; ··· 607 615 n += 2; 608 616 vco = pll->ref_clk * m / n; 609 617 610 - if (index == PLLS_I8xx) { 618 + if (index == PLLS_I8xx) 611 619 p = ((p1 + 2) * (1 << (p2 + 1))); 612 - } else { 620 + else 613 621 p = ((p1) * (p2 ? 5 : 10)); 614 - } 615 622 return vco / p; 616 623 } 617 624 618 625 #if REGDUMP 619 - static void 620 - intelfbhw_get_p1p2(struct intelfb_info *dinfo, int dpll, int *o_p1, int *o_p2) 626 + static void intelfbhw_get_p1p2(struct intelfb_info *dinfo, int dpll, 627 + int *o_p1, int *o_p2) 621 628 { 622 629 int p1, p2; 623 630 ··· 625 634 p1 = 1; 626 635 else 627 636 p1 = (dpll >> DPLL_P1_SHIFT) & 0xff; 628 - 637 + 629 638 p1 = ffs(p1); 630 639 631 640 p2 = (dpll >> DPLL_I9XX_P2_SHIFT) & DPLL_P2_MASK; ··· 643 652 #endif 644 653 645 654 646 - void 647 - intelfbhw_print_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw) 655 + void intelfbhw_print_hw_state(struct intelfb_info *dinfo, 656 + struct intelfb_hwstate *hw) 648 657 { 649 658 #if REGDUMP 650 659 int i, m1, m2, n, p1, p2; ··· 657 666 printk("hw state dump start\n"); 658 667 printk(" VGA0_DIVISOR: 0x%08x\n", hw->vga0_divisor); 659 668 printk(" VGA1_DIVISOR: 0x%08x\n", hw->vga1_divisor); 660 - printk(" VGAPD: 0x%08x\n", hw->vga_pd); 669 + printk(" VGAPD: 0x%08x\n", hw->vga_pd); 661 670 n = (hw->vga0_divisor >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; 662 671 m1 = (hw->vga0_divisor >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; 663 672 m2 = (hw->vga0_divisor >> FP_M2_DIVISOR_SHIFT) & FP_DIVISOR_MASK; ··· 676 685 intelfbhw_get_p1p2(dinfo, hw->vga_pd, &p1, &p2); 677 686 printk(" VGA1: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", 678 687 m1, m2, n, p1, p2); 679 - printk(" VGA1: clock is %d\n", calc_vclock(index, m1, m2, n, p1, p2, 0)); 688 + printk(" VGA1: clock is %d\n", 689 + calc_vclock(index, m1, m2, n, p1, p2, 0)); 680 690 681 691 printk(" DPLL_A: 0x%08x\n", hw->dpll_a); 682 692 printk(" DPLL_B: 0x%08x\n", hw->dpll_b); ··· 694 702 695 703 printk(" PLLA0: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", 696 704 m1, m2, n, p1, p2); 697 - printk(" PLLA0: clock is %d\n", calc_vclock(index, m1, m2, n, p1, p2, 0)); 705 + printk(" PLLA0: clock is %d\n", 706 + calc_vclock(index, m1, m2, n, p1, p2, 0)); 698 707 699 708 n = (hw->fpa1 >> FP_N_DIVISOR_SHIFT) & FP_DIVISOR_MASK; 700 709 m1 = (hw->fpa1 >> FP_M1_DIVISOR_SHIFT) & FP_DIVISOR_MASK; ··· 705 712 706 713 printk(" PLLA1: (m1, m2, n, p1, p2) = (%d, %d, %d, %d, %d)\n", 707 714 m1, m2, n, p1, p2); 708 - printk(" PLLA1: clock is %d\n", calc_vclock(index, m1, m2, n, p1, p2, 0)); 715 + printk(" PLLA1: clock is %d\n", 716 + calc_vclock(index, m1, m2, n, p1, p2, 0)); 709 717 710 718 #if 0 711 719 printk(" PALETTE_A:\n"); ··· 811 817 812 818 813 819 /* Split the M parameter into M1 and M2. */ 814 - static int 815 - splitm(int index, unsigned int m, unsigned int *retm1, unsigned int *retm2) 820 + static int splitm(int index, unsigned int m, unsigned int *retm1, 821 + unsigned int *retm2) 816 822 { 817 823 int m1, m2; 818 824 int testm; ··· 833 839 } 834 840 835 841 /* Split the P parameter into P1 and P2. */ 836 - static int 837 - splitp(int index, unsigned int p, unsigned int *retp1, unsigned int *retp2) 842 + static int splitp(int index, unsigned int p, unsigned int *retp1, 843 + unsigned int *retp2) 838 844 { 839 845 int p1, p2; 840 846 struct pll_min_max *pll = &plls[index]; ··· 868 874 } 869 875 } 870 876 871 - static int 872 - calc_pll_params(int index, int clock, u32 *retm1, u32 *retm2, u32 *retn, u32 *retp1, 873 - u32 *retp2, u32 *retclock) 877 + static int calc_pll_params(int index, int clock, u32 *retm1, u32 *retm2, 878 + u32 *retn, u32 *retp1, u32 *retp2, u32 *retclock) 874 879 { 875 880 u32 m1, m2, n, p1, p2, n1, testm; 876 881 u32 f_vco, p, p_best = 0, m, f_out = 0; ··· 964 971 return 0; 965 972 } 966 973 967 - static __inline__ int 968 - check_overflow(u32 value, u32 limit, const char *description) 974 + static __inline__ int check_overflow(u32 value, u32 limit, 975 + const char *description) 969 976 { 970 977 if (value > limit) { 971 978 WRN_MSG("%s value %d exceeds limit %d\n", ··· 976 983 } 977 984 978 985 /* It is assumed that hw is filled in with the initial state information. */ 979 - int 980 - intelfbhw_mode_to_hw(struct intelfb_info *dinfo, struct intelfb_hwstate *hw, 981 - struct fb_var_screeninfo *var) 986 + int intelfbhw_mode_to_hw(struct intelfb_info *dinfo, 987 + struct intelfb_hwstate *hw, 988 + struct fb_var_screeninfo *var) 982 989 { 983 990 int pipe = PIPE_A; 984 991 u32 *dpll, *fp0, *fp1; ··· 1082 1089 if (IS_I9XX(dinfo)) { 1083 1090 *dpll |= (p2 << DPLL_I9XX_P2_SHIFT); 1084 1091 *dpll |= (1 << (p1 - 1)) << DPLL_P1_SHIFT; 1085 - } else { 1092 + } else 1086 1093 *dpll |= (p2 << DPLL_P2_SHIFT) | (p1 << DPLL_P1_SHIFT); 1087 - } 1088 1094 1089 1095 *fp0 = (n << FP_N_DIVISOR_SHIFT) | 1090 1096 (m1 << FP_M1_DIVISOR_SHIFT) | ··· 1218 1226 } 1219 1227 1220 1228 /* Program a (non-VGA) video mode. */ 1221 - int 1222 - intelfbhw_program_mode(struct intelfb_info *dinfo, 1223 - const struct intelfb_hwstate *hw, int blank) 1229 + int intelfbhw_program_mode(struct intelfb_info *dinfo, 1230 + const struct intelfb_hwstate *hw, int blank) 1224 1231 { 1225 1232 int pipe = PIPE_A; 1226 1233 u32 tmp; ··· 1315 1324 tmp &= ~PIPECONF_ENABLE; 1316 1325 OUTREG(pipe_conf_reg, tmp); 1317 1326 } 1318 - } while(count < 2000); 1327 + } while (count < 2000); 1319 1328 1320 1329 OUTREG(ADPA, INREG(ADPA) & ~ADPA_DAC_ENABLE); 1321 1330 ··· 1439 1448 return ring_space; 1440 1449 } 1441 1450 1442 - static int 1443 - wait_ring(struct intelfb_info *dinfo, int n) 1451 + static int wait_ring(struct intelfb_info *dinfo, int n) 1444 1452 { 1445 1453 int i = 0; 1446 1454 unsigned long end; ··· 1481 1491 return i; 1482 1492 } 1483 1493 1484 - static void 1485 - do_flush(struct intelfb_info *dinfo) { 1494 + static void do_flush(struct intelfb_info *dinfo) 1495 + { 1486 1496 START_RING(2); 1487 1497 OUT_RING(MI_FLUSH | MI_WRITE_DIRTY_STATE | MI_INVALIDATE_MAP_CACHE); 1488 1498 OUT_RING(MI_NOOP); 1489 1499 ADVANCE_RING(); 1490 1500 } 1491 1501 1492 - void 1493 - intelfbhw_do_sync(struct intelfb_info *dinfo) 1502 + void intelfbhw_do_sync(struct intelfb_info *dinfo) 1494 1503 { 1495 1504 #if VERBOSE > 0 1496 1505 DBG_MSG("intelfbhw_do_sync\n"); ··· 1508 1519 dinfo->ring_space = dinfo->ring.size - RING_MIN_FREE; 1509 1520 } 1510 1521 1511 - static void 1512 - refresh_ring(struct intelfb_info *dinfo) 1522 + static void refresh_ring(struct intelfb_info *dinfo) 1513 1523 { 1514 1524 #if VERBOSE > 0 1515 1525 DBG_MSG("refresh_ring\n"); ··· 1519 1531 dinfo->ring_space = get_ring_space(dinfo); 1520 1532 } 1521 1533 1522 - static void 1523 - reset_state(struct intelfb_info *dinfo) 1534 + static void reset_state(struct intelfb_info *dinfo) 1524 1535 { 1525 1536 int i; 1526 1537 u32 tmp; ··· 1549 1562 } 1550 1563 1551 1564 /* Stop the 2D engine, and turn off the ring buffer. */ 1552 - void 1553 - intelfbhw_2d_stop(struct intelfb_info *dinfo) 1565 + void intelfbhw_2d_stop(struct intelfb_info *dinfo) 1554 1566 { 1555 1567 #if VERBOSE > 0 1556 - DBG_MSG("intelfbhw_2d_stop: accel: %d, ring_active: %d\n", dinfo->accel, 1557 - dinfo->ring_active); 1568 + DBG_MSG("intelfbhw_2d_stop: accel: %d, ring_active: %d\n", 1569 + dinfo->accel, dinfo->ring_active); 1558 1570 #endif 1559 1571 1560 1572 if (!dinfo->accel) ··· 1568 1582 * It is assumed that the graphics engine has been stopped by previously 1569 1583 * calling intelfb_2d_stop(). 1570 1584 */ 1571 - void 1572 - intelfbhw_2d_start(struct intelfb_info *dinfo) 1585 + void intelfbhw_2d_start(struct intelfb_info *dinfo) 1573 1586 { 1574 1587 #if VERBOSE > 0 1575 1588 DBG_MSG("intelfbhw_2d_start: accel: %d, ring_active: %d\n", ··· 1592 1607 } 1593 1608 1594 1609 /* 2D fillrect (solid fill or invert) */ 1595 - void 1596 - intelfbhw_do_fillrect(struct intelfb_info *dinfo, u32 x, u32 y, u32 w, u32 h, 1597 - u32 color, u32 pitch, u32 bpp, u32 rop) 1610 + void intelfbhw_do_fillrect(struct intelfb_info *dinfo, u32 x, u32 y, u32 w, 1611 + u32 h, u32 color, u32 pitch, u32 bpp, u32 rop) 1598 1612 { 1599 1613 u32 br00, br09, br13, br14, br16; 1600 1614 ··· 1682 1698 ADVANCE_RING(); 1683 1699 } 1684 1700 1685 - int 1686 - intelfbhw_do_drawglyph(struct intelfb_info *dinfo, u32 fg, u32 bg, u32 w, 1687 - u32 h, const u8* cdat, u32 x, u32 y, u32 pitch, u32 bpp) 1701 + int intelfbhw_do_drawglyph(struct intelfb_info *dinfo, u32 fg, u32 bg, u32 w, 1702 + u32 h, const u8* cdat, u32 x, u32 y, u32 pitch, 1703 + u32 bpp) 1688 1704 { 1689 1705 int nbytes, ndwords, pad, tmp; 1690 1706 u32 br00, br09, br13, br18, br19, br22, br23; ··· 1771 1787 } 1772 1788 1773 1789 /* HW cursor functions. */ 1774 - void 1775 - intelfbhw_cursor_init(struct intelfb_info *dinfo) 1790 + void intelfbhw_cursor_init(struct intelfb_info *dinfo) 1776 1791 { 1777 1792 u32 tmp; 1778 1793 ··· 1802 1819 } 1803 1820 } 1804 1821 1805 - void 1806 - intelfbhw_cursor_hide(struct intelfb_info *dinfo) 1822 + void intelfbhw_cursor_hide(struct intelfb_info *dinfo) 1807 1823 { 1808 1824 u32 tmp; 1809 1825 ··· 1827 1845 } 1828 1846 } 1829 1847 1830 - void 1831 - intelfbhw_cursor_show(struct intelfb_info *dinfo) 1848 + void intelfbhw_cursor_show(struct intelfb_info *dinfo) 1832 1849 { 1833 1850 u32 tmp; 1834 1851 ··· 1856 1875 } 1857 1876 } 1858 1877 1859 - void 1860 - intelfbhw_cursor_setpos(struct intelfb_info *dinfo, int x, int y) 1878 + void intelfbhw_cursor_setpos(struct intelfb_info *dinfo, int x, int y) 1861 1879 { 1862 1880 u32 tmp; 1863 1881 ··· 1874 1894 ((y & CURSOR_POS_MASK) << CURSOR_Y_SHIFT); 1875 1895 OUTREG(CURSOR_A_POSITION, tmp); 1876 1896 1877 - if (IS_I9XX(dinfo)) { 1897 + if (IS_I9XX(dinfo)) 1878 1898 OUTREG(CURSOR_A_BASEADDR, dinfo->cursor.physical); 1879 - } 1880 1899 } 1881 1900 1882 - void 1883 - intelfbhw_cursor_setcolor(struct intelfb_info *dinfo, u32 bg, u32 fg) 1901 + void intelfbhw_cursor_setcolor(struct intelfb_info *dinfo, u32 bg, u32 fg) 1884 1902 { 1885 1903 #if VERBOSE > 0 1886 1904 DBG_MSG("intelfbhw_cursor_setcolor\n"); ··· 1890 1912 OUTREG(CURSOR_A_PALETTE3, bg & CURSOR_PALETTE_MASK); 1891 1913 } 1892 1914 1893 - void 1894 - intelfbhw_cursor_load(struct intelfb_info *dinfo, int width, int height, 1895 - u8 *data) 1915 + void intelfbhw_cursor_load(struct intelfb_info *dinfo, int width, int height, 1916 + u8 *data) 1896 1917 { 1897 1918 u8 __iomem *addr = (u8 __iomem *)dinfo->cursor.virtual; 1898 1919 int i, j, w = width / 8; ··· 1919 1942 } 1920 1943 } 1921 1944 1922 - void 1923 - intelfbhw_cursor_reset(struct intelfb_info *dinfo) { 1945 + void intelfbhw_cursor_reset(struct intelfb_info *dinfo) 1946 + { 1924 1947 u8 __iomem *addr = (u8 __iomem *)dinfo->cursor.virtual; 1925 1948 int i, j; 1926 1949 ··· 2024 2047 } 2025 2048 } 2026 2049 2027 - int 2028 - intelfbhw_wait_for_vsync(struct intelfb_info *dinfo, u32 pipe) { 2050 + int intelfbhw_wait_for_vsync(struct intelfb_info *dinfo, u32 pipe) 2051 + { 2029 2052 struct intelfb_vsync *vsync; 2030 2053 unsigned int count; 2031 2054 int ret; ··· 2039 2062 } 2040 2063 2041 2064 ret = intelfbhw_enable_irq(dinfo, 0); 2042 - if (ret) { 2065 + if (ret) 2043 2066 return ret; 2044 - } 2045 2067 2046 2068 count = vsync->count; 2047 - ret = wait_event_interruptible_timeout(vsync->wait, count != vsync->count, HZ/10); 2048 - if (ret < 0) { 2069 + ret = wait_event_interruptible_timeout(vsync->wait, 2070 + count != vsync->count, HZ / 10); 2071 + if (ret < 0) 2049 2072 return ret; 2050 - } 2051 2073 if (ret == 0) { 2052 2074 intelfbhw_enable_irq(dinfo, 1); 2053 2075 DBG_MSG("wait_for_vsync timed out!\n");
+7 -7
drivers/video/intelfb/intelfbhw.h
··· 83 83 */ 84 84 #define RING_MIN_FREE 64 85 85 86 - #define IPEHR 0x2088 86 + #define IPEHR 0x2088 87 87 88 88 #define INSTDONE 0x2090 89 89 #define PRI_RING_EMPTY 1 ··· 128 128 129 129 #define GPIOA 0x5010 130 130 #define GPIOB 0x5014 131 - #define GPIOC 0x5018 // this may be external DDC on i830 132 - #define GPIOD 0x501C // this is DVO DDC 133 - #define GPIOE 0x5020 // this is DVO i2C 131 + #define GPIOC 0x5018 /* this may be external DDC on i830 */ 132 + #define GPIOD 0x501C /* this is DVO DDC */ 133 + #define GPIOE 0x5020 /* this is DVO i2C */ 134 134 #define GPIOF 0x5024 135 135 136 136 /* PLL registers */ ··· 269 269 #define PORT_ENABLE (1 << 31) 270 270 #define PORT_PIPE_SELECT_SHIFT 30 271 271 #define PORT_TV_FLAGS_MASK 0xFF 272 - #define PORT_TV_FLAGS 0xC4 // ripped from my BIOS 273 - // to understand and correct 272 + #define PORT_TV_FLAGS 0xC4 /* ripped from my BIOS 273 + to understand and correct */ 274 274 275 275 #define DVOA_SRCDIM 0x61124 276 276 #define DVOB_SRCDIM 0x61144 ··· 369 369 #define DISPPLANE_8BPP (0x2<<26) 370 370 #define DISPPLANE_15_16BPP (0x4<<26) 371 371 #define DISPPLANE_16BPP (0x5<<26) 372 - #define DISPPLANE_32BPP_NO_ALPHA (0x6<<26) 372 + #define DISPPLANE_32BPP_NO_ALPHA (0x6<<26) 373 373 #define DISPPLANE_32BPP (0x7<<26) 374 374 #define DISPPLANE_STEREO_ENABLE (1<<25) 375 375 #define DISPPLANE_STEREO_DISABLE 0