1 /* tcx.c: TCX frame buffer driver
3 * Copyright (C) 2003 David S. Miller (davem@redhat.com)
4 * Copyright (C) 1996,1998 Jakub Jelinek (jj@ultra.linux.cz)
5 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
6 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
8 * Driver layout based loosely on tgafb.c, see that file for credits.
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/errno.h>
14 #include <linux/string.h>
15 #include <linux/slab.h>
16 #include <linux/delay.h>
17 #include <linux/init.h>
23 #include <asm/oplib.h>
32 static int tcx_setcolreg(unsigned, unsigned, unsigned, unsigned,
33 unsigned, struct fb_info
*);
34 static int tcx_blank(int, struct fb_info
*);
36 static int tcx_mmap(struct fb_info
*, struct file
*, struct vm_area_struct
*);
37 static int tcx_ioctl(struct inode
*, struct file
*, unsigned int,
38 unsigned long, struct fb_info
*);
39 static int tcx_pan_display(struct fb_var_screeninfo
*, struct fb_info
*);
42 * Frame buffer operations
45 static struct fb_ops tcx_ops
= {
47 .fb_setcolreg
= tcx_setcolreg
,
48 .fb_blank
= tcx_blank
,
49 .fb_pan_display
= tcx_pan_display
,
50 .fb_fillrect
= cfb_fillrect
,
51 .fb_copyarea
= cfb_copyarea
,
52 .fb_imageblit
= cfb_imageblit
,
54 .fb_ioctl
= tcx_ioctl
,
56 .fb_compat_ioctl
= sbusfb_compat_ioctl
,
61 #define TCX_THC_MISC_REV_SHIFT 16
62 #define TCX_THC_MISC_REV_MASK 15
63 #define TCX_THC_MISC_VSYNC_DIS (1 << 25)
64 #define TCX_THC_MISC_HSYNC_DIS (1 << 24)
65 #define TCX_THC_MISC_RESET (1 << 12)
66 #define TCX_THC_MISC_VIDEO (1 << 10)
67 #define TCX_THC_MISC_SYNC (1 << 9)
68 #define TCX_THC_MISC_VSYNC (1 << 8)
69 #define TCX_THC_MISC_SYNC_ENAB (1 << 7)
70 #define TCX_THC_MISC_CURS_RES (1 << 6)
71 #define TCX_THC_MISC_INT_ENAB (1 << 5)
72 #define TCX_THC_MISC_INT (1 << 4)
73 #define TCX_THC_MISC_INIT 0x9f
74 #define TCX_THC_REV_REV_SHIFT 20
75 #define TCX_THC_REV_REV_MASK 15
76 #define TCX_THC_REV_MINREV_SHIFT 28
77 #define TCX_THC_REV_MINREV_MASK 15
79 /* The contents are unknown */
81 volatile u32 tec_matrix
;
82 volatile u32 tec_clip
;
89 volatile u32 thc_hs
; /* hsync timing */
90 volatile u32 thc_hsdvs
;
92 volatile u32 thc_vs
; /* vsync timing */
94 volatile u32 thc_refresh
;
95 volatile u32 thc_misc
;
97 volatile u32 thc_cursxy
; /* cursor x,y position (16 bits each) */
98 volatile u32 thc_cursmask
[32]; /* cursor mask bits */
99 volatile u32 thc_cursbits
[32]; /* what to show where mask enabled */
104 volatile u32 color_map
;
105 volatile u32 control
;
109 #define TCX_MMAP_ENTRIES 14
113 struct bt_regs __iomem
*bt
;
114 struct tcx_thc __iomem
*thc
;
115 struct tcx_tec __iomem
*tec
;
116 volatile u32 __iomem
*cplane
;
119 #define TCX_FLAG_BLANKED 0x00000001
121 unsigned long physbase
;
122 unsigned long fbsize
;
124 struct sbus_mmap_map mmap_map
[TCX_MMAP_ENTRIES
];
127 struct sbus_dev
*sdev
;
128 struct list_head list
;
131 /* Reset control plane so that WID is 8-bit plane. */
132 static void __tcx_set_control_plane (struct tcx_par
*par
)
134 volatile u32 __iomem
*p
, *pend
;
142 for (pend
= p
+ par
->fbsize
; p
< pend
; p
++) {
143 u32 tmp
= sbus_readl(p
);
150 static void tcx_reset (struct fb_info
*info
)
152 struct tcx_par
*par
= (struct tcx_par
*) info
->par
;
155 spin_lock_irqsave(&par
->lock
, flags
);
156 __tcx_set_control_plane(par
);
157 spin_unlock_irqrestore(&par
->lock
, flags
);
160 static int tcx_pan_display(struct fb_var_screeninfo
*var
, struct fb_info
*info
)
167 * tcx_setcolreg - Optional function. Sets a color register.
168 * @regno: boolean, 0 copy local, 1 get_user() function
169 * @red: frame buffer colormap structure
170 * @green: The green value which can be up to 16 bits wide
171 * @blue: The blue value which can be up to 16 bits wide.
172 * @transp: If supported the alpha value which can be up to 16 bits wide.
173 * @info: frame buffer info structure
175 static int tcx_setcolreg(unsigned regno
,
176 unsigned red
, unsigned green
, unsigned blue
,
177 unsigned transp
, struct fb_info
*info
)
179 struct tcx_par
*par
= (struct tcx_par
*) info
->par
;
180 struct bt_regs __iomem
*bt
= par
->bt
;
190 spin_lock_irqsave(&par
->lock
, flags
);
192 sbus_writel(regno
<< 24, &bt
->addr
);
193 sbus_writel(red
<< 24, &bt
->color_map
);
194 sbus_writel(green
<< 24, &bt
->color_map
);
195 sbus_writel(blue
<< 24, &bt
->color_map
);
197 spin_unlock_irqrestore(&par
->lock
, flags
);
203 * tcx_blank - Optional function. Blanks the display.
204 * @blank_mode: the blank mode we want.
205 * @info: frame buffer structure that represents a single frame buffer
208 tcx_blank(int blank
, struct fb_info
*info
)
210 struct tcx_par
*par
= (struct tcx_par
*) info
->par
;
211 struct tcx_thc __iomem
*thc
= par
->thc
;
215 spin_lock_irqsave(&par
->lock
, flags
);
217 val
= sbus_readl(&thc
->thc_misc
);
220 case FB_BLANK_UNBLANK
: /* Unblanking */
221 val
&= ~(TCX_THC_MISC_VSYNC_DIS
|
222 TCX_THC_MISC_HSYNC_DIS
);
223 val
|= TCX_THC_MISC_VIDEO
;
224 par
->flags
&= ~TCX_FLAG_BLANKED
;
227 case FB_BLANK_NORMAL
: /* Normal blanking */
228 val
&= ~TCX_THC_MISC_VIDEO
;
229 par
->flags
|= TCX_FLAG_BLANKED
;
232 case FB_BLANK_VSYNC_SUSPEND
: /* VESA blank (vsync off) */
233 val
|= TCX_THC_MISC_VSYNC_DIS
;
235 case FB_BLANK_HSYNC_SUSPEND
: /* VESA blank (hsync off) */
236 val
|= TCX_THC_MISC_HSYNC_DIS
;
239 case FB_BLANK_POWERDOWN
: /* Poweroff */
243 sbus_writel(val
, &thc
->thc_misc
);
245 spin_unlock_irqrestore(&par
->lock
, flags
);
250 static struct sbus_mmap_map __tcx_mmap_map
[TCX_MMAP_ENTRIES
] = {
253 .size
= SBUS_MMAP_FBSIZE(1)
256 .voff
= TCX_RAM24BIT
,
257 .size
= SBUS_MMAP_FBSIZE(4)
261 .size
= SBUS_MMAP_FBSIZE(8)
265 .size
= SBUS_MMAP_FBSIZE(8)
268 .voff
= TCX_CONTROLPLANE
,
269 .size
= SBUS_MMAP_FBSIZE(4)
273 .size
= SBUS_MMAP_FBSIZE(8)
277 .size
= SBUS_MMAP_FBSIZE(8)
306 static int tcx_mmap(struct fb_info
*info
, struct file
*file
, struct vm_area_struct
*vma
)
308 struct tcx_par
*par
= (struct tcx_par
*)info
->par
;
310 return sbusfb_mmap_helper(par
->mmap_map
,
311 par
->physbase
, par
->fbsize
,
312 par
->sdev
->reg_addrs
[0].which_io
,
316 static int tcx_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
,
317 unsigned long arg
, struct fb_info
*info
)
319 struct tcx_par
*par
= (struct tcx_par
*) info
->par
;
321 return sbusfb_ioctl_helper(cmd
, arg
, info
,
323 (par
->lowdepth
? 8 : 24),
332 tcx_init_fix(struct fb_info
*info
, int linebytes
)
334 struct tcx_par
*par
= (struct tcx_par
*)info
->par
;
335 const char *tcx_name
;
342 strlcpy(info
->fix
.id
, tcx_name
, sizeof(info
->fix
.id
));
344 info
->fix
.type
= FB_TYPE_PACKED_PIXELS
;
345 info
->fix
.visual
= FB_VISUAL_PSEUDOCOLOR
;
347 info
->fix
.line_length
= linebytes
;
349 info
->fix
.accel
= FB_ACCEL_SUN_TCX
;
355 struct list_head list
;
357 static LIST_HEAD(tcx_list
);
359 static void tcx_init_one(struct sbus_dev
*sdev
)
361 struct all_info
*all
;
364 all
= kmalloc(sizeof(*all
), GFP_KERNEL
);
366 printk(KERN_ERR
"tcx: Cannot allocate memory.\n");
369 memset(all
, 0, sizeof(*all
));
371 INIT_LIST_HEAD(&all
->list
);
373 spin_lock_init(&all
->par
.lock
);
374 all
->par
.sdev
= sdev
;
376 all
->par
.lowdepth
= prom_getbool(sdev
->prom_node
, "tcx-8-bit");
378 sbusfb_fill_var(&all
->info
.var
, sdev
->prom_node
, 8);
379 all
->info
.var
.red
.length
= 8;
380 all
->info
.var
.green
.length
= 8;
381 all
->info
.var
.blue
.length
= 8;
383 linebytes
= prom_getintdefault(sdev
->prom_node
, "linebytes",
385 all
->par
.fbsize
= PAGE_ALIGN(linebytes
* all
->info
.var
.yres
);
387 all
->par
.tec
= sbus_ioremap(&sdev
->resource
[7], 0,
388 sizeof(struct tcx_tec
), "tcx tec");
389 all
->par
.thc
= sbus_ioremap(&sdev
->resource
[9], 0,
390 sizeof(struct tcx_thc
), "tcx thc");
391 all
->par
.bt
= sbus_ioremap(&sdev
->resource
[8], 0,
392 sizeof(struct bt_regs
), "tcx dac");
393 memcpy(&all
->par
.mmap_map
, &__tcx_mmap_map
, sizeof(all
->par
.mmap_map
));
394 if (!all
->par
.lowdepth
) {
395 all
->par
.cplane
= sbus_ioremap(&sdev
->resource
[4], 0,
396 all
->par
.fbsize
* sizeof(u32
), "tcx cplane");
398 all
->par
.mmap_map
[1].size
= SBUS_MMAP_EMPTY
;
399 all
->par
.mmap_map
[4].size
= SBUS_MMAP_EMPTY
;
400 all
->par
.mmap_map
[5].size
= SBUS_MMAP_EMPTY
;
401 all
->par
.mmap_map
[6].size
= SBUS_MMAP_EMPTY
;
404 all
->par
.physbase
= 0;
405 for (i
= 0; i
< TCX_MMAP_ENTRIES
; i
++) {
421 all
->par
.mmap_map
[i
].poff
= sdev
->reg_addrs
[j
].phys_addr
;
424 all
->info
.flags
= FBINFO_DEFAULT
;
425 all
->info
.fbops
= &tcx_ops
;
426 #ifdef CONFIG_SPARC32
427 all
->info
.screen_base
= (char __iomem
*)
428 prom_getintdefault(sdev
->prom_node
, "address", 0);
430 if (!all
->info
.screen_base
)
431 all
->info
.screen_base
= sbus_ioremap(&sdev
->resource
[0], 0,
432 all
->par
.fbsize
, "tcx ram");
433 all
->info
.par
= &all
->par
;
435 /* Initialize brooktree DAC. */
436 sbus_writel(0x04 << 24, &all
->par
.bt
->addr
); /* color planes */
437 sbus_writel(0xff << 24, &all
->par
.bt
->control
);
438 sbus_writel(0x05 << 24, &all
->par
.bt
->addr
);
439 sbus_writel(0x00 << 24, &all
->par
.bt
->control
);
440 sbus_writel(0x06 << 24, &all
->par
.bt
->addr
); /* overlay plane */
441 sbus_writel(0x73 << 24, &all
->par
.bt
->control
);
442 sbus_writel(0x07 << 24, &all
->par
.bt
->addr
);
443 sbus_writel(0x00 << 24, &all
->par
.bt
->control
);
445 tcx_reset(&all
->info
);
447 tcx_blank(0, &all
->info
);
449 if (fb_alloc_cmap(&all
->info
.cmap
, 256, 0)) {
450 printk(KERN_ERR
"tcx: Could not allocate color map.\n");
455 fb_set_cmap(&all
->info
.cmap
, &all
->info
);
456 tcx_init_fix(&all
->info
, linebytes
);
458 if (register_framebuffer(&all
->info
) < 0) {
459 printk(KERN_ERR
"tcx: Could not register framebuffer.\n");
460 fb_dealloc_cmap(&all
->info
.cmap
);
465 list_add(&all
->list
, &tcx_list
);
467 printk("tcx: %s at %lx:%lx, %s\n",
469 (long) sdev
->reg_addrs
[0].which_io
,
470 (long) sdev
->reg_addrs
[0].phys_addr
,
471 all
->par
.lowdepth
? "8-bit only" : "24-bit depth");
474 int __init
tcx_init(void)
476 struct sbus_bus
*sbus
;
477 struct sbus_dev
*sdev
;
479 if (fb_get_options("tcxfb", NULL
))
482 for_all_sbusdev(sdev
, sbus
) {
483 if (!strcmp(sdev
->prom_name
, "SUNW,tcx"))
490 void __exit
tcx_exit(void)
492 struct list_head
*pos
, *tmp
;
494 list_for_each_safe(pos
, tmp
, &tcx_list
) {
495 struct all_info
*all
= list_entry(pos
, typeof(*all
), list
);
497 unregister_framebuffer(&all
->info
);
498 fb_dealloc_cmap(&all
->info
.cmap
);
506 /* No cmdline options yet... */
510 module_init(tcx_init
);
513 module_exit(tcx_exit
);
516 MODULE_DESCRIPTION("framebuffer driver for TCX chipsets");
517 MODULE_AUTHOR("David S. Miller <davem@redhat.com>");
518 MODULE_LICENSE("GPL");