1 // SPDX-License-Identifier: GPL-2.0-only 2 /* tcx.c: TCX frame buffer driver 3 * 4 * Copyright (C) 2003, 2006 David S. Miller (davem@davemloft.net) 5 * Copyright (C) 1996,1998 Jakub Jelinek (jj@ultra.linux.cz) 6 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx) 7 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be) 8 * 9 * Driver layout based loosely on tgafb.c, see that file for credits. 10 */ 11 12 #include <linux/module.h> 13 #include <linux/kernel.h> 14 #include <linux/errno.h> 15 #include <linux/string.h> 16 #include <linux/delay.h> 17 #include <linux/init.h> 18 #include <linux/fb.h> 19 #include <linux/mm.h> 20 #include <linux/of_device.h> 21 22 #include <asm/io.h> 23 #include <asm/fbio.h> 24 25 #include "sbuslib.h" 26 27 /* 28 * Local functions. 29 */ 30 31 static int tcx_setcolreg(unsigned, unsigned, unsigned, unsigned, 32 unsigned, struct fb_info *); 33 static int tcx_blank(int, struct fb_info *); 34 35 static int tcx_mmap(struct fb_info *, struct vm_area_struct *); 36 static int tcx_ioctl(struct fb_info *, unsigned int, unsigned long); 37 static int tcx_pan_display(struct fb_var_screeninfo *, struct fb_info *); 38 39 /* 40 * Frame buffer operations 41 */ 42 43 static const struct fb_ops tcx_ops = { 44 .owner = THIS_MODULE, 45 .fb_setcolreg = tcx_setcolreg, 46 .fb_blank = tcx_blank, 47 .fb_pan_display = tcx_pan_display, 48 .fb_fillrect = cfb_fillrect, 49 .fb_copyarea = cfb_copyarea, 50 .fb_imageblit = cfb_imageblit, 51 .fb_mmap = tcx_mmap, 52 .fb_ioctl = tcx_ioctl, 53 #ifdef CONFIG_COMPAT 54 .fb_compat_ioctl = sbusfb_compat_ioctl, 55 #endif 56 }; 57 58 /* THC definitions */ 59 #define TCX_THC_MISC_REV_SHIFT 16 60 #define TCX_THC_MISC_REV_MASK 15 61 #define TCX_THC_MISC_VSYNC_DIS (1 << 25) 62 #define TCX_THC_MISC_HSYNC_DIS (1 << 24) 63 #define TCX_THC_MISC_RESET (1 << 12) 64 #define TCX_THC_MISC_VIDEO (1 << 10) 65 #define TCX_THC_MISC_SYNC (1 << 9) 66 #define TCX_THC_MISC_VSYNC (1 << 8) 67 #define TCX_THC_MISC_SYNC_ENAB (1 << 7) 68 #define TCX_THC_MISC_CURS_RES (1 << 6) 69 #define TCX_THC_MISC_INT_ENAB (1 << 5) 70 #define TCX_THC_MISC_INT (1 << 4) 71 #define TCX_THC_MISC_INIT 0x9f 72 #define TCX_THC_REV_REV_SHIFT 20 73 #define TCX_THC_REV_REV_MASK 15 74 #define TCX_THC_REV_MINREV_SHIFT 28 75 #define TCX_THC_REV_MINREV_MASK 15 76 77 /* The contents are unknown */ 78 struct tcx_tec { 79 u32 tec_matrix; 80 u32 tec_clip; 81 u32 tec_vdc; 82 }; 83 84 struct tcx_thc { 85 u32 thc_rev; 86 u32 thc_pad0[511]; 87 u32 thc_hs; /* hsync timing */ 88 u32 thc_hsdvs; 89 u32 thc_hd; 90 u32 thc_vs; /* vsync timing */ 91 u32 thc_vd; 92 u32 thc_refresh; 93 u32 thc_misc; 94 u32 thc_pad1[56]; 95 u32 thc_cursxy; /* cursor x,y position (16 bits each) */ 96 u32 thc_cursmask[32]; /* cursor mask bits */ 97 u32 thc_cursbits[32]; /* what to show where mask enabled */ 98 }; 99 100 struct bt_regs { 101 u32 addr; 102 u32 color_map; 103 u32 control; 104 u32 cursor; 105 }; 106 107 #define TCX_MMAP_ENTRIES 14 108 109 struct tcx_par { 110 spinlock_t lock; 111 struct bt_regs __iomem *bt; 112 struct tcx_thc __iomem *thc; 113 struct tcx_tec __iomem *tec; 114 u32 __iomem *cplane; 115 116 u32 flags; 117 #define TCX_FLAG_BLANKED 0x00000001 118 119 unsigned long which_io; 120 121 struct sbus_mmap_map mmap_map[TCX_MMAP_ENTRIES]; 122 int lowdepth; 123 }; 124 125 /* Reset control plane so that WID is 8-bit plane. */ 126 static void __tcx_set_control_plane(struct fb_info *info) 127 { 128 struct tcx_par *par = info->par; 129 u32 __iomem *p, *pend; 130 131 if (par->lowdepth) 132 return; 133 134 p = par->cplane; 135 if (p == NULL) 136 return; 137 for (pend = p + info->fix.smem_len; p < pend; p++) { 138 u32 tmp = sbus_readl(p); 139 140 tmp &= 0xffffff; 141 sbus_writel(tmp, p); 142 } 143 } 144 145 static void tcx_reset(struct fb_info *info) 146 { 147 struct tcx_par *par = (struct tcx_par *) info->par; 148 unsigned long flags; 149 150 spin_lock_irqsave(&par->lock, flags); 151 __tcx_set_control_plane(info); 152 spin_unlock_irqrestore(&par->lock, flags); 153 } 154 155 static int tcx_pan_display(struct fb_var_screeninfo *var, struct fb_info *info) 156 { 157 tcx_reset(info); 158 return 0; 159 } 160 161 /** 162 * tcx_setcolreg - Optional function. Sets a color register. 163 * @regno: boolean, 0 copy local, 1 get_user() function 164 * @red: frame buffer colormap structure 165 * @green: The green value which can be up to 16 bits wide 166 * @blue: The blue value which can be up to 16 bits wide. 167 * @transp: If supported the alpha value which can be up to 16 bits wide. 168 * @info: frame buffer info structure 169 */ 170 static int tcx_setcolreg(unsigned regno, 171 unsigned red, unsigned green, unsigned blue, 172 unsigned transp, struct fb_info *info) 173 { 174 struct tcx_par *par = (struct tcx_par *) info->par; 175 struct bt_regs __iomem *bt = par->bt; 176 unsigned long flags; 177 178 if (regno >= 256) 179 return 1; 180 181 red >>= 8; 182 green >>= 8; 183 blue >>= 8; 184 185 spin_lock_irqsave(&par->lock, flags); 186 187 sbus_writel(regno << 24, &bt->addr); 188 sbus_writel(red << 24, &bt->color_map); 189 sbus_writel(green << 24, &bt->color_map); 190 sbus_writel(blue << 24, &bt->color_map); 191 192 spin_unlock_irqrestore(&par->lock, flags); 193 194 return 0; 195 } 196 197 /** 198 * tcx_blank - Optional function. Blanks the display. 199 * @blank: the blank mode we want. 200 * @info: frame buffer structure that represents a single frame buffer 201 */ 202 static int 203 tcx_blank(int blank, struct fb_info *info) 204 { 205 struct tcx_par *par = (struct tcx_par *) info->par; 206 struct tcx_thc __iomem *thc = par->thc; 207 unsigned long flags; 208 u32 val; 209 210 spin_lock_irqsave(&par->lock, flags); 211 212 val = sbus_readl(&thc->thc_misc); 213 214 switch (blank) { 215 case FB_BLANK_UNBLANK: /* Unblanking */ 216 val &= ~(TCX_THC_MISC_VSYNC_DIS | 217 TCX_THC_MISC_HSYNC_DIS); 218 val |= TCX_THC_MISC_VIDEO; 219 par->flags &= ~TCX_FLAG_BLANKED; 220 break; 221 222 case FB_BLANK_NORMAL: /* Normal blanking */ 223 val &= ~TCX_THC_MISC_VIDEO; 224 par->flags |= TCX_FLAG_BLANKED; 225 break; 226 227 case FB_BLANK_VSYNC_SUSPEND: /* VESA blank (vsync off) */ 228 val |= TCX_THC_MISC_VSYNC_DIS; 229 break; 230 case FB_BLANK_HSYNC_SUSPEND: /* VESA blank (hsync off) */ 231 val |= TCX_THC_MISC_HSYNC_DIS; 232 break; 233 234 case FB_BLANK_POWERDOWN: /* Poweroff */ 235 break; 236 } 237 238 sbus_writel(val, &thc->thc_misc); 239 240 spin_unlock_irqrestore(&par->lock, flags); 241 242 return 0; 243 } 244 245 static struct sbus_mmap_map __tcx_mmap_map[TCX_MMAP_ENTRIES] = { 246 { 247 .voff = TCX_RAM8BIT, 248 .size = SBUS_MMAP_FBSIZE(1) 249 }, 250 { 251 .voff = TCX_RAM24BIT, 252 .size = SBUS_MMAP_FBSIZE(4) 253 }, 254 { 255 .voff = TCX_UNK3, 256 .size = SBUS_MMAP_FBSIZE(8) 257 }, 258 { 259 .voff = TCX_UNK4, 260 .size = SBUS_MMAP_FBSIZE(8) 261 }, 262 { 263 .voff = TCX_CONTROLPLANE, 264 .size = SBUS_MMAP_FBSIZE(4) 265 }, 266 { 267 .voff = TCX_UNK6, 268 .size = SBUS_MMAP_FBSIZE(8) 269 }, 270 { 271 .voff = TCX_UNK7, 272 .size = SBUS_MMAP_FBSIZE(8) 273 }, 274 { 275 .voff = TCX_TEC, 276 .size = PAGE_SIZE 277 }, 278 { 279 .voff = TCX_BTREGS, 280 .size = PAGE_SIZE 281 }, 282 { 283 .voff = TCX_THC, 284 .size = PAGE_SIZE 285 }, 286 { 287 .voff = TCX_DHC, 288 .size = PAGE_SIZE 289 }, 290 { 291 .voff = TCX_ALT, 292 .size = PAGE_SIZE 293 }, 294 { 295 .voff = TCX_UNK2, 296 .size = 0x20000 297 }, 298 { .size = 0 } 299 }; 300 301 static int tcx_mmap(struct fb_info *info, struct vm_area_struct *vma) 302 { 303 struct tcx_par *par = (struct tcx_par *)info->par; 304 305 return sbusfb_mmap_helper(par->mmap_map, 306 info->fix.smem_start, info->fix.smem_len, 307 par->which_io, vma); 308 } 309 310 static int tcx_ioctl(struct fb_info *info, unsigned int cmd, 311 unsigned long arg) 312 { 313 struct tcx_par *par = (struct tcx_par *) info->par; 314 315 return sbusfb_ioctl_helper(cmd, arg, info, 316 FBTYPE_TCXCOLOR, 317 (par->lowdepth ? 8 : 24), 318 info->fix.smem_len); 319 } 320 321 /* 322 * Initialisation 323 */ 324 325 static void 326 tcx_init_fix(struct fb_info *info, int linebytes) 327 { 328 struct tcx_par *par = (struct tcx_par *)info->par; 329 const char *tcx_name; 330 331 if (par->lowdepth) 332 tcx_name = "TCX8"; 333 else 334 tcx_name = "TCX24"; 335 336 strscpy(info->fix.id, tcx_name, sizeof(info->fix.id)); 337 338 info->fix.type = FB_TYPE_PACKED_PIXELS; 339 info->fix.visual = FB_VISUAL_PSEUDOCOLOR; 340 341 info->fix.line_length = linebytes; 342 343 info->fix.accel = FB_ACCEL_SUN_TCX; 344 } 345 346 static void tcx_unmap_regs(struct platform_device *op, struct fb_info *info, 347 struct tcx_par *par) 348 { 349 if (par->tec) 350 of_iounmap(&op->resource[7], 351 par->tec, sizeof(struct tcx_tec)); 352 if (par->thc) 353 of_iounmap(&op->resource[9], 354 par->thc, sizeof(struct tcx_thc)); 355 if (par->bt) 356 of_iounmap(&op->resource[8], 357 par->bt, sizeof(struct bt_regs)); 358 if (par->cplane) 359 of_iounmap(&op->resource[4], 360 par->cplane, info->fix.smem_len * sizeof(u32)); 361 if (info->screen_base) 362 of_iounmap(&op->resource[0], 363 info->screen_base, info->fix.smem_len); 364 } 365 366 static int tcx_probe(struct platform_device *op) 367 { 368 struct device_node *dp = op->dev.of_node; 369 struct fb_info *info; 370 struct tcx_par *par; 371 int linebytes, i, err; 372 373 info = framebuffer_alloc(sizeof(struct tcx_par), &op->dev); 374 375 err = -ENOMEM; 376 if (!info) 377 goto out_err; 378 par = info->par; 379 380 spin_lock_init(&par->lock); 381 382 par->lowdepth = of_property_read_bool(dp, "tcx-8-bit"); 383 384 sbusfb_fill_var(&info->var, dp, 8); 385 info->var.red.length = 8; 386 info->var.green.length = 8; 387 info->var.blue.length = 8; 388 389 linebytes = of_getintprop_default(dp, "linebytes", 390 info->var.xres); 391 info->fix.smem_len = PAGE_ALIGN(linebytes * info->var.yres); 392 393 par->tec = of_ioremap(&op->resource[7], 0, 394 sizeof(struct tcx_tec), "tcx tec"); 395 par->thc = of_ioremap(&op->resource[9], 0, 396 sizeof(struct tcx_thc), "tcx thc"); 397 par->bt = of_ioremap(&op->resource[8], 0, 398 sizeof(struct bt_regs), "tcx dac"); 399 info->screen_base = of_ioremap(&op->resource[0], 0, 400 info->fix.smem_len, "tcx ram"); 401 if (!par->tec || !par->thc || 402 !par->bt || !info->screen_base) 403 goto out_unmap_regs; 404 405 memcpy(&par->mmap_map, &__tcx_mmap_map, sizeof(par->mmap_map)); 406 if (!par->lowdepth) { 407 par->cplane = of_ioremap(&op->resource[4], 0, 408 info->fix.smem_len * sizeof(u32), 409 "tcx cplane"); 410 if (!par->cplane) 411 goto out_unmap_regs; 412 } else { 413 par->mmap_map[1].size = SBUS_MMAP_EMPTY; 414 par->mmap_map[4].size = SBUS_MMAP_EMPTY; 415 par->mmap_map[5].size = SBUS_MMAP_EMPTY; 416 par->mmap_map[6].size = SBUS_MMAP_EMPTY; 417 } 418 419 info->fix.smem_start = op->resource[0].start; 420 par->which_io = op->resource[0].flags & IORESOURCE_BITS; 421 422 for (i = 0; i < TCX_MMAP_ENTRIES; i++) { 423 int j; 424 425 switch (i) { 426 case 10: 427 j = 12; 428 break; 429 430 case 11: case 12: 431 j = i - 1; 432 break; 433 434 default: 435 j = i; 436 break; 437 } 438 par->mmap_map[i].poff = op->resource[j].start; 439 } 440 441 info->flags = FBINFO_DEFAULT; 442 info->fbops = &tcx_ops; 443 444 /* Initialize brooktree DAC. */ 445 sbus_writel(0x04 << 24, &par->bt->addr); /* color planes */ 446 sbus_writel(0xff << 24, &par->bt->control); 447 sbus_writel(0x05 << 24, &par->bt->addr); 448 sbus_writel(0x00 << 24, &par->bt->control); 449 sbus_writel(0x06 << 24, &par->bt->addr); /* overlay plane */ 450 sbus_writel(0x73 << 24, &par->bt->control); 451 sbus_writel(0x07 << 24, &par->bt->addr); 452 sbus_writel(0x00 << 24, &par->bt->control); 453 454 tcx_reset(info); 455 456 tcx_blank(FB_BLANK_UNBLANK, info); 457 458 if (fb_alloc_cmap(&info->cmap, 256, 0)) 459 goto out_unmap_regs; 460 461 fb_set_cmap(&info->cmap, info); 462 tcx_init_fix(info, linebytes); 463 464 err = register_framebuffer(info); 465 if (err < 0) 466 goto out_dealloc_cmap; 467 468 dev_set_drvdata(&op->dev, info); 469 470 printk(KERN_INFO "%pOF: TCX at %lx:%lx, %s\n", 471 dp, 472 par->which_io, 473 info->fix.smem_start, 474 par->lowdepth ? "8-bit only" : "24-bit depth"); 475 476 return 0; 477 478 out_dealloc_cmap: 479 fb_dealloc_cmap(&info->cmap); 480 481 out_unmap_regs: 482 tcx_unmap_regs(op, info, par); 483 framebuffer_release(info); 484 485 out_err: 486 return err; 487 } 488 489 static void tcx_remove(struct platform_device *op) 490 { 491 struct fb_info *info = dev_get_drvdata(&op->dev); 492 struct tcx_par *par = info->par; 493 494 unregister_framebuffer(info); 495 fb_dealloc_cmap(&info->cmap); 496 497 tcx_unmap_regs(op, info, par); 498 499 framebuffer_release(info); 500 } 501 502 static const struct of_device_id tcx_match[] = { 503 { 504 .name = "SUNW,tcx", 505 }, 506 {}, 507 }; 508 MODULE_DEVICE_TABLE(of, tcx_match); 509 510 static struct platform_driver tcx_driver = { 511 .driver = { 512 .name = "tcx", 513 .of_match_table = tcx_match, 514 }, 515 .probe = tcx_probe, 516 .remove_new = tcx_remove, 517 }; 518 519 static int __init tcx_init(void) 520 { 521 if (fb_get_options("tcxfb", NULL)) 522 return -ENODEV; 523 524 return platform_driver_register(&tcx_driver); 525 } 526 527 static void __exit tcx_exit(void) 528 { 529 platform_driver_unregister(&tcx_driver); 530 } 531 532 module_init(tcx_init); 533 module_exit(tcx_exit); 534 535 MODULE_DESCRIPTION("framebuffer driver for TCX chipsets"); 536 MODULE_AUTHOR("David S. Miller <davem@davemloft.net>"); 537 MODULE_VERSION("2.0"); 538 MODULE_LICENSE("GPL"); 539