1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/module.h> 3 #include <linux/kernel.h> 4 #include <linux/errno.h> 5 #include <linux/string.h> 6 #include <linux/mm.h> 7 #include <linux/slab.h> 8 #include <linux/delay.h> 9 #include <linux/fb.h> 10 #include <linux/ioport.h> 11 #include <linux/init.h> 12 #include <linux/pci.h> 13 #include <linux/vmalloc.h> 14 #include <linux/pagemap.h> 15 #include <linux/console.h> 16 #ifdef CONFIG_MTRR 17 #include <asm/mtrr.h> 18 #endif 19 #include <linux/platform_device.h> 20 #include <linux/screen_info.h> 21 #include <linux/sizes.h> 22 23 #include "sm750.h" 24 #include "ddk750.h" 25 #include "sm750_accel.h" 26 27 void __iomem *mmio750; 28 29 int hw_sm750_map(struct sm750_dev *sm750_dev, struct pci_dev *pdev) 30 { 31 int ret; 32 33 ret = 0; 34 35 sm750_dev->vidreg_start = pci_resource_start(pdev, 1); 36 sm750_dev->vidreg_size = SZ_2M; 37 38 pr_info("mmio phyAddr = %lx\n", sm750_dev->vidreg_start); 39 40 /* 41 * reserve the vidreg space of smi adaptor 42 * if you do this, you need to add release region code 43 * in lynxfb_remove, or memory will not be mapped again 44 * successfully 45 */ 46 ret = pci_request_region(pdev, 1, "sm750fb"); 47 if (ret) { 48 pr_err("Can not request PCI regions.\n"); 49 goto exit; 50 } 51 52 /* now map mmio and vidmem */ 53 sm750_dev->pvReg = ioremap(sm750_dev->vidreg_start, 54 sm750_dev->vidreg_size); 55 if (!sm750_dev->pvReg) { 56 pr_err("mmio failed\n"); 57 ret = -EFAULT; 58 goto exit; 59 } else { 60 pr_info("mmio virtual addr = %p\n", sm750_dev->pvReg); 61 } 62 63 sm750_dev->accel.dprBase = sm750_dev->pvReg + DE_BASE_ADDR_TYPE1; 64 sm750_dev->accel.dpPortBase = sm750_dev->pvReg + DE_PORT_ADDR_TYPE1; 65 66 mmio750 = sm750_dev->pvReg; 67 sm750_set_chip_type(sm750_dev->devid, sm750_dev->revid); 68 69 sm750_dev->vidmem_start = pci_resource_start(pdev, 0); 70 /* 71 * don't use pdev_resource[x].end - resource[x].start to 72 * calculate the resource size, it's only the maximum available 73 * size but not the actual size, using 74 * @ddk750_get_vm_size function can be safe. 75 */ 76 sm750_dev->vidmem_size = ddk750_get_vm_size(); 77 pr_info("video memory phyAddr = %lx, size = %u bytes\n", 78 sm750_dev->vidmem_start, sm750_dev->vidmem_size); 79 80 /* reserve the vidmem space of smi adaptor */ 81 sm750_dev->pvMem = ioremap_wc(sm750_dev->vidmem_start, 82 sm750_dev->vidmem_size); 83 if (!sm750_dev->pvMem) { 84 pr_err("Map video memory failed\n"); 85 ret = -EFAULT; 86 goto exit; 87 } else { 88 pr_info("video memory vaddr = %p\n", sm750_dev->pvMem); 89 } 90 exit: 91 return ret; 92 } 93 94 int hw_sm750_inithw(struct sm750_dev *sm750_dev, struct pci_dev *pdev) 95 { 96 struct init_status *parm; 97 98 parm = &sm750_dev->initParm; 99 if (parm->chip_clk == 0) 100 parm->chip_clk = (sm750_get_chip_type() == SM750LE) ? 101 DEFAULT_SM750LE_CHIP_CLOCK : 102 DEFAULT_SM750_CHIP_CLOCK; 103 104 if (parm->mem_clk == 0) 105 parm->mem_clk = parm->chip_clk; 106 if (parm->master_clk == 0) 107 parm->master_clk = parm->chip_clk / 3; 108 109 ddk750_init_hw((struct initchip_param *)&sm750_dev->initParm); 110 /* for sm718, open pci burst */ 111 if (sm750_dev->devid == 0x718) { 112 poke32(SYSTEM_CTRL, 113 peek32(SYSTEM_CTRL) | SYSTEM_CTRL_PCI_BURST); 114 } 115 116 if (sm750_get_chip_type() != SM750LE) { 117 unsigned int val; 118 /* does user need CRT? */ 119 if (sm750_dev->nocrt) { 120 poke32(MISC_CTRL, 121 peek32(MISC_CTRL) | MISC_CTRL_DAC_POWER_OFF); 122 /* shut off dpms */ 123 val = peek32(SYSTEM_CTRL) & ~SYSTEM_CTRL_DPMS_MASK; 124 val |= SYSTEM_CTRL_DPMS_VPHN; 125 poke32(SYSTEM_CTRL, val); 126 } else { 127 poke32(MISC_CTRL, 128 peek32(MISC_CTRL) & ~MISC_CTRL_DAC_POWER_OFF); 129 /* turn on dpms */ 130 val = peek32(SYSTEM_CTRL) & ~SYSTEM_CTRL_DPMS_MASK; 131 val |= SYSTEM_CTRL_DPMS_VPHP; 132 poke32(SYSTEM_CTRL, val); 133 } 134 135 val = peek32(PANEL_DISPLAY_CTRL) & 136 ~(PANEL_DISPLAY_CTRL_DUAL_DISPLAY | 137 PANEL_DISPLAY_CTRL_DOUBLE_PIXEL); 138 switch (sm750_dev->pnltype) { 139 case sm750_24TFT: 140 break; 141 case sm750_doubleTFT: 142 val |= PANEL_DISPLAY_CTRL_DOUBLE_PIXEL; 143 break; 144 case sm750_dualTFT: 145 val |= PANEL_DISPLAY_CTRL_DUAL_DISPLAY; 146 break; 147 } 148 poke32(PANEL_DISPLAY_CTRL, val); 149 } else { 150 /* 151 * for 750LE, no DVI chip initialization 152 * makes Monitor no signal 153 * 154 * Set up GPIO for software I2C to program DVI chip in the 155 * Xilinx SP605 board, in order to have video signal. 156 */ 157 sm750_sw_i2c_init(0, 1); 158 159 /* 160 * Customer may NOT use CH7301 DVI chip, which has to be 161 * initialized differently. 162 */ 163 if (sm750_sw_i2c_read_reg(0xec, 0x4a) == 0x95) { 164 /* 165 * The following register values for CH7301 are from 166 * Chrontel app note and our experiment. 167 */ 168 pr_info("yes,CH7301 DVI chip found\n"); 169 sm750_sw_i2c_write_reg(0xec, 0x1d, 0x16); 170 sm750_sw_i2c_write_reg(0xec, 0x21, 0x9); 171 sm750_sw_i2c_write_reg(0xec, 0x49, 0xC0); 172 pr_info("okay,CH7301 DVI chip setup done\n"); 173 } 174 } 175 176 /* init 2d engine */ 177 if (!sm750_dev->accel_off) 178 hw_sm750_initAccel(sm750_dev); 179 180 return 0; 181 } 182 183 int hw_sm750_output_setMode(struct lynxfb_output *output, 184 struct fb_var_screeninfo *var, 185 struct fb_fix_screeninfo *fix) 186 { 187 int ret; 188 enum disp_output disp_set; 189 int channel; 190 191 ret = 0; 192 disp_set = 0; 193 channel = *output->channel; 194 195 if (sm750_get_chip_type() != SM750LE) { 196 if (channel == sm750_primary) { 197 pr_info("primary channel\n"); 198 if (output->paths & sm750_panel) 199 disp_set |= do_LCD1_PRI; 200 if (output->paths & sm750_crt) 201 disp_set |= do_CRT_PRI; 202 203 } else { 204 pr_info("secondary channel\n"); 205 if (output->paths & sm750_panel) 206 disp_set |= do_LCD1_SEC; 207 if (output->paths & sm750_crt) 208 disp_set |= do_CRT_SEC; 209 } 210 ddk750_set_logical_disp_out(disp_set); 211 } else { 212 /* just open DISPLAY_CONTROL_750LE register bit 3:0 */ 213 u32 reg; 214 215 reg = peek32(DISPLAY_CONTROL_750LE); 216 reg |= 0xf; 217 poke32(DISPLAY_CONTROL_750LE, reg); 218 } 219 220 pr_info("ddk setlogicdispout done\n"); 221 return ret; 222 } 223 224 int hw_sm750_crtc_checkMode(struct lynxfb_crtc *crtc, 225 struct fb_var_screeninfo *var) 226 { 227 struct sm750_dev *sm750_dev; 228 struct lynxfb_par *par = container_of(crtc, struct lynxfb_par, crtc); 229 230 sm750_dev = par->dev; 231 232 switch (var->bits_per_pixel) { 233 case 8: 234 case 16: 235 break; 236 case 32: 237 if (sm750_dev->revid == SM750LE_REVISION_ID) { 238 pr_debug("750le do not support 32bpp\n"); 239 return -EINVAL; 240 } 241 break; 242 default: 243 return -EINVAL; 244 } 245 246 return 0; 247 } 248 249 /* set the controller's mode for @crtc charged with @var and @fix parameters */ 250 int hw_sm750_crtc_setMode(struct lynxfb_crtc *crtc, 251 struct fb_var_screeninfo *var, 252 struct fb_fix_screeninfo *fix) 253 { 254 int ret, fmt; 255 u32 reg; 256 struct mode_parameter modparm; 257 enum clock_type clock; 258 struct sm750_dev *sm750_dev; 259 struct lynxfb_par *par; 260 261 ret = 0; 262 par = container_of(crtc, struct lynxfb_par, crtc); 263 sm750_dev = par->dev; 264 265 if (!sm750_dev->accel_off) { 266 /* set 2d engine pixel format according to mode bpp */ 267 switch (var->bits_per_pixel) { 268 case 8: 269 fmt = 0; 270 break; 271 case 16: 272 fmt = 1; 273 break; 274 case 32: 275 default: 276 fmt = 2; 277 break; 278 } 279 sm750_hw_set2dformat(&sm750_dev->accel, fmt); 280 } 281 282 /* set timing */ 283 modparm.pixel_clock = ps_to_hz(var->pixclock); 284 modparm.vertical_sync_polarity = (var->sync & FB_SYNC_HOR_HIGH_ACT) 285 ? POS : NEG; 286 modparm.horizontal_sync_polarity = (var->sync & FB_SYNC_VERT_HIGH_ACT) 287 ? POS : NEG; 288 modparm.clock_phase_polarity = (var->sync & FB_SYNC_COMP_HIGH_ACT) 289 ? POS : NEG; 290 modparm.horizontal_display_end = var->xres; 291 modparm.horizontal_sync_width = var->hsync_len; 292 modparm.horizontal_sync_start = var->xres + var->right_margin; 293 modparm.horizontal_total = var->xres + var->left_margin + 294 var->right_margin + var->hsync_len; 295 modparm.vertical_display_end = var->yres; 296 modparm.vertical_sync_height = var->vsync_len; 297 modparm.vertical_sync_start = var->yres + var->lower_margin; 298 modparm.vertical_total = var->yres + var->upper_margin + 299 var->lower_margin + var->vsync_len; 300 301 /* choose pll */ 302 if (crtc->channel != sm750_secondary) 303 clock = PRIMARY_PLL; 304 else 305 clock = SECONDARY_PLL; 306 307 pr_debug("Request pixel clock = %lu\n", modparm.pixel_clock); 308 ret = ddk750_setModeTiming(&modparm, clock); 309 if (ret) { 310 pr_err("Set mode timing failed\n"); 311 goto exit; 312 } 313 314 if (crtc->channel != sm750_secondary) { 315 /* set pitch, offset, width, start address, etc... */ 316 poke32(PANEL_FB_ADDRESS, 317 crtc->oScreen & PANEL_FB_ADDRESS_ADDRESS_MASK); 318 319 reg = var->xres * (var->bits_per_pixel >> 3); 320 /* 321 * crtc->channel is not equal to par->index on numeric, 322 * be aware of that 323 */ 324 reg = ALIGN(reg, crtc->line_pad); 325 reg = (reg << PANEL_FB_WIDTH_WIDTH_SHIFT) & 326 PANEL_FB_WIDTH_WIDTH_MASK; 327 reg |= (fix->line_length & PANEL_FB_WIDTH_OFFSET_MASK); 328 poke32(PANEL_FB_WIDTH, reg); 329 330 reg = ((var->xres - 1) << PANEL_WINDOW_WIDTH_WIDTH_SHIFT) & 331 PANEL_WINDOW_WIDTH_WIDTH_MASK; 332 reg |= (var->xoffset & PANEL_WINDOW_WIDTH_X_MASK); 333 poke32(PANEL_WINDOW_WIDTH, reg); 334 335 reg = (var->yres_virtual - 1) << 336 PANEL_WINDOW_HEIGHT_HEIGHT_SHIFT; 337 reg &= PANEL_WINDOW_HEIGHT_HEIGHT_MASK; 338 reg |= (var->yoffset & PANEL_WINDOW_HEIGHT_Y_MASK); 339 poke32(PANEL_WINDOW_HEIGHT, reg); 340 341 poke32(PANEL_PLANE_TL, 0); 342 343 reg = ((var->yres - 1) << PANEL_PLANE_BR_BOTTOM_SHIFT) & 344 PANEL_PLANE_BR_BOTTOM_MASK; 345 reg |= ((var->xres - 1) & PANEL_PLANE_BR_RIGHT_MASK); 346 poke32(PANEL_PLANE_BR, reg); 347 348 /* set pixel format */ 349 reg = peek32(PANEL_DISPLAY_CTRL); 350 poke32(PANEL_DISPLAY_CTRL, reg | (var->bits_per_pixel >> 4)); 351 } else { 352 /* not implemented now */ 353 poke32(CRT_FB_ADDRESS, crtc->oScreen); 354 reg = var->xres * (var->bits_per_pixel >> 3); 355 /* 356 * crtc->channel is not equal to par->index on numeric, 357 * be aware of that 358 */ 359 reg = ALIGN(reg, crtc->line_pad) << CRT_FB_WIDTH_WIDTH_SHIFT; 360 reg &= CRT_FB_WIDTH_WIDTH_MASK; 361 reg |= (fix->line_length & CRT_FB_WIDTH_OFFSET_MASK); 362 poke32(CRT_FB_WIDTH, reg); 363 364 /* SET PIXEL FORMAT */ 365 reg = peek32(CRT_DISPLAY_CTRL); 366 reg |= ((var->bits_per_pixel >> 4) & 367 CRT_DISPLAY_CTRL_FORMAT_MASK); 368 poke32(CRT_DISPLAY_CTRL, reg); 369 } 370 371 exit: 372 return ret; 373 } 374 375 int hw_sm750_setColReg(struct lynxfb_crtc *crtc, ushort index, 376 ushort red, ushort green, ushort blue) 377 { 378 static unsigned int add[] = {PANEL_PALETTE_RAM, CRT_PALETTE_RAM}; 379 380 poke32(add[crtc->channel] + index * 4, 381 (red << 16) | (green << 8) | blue); 382 return 0; 383 } 384 385 int hw_sm750le_setBLANK(struct lynxfb_output *output, int blank) 386 { 387 int dpms, crtdb; 388 389 switch (blank) { 390 case FB_BLANK_UNBLANK: 391 dpms = CRT_DISPLAY_CTRL_DPMS_0; 392 crtdb = 0; 393 break; 394 case FB_BLANK_NORMAL: 395 dpms = CRT_DISPLAY_CTRL_DPMS_0; 396 crtdb = CRT_DISPLAY_CTRL_BLANK; 397 break; 398 case FB_BLANK_VSYNC_SUSPEND: 399 dpms = CRT_DISPLAY_CTRL_DPMS_2; 400 crtdb = CRT_DISPLAY_CTRL_BLANK; 401 break; 402 case FB_BLANK_HSYNC_SUSPEND: 403 dpms = CRT_DISPLAY_CTRL_DPMS_1; 404 crtdb = CRT_DISPLAY_CTRL_BLANK; 405 break; 406 case FB_BLANK_POWERDOWN: 407 dpms = CRT_DISPLAY_CTRL_DPMS_3; 408 crtdb = CRT_DISPLAY_CTRL_BLANK; 409 break; 410 default: 411 return -EINVAL; 412 } 413 414 if (output->paths & sm750_crt) { 415 unsigned int val; 416 417 val = peek32(CRT_DISPLAY_CTRL) & ~CRT_DISPLAY_CTRL_DPMS_MASK; 418 poke32(CRT_DISPLAY_CTRL, val | dpms); 419 420 val = peek32(CRT_DISPLAY_CTRL) & ~CRT_DISPLAY_CTRL_BLANK; 421 poke32(CRT_DISPLAY_CTRL, val | crtdb); 422 } 423 return 0; 424 } 425 426 int hw_sm750_setBLANK(struct lynxfb_output *output, int blank) 427 { 428 unsigned int dpms, pps, crtdb; 429 430 dpms = 0; 431 pps = 0; 432 crtdb = 0; 433 434 switch (blank) { 435 case FB_BLANK_UNBLANK: 436 pr_debug("flag = FB_BLANK_UNBLANK\n"); 437 dpms = SYSTEM_CTRL_DPMS_VPHP; 438 pps = PANEL_DISPLAY_CTRL_DATA; 439 break; 440 case FB_BLANK_NORMAL: 441 pr_debug("flag = FB_BLANK_NORMAL\n"); 442 dpms = SYSTEM_CTRL_DPMS_VPHP; 443 crtdb = CRT_DISPLAY_CTRL_BLANK; 444 break; 445 case FB_BLANK_VSYNC_SUSPEND: 446 dpms = SYSTEM_CTRL_DPMS_VNHP; 447 crtdb = CRT_DISPLAY_CTRL_BLANK; 448 break; 449 case FB_BLANK_HSYNC_SUSPEND: 450 dpms = SYSTEM_CTRL_DPMS_VPHN; 451 crtdb = CRT_DISPLAY_CTRL_BLANK; 452 break; 453 case FB_BLANK_POWERDOWN: 454 dpms = SYSTEM_CTRL_DPMS_VNHN; 455 crtdb = CRT_DISPLAY_CTRL_BLANK; 456 break; 457 } 458 459 if (output->paths & sm750_crt) { 460 unsigned int val = peek32(SYSTEM_CTRL) & ~SYSTEM_CTRL_DPMS_MASK; 461 462 poke32(SYSTEM_CTRL, val | dpms); 463 464 val = peek32(CRT_DISPLAY_CTRL) & ~CRT_DISPLAY_CTRL_BLANK; 465 poke32(CRT_DISPLAY_CTRL, val | crtdb); 466 } 467 468 if (output->paths & sm750_panel) { 469 unsigned int val = peek32(PANEL_DISPLAY_CTRL); 470 471 val &= ~PANEL_DISPLAY_CTRL_DATA; 472 val |= pps; 473 poke32(PANEL_DISPLAY_CTRL, val); 474 } 475 476 return 0; 477 } 478 479 void hw_sm750_initAccel(struct sm750_dev *sm750_dev) 480 { 481 u32 reg; 482 483 sm750_enable_2d_engine(1); 484 485 if (sm750_get_chip_type() == SM750LE) { 486 reg = peek32(DE_STATE1); 487 reg |= DE_STATE1_DE_ABORT; 488 poke32(DE_STATE1, reg); 489 490 reg = peek32(DE_STATE1); 491 reg &= ~DE_STATE1_DE_ABORT; 492 poke32(DE_STATE1, reg); 493 494 } else { 495 /* engine reset */ 496 reg = peek32(SYSTEM_CTRL); 497 reg |= SYSTEM_CTRL_DE_ABORT; 498 poke32(SYSTEM_CTRL, reg); 499 500 reg = peek32(SYSTEM_CTRL); 501 reg &= ~SYSTEM_CTRL_DE_ABORT; 502 poke32(SYSTEM_CTRL, reg); 503 } 504 505 /* call 2d init */ 506 sm750_dev->accel.de_init(&sm750_dev->accel); 507 } 508 509 int hw_sm750le_deWait(void) 510 { 511 int i = 0x10000000; 512 unsigned int mask = DE_STATE2_DE_STATUS_BUSY | DE_STATE2_DE_FIFO_EMPTY | 513 DE_STATE2_DE_MEM_FIFO_EMPTY; 514 515 while (i--) { 516 unsigned int val = peek32(DE_STATE2); 517 518 if ((val & mask) == 519 (DE_STATE2_DE_FIFO_EMPTY | DE_STATE2_DE_MEM_FIFO_EMPTY)) 520 return 0; 521 } 522 /* timeout error */ 523 return -1; 524 } 525 526 int hw_sm750_deWait(void) 527 { 528 int i = 0x10000000; 529 unsigned int mask = SYSTEM_CTRL_DE_STATUS_BUSY | 530 SYSTEM_CTRL_DE_FIFO_EMPTY | 531 SYSTEM_CTRL_DE_MEM_FIFO_EMPTY; 532 533 while (i--) { 534 unsigned int val = peek32(SYSTEM_CTRL); 535 536 if ((val & mask) == 537 (SYSTEM_CTRL_DE_FIFO_EMPTY | SYSTEM_CTRL_DE_MEM_FIFO_EMPTY)) 538 return 0; 539 } 540 /* timeout error */ 541 return -1; 542 } 543 544 int hw_sm750_pan_display(struct lynxfb_crtc *crtc, 545 const struct fb_var_screeninfo *var, 546 const struct fb_info *info) 547 { 548 u32 total; 549 /* check params */ 550 if ((var->xoffset + var->xres > var->xres_virtual) || 551 (var->yoffset + var->yres > var->yres_virtual)) { 552 return -EINVAL; 553 } 554 555 total = var->yoffset * info->fix.line_length + 556 ((var->xoffset * var->bits_per_pixel) >> 3); 557 total += crtc->oScreen; 558 if (crtc->channel == sm750_primary) { 559 poke32(PANEL_FB_ADDRESS, 560 peek32(PANEL_FB_ADDRESS) | 561 (total & PANEL_FB_ADDRESS_ADDRESS_MASK)); 562 } else { 563 poke32(CRT_FB_ADDRESS, 564 peek32(CRT_FB_ADDRESS) | 565 (total & CRT_FB_ADDRESS_ADDRESS_MASK)); 566 } 567 return 0; 568 } 569