bw2.c 9.11 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
Linus Torvalds's avatar
Linus Torvalds committed
2 3
/* bw2.c: BWTWO frame buffer driver
 *
4
 * Copyright (C) 2003, 2006 David S. Miller (davem@davemloft.net)
Linus Torvalds's avatar
Linus Torvalds committed
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 * Copyright (C) 1996,1998 Jakub Jelinek (jj@ultra.linux.cz)
 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
 *
 * Driver layout based loosely on tgafb.c, see that file for credits.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/fb.h>
#include <linux/mm.h>
20 21
#include <linux/of.h>
#include <linux/platform_device.h>
Linus Torvalds's avatar
Linus Torvalds committed
22 23 24 25 26 27 28 29 30 31 32 33

#include <asm/io.h>
#include <asm/fbio.h>

#include "sbuslib.h"

/*
 * Local functions.
 */

static int bw2_blank(int, struct fb_info *);

34
static int bw2_mmap(struct fb_info *, struct vm_area_struct *);
35
static int bw2_ioctl(struct fb_info *, unsigned int, unsigned long);
Linus Torvalds's avatar
Linus Torvalds committed
36 37 38 39 40

/*
 *  Frame buffer operations
 */

41
static const struct fb_ops bw2_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
42 43 44 45 46 47 48
	.owner			= THIS_MODULE,
	.fb_blank		= bw2_blank,
	.fb_fillrect		= cfb_fillrect,
	.fb_copyarea		= cfb_copyarea,
	.fb_imageblit		= cfb_imageblit,
	.fb_mmap		= bw2_mmap,
	.fb_ioctl		= bw2_ioctl,
49 50 51
#ifdef CONFIG_COMPAT
	.fb_compat_ioctl	= sbusfb_compat_ioctl,
#endif
Linus Torvalds's avatar
Linus Torvalds committed
52 53 54 55 56 57
};

/* OBio addresses for the bwtwo registers */
#define BWTWO_REGISTER_OFFSET 0x400000

struct bt_regs {
58 59 60 61
	u32 addr;
	u32 color_map;
	u32 control;
	u32 cursor;
Linus Torvalds's avatar
Linus Torvalds committed
62 63 64 65
};

struct bw2_regs {
	struct bt_regs	cmap;
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
	u8	control;
	u8	status;
	u8	cursor_start;
	u8	cursor_end;
	u8	h_blank_start;
	u8	h_blank_end;
	u8	h_sync_start;
	u8	h_sync_end;
	u8	comp_sync_end;
	u8	v_blank_start_high;
	u8	v_blank_start_low;
	u8	v_blank_end;
	u8	v_sync_start;
	u8	v_sync_end;
	u8	xfer_holdoff_start;
	u8	xfer_holdoff_end;
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
};

/* Status Register Constants */
#define BWTWO_SR_RES_MASK	0x70
#define BWTWO_SR_1600_1280	0x50
#define BWTWO_SR_1152_900_76_A	0x40
#define BWTWO_SR_1152_900_76_B	0x60
#define BWTWO_SR_ID_MASK	0x0f
#define BWTWO_SR_ID_MONO	0x02
#define BWTWO_SR_ID_MONO_ECL	0x03
#define BWTWO_SR_ID_MSYNC	0x04
#define BWTWO_SR_ID_NOCONN	0x0a

/* Control Register Constants */
#define BWTWO_CTL_ENABLE_INTS   0x80
#define BWTWO_CTL_ENABLE_VIDEO  0x40
#define BWTWO_CTL_ENABLE_TIMING 0x20
#define BWTWO_CTL_ENABLE_CURCMP 0x10
#define BWTWO_CTL_XTAL_MASK     0x0C
#define BWTWO_CTL_DIVISOR_MASK  0x03

/* Status Register Constants */
#define BWTWO_STAT_PENDING_INT  0x80
#define BWTWO_STAT_MSENSE_MASK  0x70
#define BWTWO_STAT_ID_MASK      0x0f

struct bw2_par {
	spinlock_t		lock;
	struct bw2_regs		__iomem *regs;

	u32			flags;
#define BW2_FLAG_BLANKED	0x00000001

115
	unsigned long		which_io;
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119
};

/**
 *      bw2_blank - Optional function.  Blanks the display.
120
 *      @blank: the blank mode we want.
Linus Torvalds's avatar
Linus Torvalds committed
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
 *      @info: frame buffer structure that represents a single frame buffer
 */
static int
bw2_blank(int blank, struct fb_info *info)
{
	struct bw2_par *par = (struct bw2_par *) info->par;
	struct bw2_regs __iomem *regs = par->regs;
	unsigned long flags;
	u8 val;

	spin_lock_irqsave(&par->lock, flags);

	switch (blank) {
	case FB_BLANK_UNBLANK: /* Unblanking */
		val = sbus_readb(&regs->control);
		val |= BWTWO_CTL_ENABLE_VIDEO;
		sbus_writeb(val, &regs->control);
		par->flags &= ~BW2_FLAG_BLANKED;
		break;

	case FB_BLANK_NORMAL: /* Normal blanking */
	case FB_BLANK_VSYNC_SUSPEND: /* VESA blank (vsync off) */
	case FB_BLANK_HSYNC_SUSPEND: /* VESA blank (hsync off) */
	case FB_BLANK_POWERDOWN: /* Poweroff */
		val = sbus_readb(&regs->control);
		val &= ~BWTWO_CTL_ENABLE_VIDEO;
		sbus_writeb(val, &regs->control);
		par->flags |= BW2_FLAG_BLANKED;
		break;
	}

	spin_unlock_irqrestore(&par->lock, flags);

	return 0;
}

static struct sbus_mmap_map bw2_mmap_map[] = {
	{
		.size = SBUS_MMAP_FBSIZE(1)
	},
	{ .size = 0 }
};

164
static int bw2_mmap(struct fb_info *info, struct vm_area_struct *vma)
Linus Torvalds's avatar
Linus Torvalds committed
165 166 167 168
{
	struct bw2_par *par = (struct bw2_par *)info->par;

	return sbusfb_mmap_helper(bw2_mmap_map,
169
				  info->fix.smem_start, info->fix.smem_len,
170
				  par->which_io,
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173
				  vma);
}

174
static int bw2_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
Linus Torvalds's avatar
Linus Torvalds committed
175 176
{
	return sbusfb_ioctl_helper(cmd, arg, info,
177
				   FBTYPE_SUN2BW, 1, info->fix.smem_len);
Linus Torvalds's avatar
Linus Torvalds committed
178 179 180 181 182 183
}

/*
 *  Initialisation
 */

184
static void bw2_init_fix(struct fb_info *info, int linebytes)
Linus Torvalds's avatar
Linus Torvalds committed
185
{
186
	strscpy(info->fix.id, "bwtwo", sizeof(info->fix.id));
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191 192 193 194 195

	info->fix.type = FB_TYPE_PACKED_PIXELS;
	info->fix.visual = FB_VISUAL_MONO01;

	info->fix.line_length = linebytes;

	info->fix.accel = FB_ACCEL_SUN_BWTWO;
}

196
static u8 bw2regs_1600[] = {
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202
	0x14, 0x8b,	0x15, 0x28,	0x16, 0x03,	0x17, 0x13,
	0x18, 0x7b,	0x19, 0x05,	0x1a, 0x34,	0x1b, 0x2e,
	0x1c, 0x00,	0x1d, 0x0a,	0x1e, 0xff,	0x1f, 0x01,
	0x10, 0x21,	0
};

203
static u8 bw2regs_ecl[] = {
Linus Torvalds's avatar
Linus Torvalds committed
204 205 206 207 208 209
	0x14, 0x65,	0x15, 0x1e,	0x16, 0x04,	0x17, 0x0c,
	0x18, 0x5e,	0x19, 0x03,	0x1a, 0xa7,	0x1b, 0x23,
	0x1c, 0x00,	0x1d, 0x08,	0x1e, 0xff,	0x1f, 0x01,
	0x10, 0x20,	0
};

210
static u8 bw2regs_analog[] = {
Linus Torvalds's avatar
Linus Torvalds committed
211 212 213 214 215 216
	0x14, 0xbb,	0x15, 0x2b,	0x16, 0x03,	0x17, 0x13,
	0x18, 0xb0,	0x19, 0x03,	0x1a, 0xa6,	0x1b, 0x22,
	0x1c, 0x01,	0x1d, 0x05,	0x1e, 0xff,	0x1f, 0x01,
	0x10, 0x20,	0
};

217
static u8 bw2regs_76hz[] = {
Linus Torvalds's avatar
Linus Torvalds committed
218 219 220 221 222 223
	0x14, 0xb7,	0x15, 0x27,	0x16, 0x03,	0x17, 0x0f,
	0x18, 0xae,	0x19, 0x03,	0x1a, 0xae,	0x1b, 0x2a,
	0x1c, 0x01,	0x1d, 0x09,	0x1e, 0xff,	0x1f, 0x01,
	0x10, 0x24,	0
};

224
static u8 bw2regs_66hz[] = {
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228 229 230
	0x14, 0xbb,	0x15, 0x2b,	0x16, 0x04,	0x17, 0x14,
	0x18, 0xae,	0x19, 0x03,	0x1a, 0xa8,	0x1b, 0x24,
	0x1c, 0x01,	0x1d, 0x05,	0x1e, 0xff,	0x1f, 0x01,
	0x10, 0x20,	0
};

231 232
static int bw2_do_default_mode(struct bw2_par *par, struct fb_info *info,
			       int *linebytes)
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
{
	u8 status, mon;
	u8 *p;

	status = sbus_readb(&par->regs->status);
	mon = status & BWTWO_SR_RES_MASK;
	switch (status & BWTWO_SR_ID_MASK) {
	case BWTWO_SR_ID_MONO_ECL:
		if (mon == BWTWO_SR_1600_1280) {
			p = bw2regs_1600;
			info->var.xres = info->var.xres_virtual = 1600;
			info->var.yres = info->var.yres_virtual = 1280;
			*linebytes = 1600 / 8;
		} else
			p = bw2regs_ecl;
		break;

	case BWTWO_SR_ID_MONO:
		p = bw2regs_analog;
		break;

	case BWTWO_SR_ID_MSYNC:
		if (mon == BWTWO_SR_1152_900_76_A ||
		    mon == BWTWO_SR_1152_900_76_B)
			p = bw2regs_76hz;
		else
			p = bw2regs_66hz;
		break;

	case BWTWO_SR_ID_NOCONN:
263
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
264 265

	default:
266 267 268
		printk(KERN_ERR "bw2: can't handle SR %02x\n",
		       status);
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
269 270 271 272 273
	}
	for ( ; *p; p += 2) {
		u8 __iomem *regp = &((u8 __iomem *)par->regs)[p[0]];
		sbus_writeb(p[1], regp);
	}
274
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
275 276
}

277
static int bw2_probe(struct platform_device *op)
Linus Torvalds's avatar
Linus Torvalds committed
278
{
279
	struct device_node *dp = op->dev.of_node;
280 281
	struct fb_info *info;
	struct bw2_par *par;
282
	int linebytes, err;
Linus Torvalds's avatar
Linus Torvalds committed
283

284
	info = framebuffer_alloc(sizeof(struct bw2_par), &op->dev);
Linus Torvalds's avatar
Linus Torvalds committed
285

286 287 288 289
	err = -ENOMEM;
	if (!info)
		goto out_err;
	par = info->par;
290

291
	spin_lock_init(&par->lock);
292

293
	info->fix.smem_start = op->resource[0].start;
294 295
	par->which_io = op->resource[0].flags & IORESOURCE_BITS;

296
	sbusfb_fill_var(&info->var, dp, 1);
297
	linebytes = of_getintprop_default(dp, "linebytes",
298
					  info->var.xres);
299

300 301 302 303
	info->var.red.length = info->var.green.length =
		info->var.blue.length = info->var.bits_per_pixel;
	info->var.red.offset = info->var.green.offset =
		info->var.blue.offset = 0;
Linus Torvalds's avatar
Linus Torvalds committed
304

305 306 307 308
	par->regs = of_ioremap(&op->resource[0], BWTWO_REGISTER_OFFSET,
			       sizeof(struct bw2_regs), "bw2 regs");
	if (!par->regs)
		goto out_release_fb;
Linus Torvalds's avatar
Linus Torvalds committed
309

310
	if (!of_property_present(dp, "width")) {
311 312 313 314
		err = bw2_do_default_mode(par, info, &linebytes);
		if (err)
			goto out_unmap_regs;
	}
Linus Torvalds's avatar
Linus Torvalds committed
315

316
	info->fix.smem_len = PAGE_ALIGN(linebytes * info->var.yres);
Linus Torvalds's avatar
Linus Torvalds committed
317

318 319
	info->flags = FBINFO_DEFAULT;
	info->fbops = &bw2_ops;
320

321
	info->screen_base = of_ioremap(&op->resource[0], 0,
322
				       info->fix.smem_len, "bw2 ram");
323 324
	if (!info->screen_base) {
		err = -ENOMEM;
325
		goto out_unmap_regs;
326
	}
Linus Torvalds's avatar
Linus Torvalds committed
327

328
	bw2_blank(FB_BLANK_UNBLANK, info);
Linus Torvalds's avatar
Linus Torvalds committed
329

330
	bw2_init_fix(info, linebytes);
Linus Torvalds's avatar
Linus Torvalds committed
331

332 333 334
	err = register_framebuffer(info);
	if (err < 0)
		goto out_unmap_screen;
Linus Torvalds's avatar
Linus Torvalds committed
335

336
	dev_set_drvdata(&op->dev, info);
337

338 339
	printk(KERN_INFO "%pOF: bwtwo at %lx:%lx\n",
	       dp, par->which_io, info->fix.smem_start);
Linus Torvalds's avatar
Linus Torvalds committed
340

341
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
342

343
out_unmap_screen:
344
	of_iounmap(&op->resource[0], info->screen_base, info->fix.smem_len);
345 346 347 348 349 350

out_unmap_regs:
	of_iounmap(&op->resource[0], par->regs, sizeof(struct bw2_regs));

out_release_fb:
	framebuffer_release(info);
Linus Torvalds's avatar
Linus Torvalds committed
351

352 353
out_err:
	return err;
354
}
Linus Torvalds's avatar
Linus Torvalds committed
355

356
static void bw2_remove(struct platform_device *op)
357
{
358 359
	struct fb_info *info = dev_get_drvdata(&op->dev);
	struct bw2_par *par = info->par;
360

361
	unregister_framebuffer(info);
362

363
	of_iounmap(&op->resource[0], par->regs, sizeof(struct bw2_regs));
364
	of_iounmap(&op->resource[0], info->screen_base, info->fix.smem_len);
365

366
	framebuffer_release(info);
Linus Torvalds's avatar
Linus Torvalds committed
367 368
}

369
static const struct of_device_id bw2_match[] = {
370 371 372 373 374 375
	{
		.name = "bwtwo",
	},
	{},
};
MODULE_DEVICE_TABLE(of, bw2_match);
Linus Torvalds's avatar
Linus Torvalds committed
376

377
static struct platform_driver bw2_driver = {
378 379 380 381
	.driver = {
		.name = "bw2",
		.of_match_table = bw2_match,
	},
382
	.probe		= bw2_probe,
383
	.remove_new	= bw2_remove,
384
};
Linus Torvalds's avatar
Linus Torvalds committed
385

386 387 388 389 390
static int __init bw2_init(void)
{
	if (fb_get_options("bw2fb", NULL))
		return -ENODEV;

391
	return platform_driver_register(&bw2_driver);
Linus Torvalds's avatar
Linus Torvalds committed
392 393
}

394
static void __exit bw2_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
395
{
396
	platform_driver_unregister(&bw2_driver);
Linus Torvalds's avatar
Linus Torvalds committed
397 398
}

399
module_init(bw2_init);
Linus Torvalds's avatar
Linus Torvalds committed
400 401 402
module_exit(bw2_exit);

MODULE_DESCRIPTION("framebuffer driver for BWTWO chipsets");
403 404
MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
MODULE_VERSION("2.0");
Linus Torvalds's avatar
Linus Torvalds committed
405
MODULE_LICENSE("GPL");