cyber2000fb.c 42.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 *  linux/drivers/video/cyber2000fb.c
 *
4
 *  Copyright (C) 1998-2002 Russell King
Linus Torvalds's avatar
Linus Torvalds committed
5
 *
Linus Torvalds's avatar
Linus Torvalds committed
6 7 8
 *  MIPS and 50xx clock support
 *  Copyright (C) 2001 Bradley D. LaRonde <brad@ltc.com>
 *
9 10 11
 *  32 bit support, text color and panning fixes for modes != 8 bit
 *  Copyright (C) 2002 Denis Oliver Kropp <dok@directfb.org>
 *
Linus Torvalds's avatar
Linus Torvalds committed
12 13 14 15 16 17 18 19
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Integraphics CyberPro 2000, 2010 and 5000 frame buffer device
 *
 * Based on cyberfb.c.
 *
20 21 22 23 24 25 26
 * Note that we now use the new fbcon fix, var and cmap scheme.  We do
 * still have to check which console is the currently displayed one
 * however, especially for the colourmap stuff.
 *
 * We also use the new hotplug PCI subsystem.  I'm not sure if there
 * are any such cards, but I'm erring on the side of caution.  We don't
 * want to go pop just because someone does have one.
Linus Torvalds's avatar
Linus Torvalds committed
27
 *
28 29 30
 * Note that this doesn't work fully in the case of multiple CyberPro
 * cards with grabbers.  We currently can only attach to the first
 * CyberPro card found.
Linus Torvalds's avatar
Linus Torvalds committed
31
 *
32 33 34 35 36 37
 * When we're in truecolour mode, we power down the LUT RAM as a power
 * saving feature.  Also, when we enter any of the powersaving modes
 * (except soft blanking) we power down the RAMDACs.  This saves about
 * 1W, which is roughly 8% of the power consumption of a NetWinder
 * (which, incidentally, is about the same saving as a 2.5in hard disk
 * entering standby mode.)
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40 41 42 43 44 45
 */
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/tty.h>
Linus Torvalds's avatar
Linus Torvalds committed
46
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
47 48 49 50 51 52 53 54 55 56 57
#include <linux/delay.h>
#include <linux/fb.h>
#include <linux/pci.h>
#include <linux/init.h>

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/pgtable.h>
#include <asm/system.h>
#include <asm/uaccess.h>

58 59 60 61
#ifdef __arm__
#include <asm/mach-types.h>
#endif

Linus Torvalds's avatar
Linus Torvalds committed
62 63 64 65 66
#include "cyber2000fb.h"

struct cfb_info {
	struct fb_info		fb;
	struct display_switch	*dispsw;
67
	struct display		*display;
Linus Torvalds's avatar
Linus Torvalds committed
68
	struct pci_dev		*dev;
Linus Torvalds's avatar
Linus Torvalds committed
69 70
	unsigned char 		*region;
	unsigned char		*regs;
71
	u_int			id;
Linus Torvalds's avatar
Linus Torvalds committed
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
	int			func_use_count;
	u_long			ref_ps;

	/*
	 * Clock divisors
	 */
	u_int			divisors[4];

	struct {
		u8 red, green, blue;
	} palette[NR_PALETTE];

	u_char			mem_ctl1;
	u_char			mem_ctl2;
	u_char			mclk_mult;
	u_char			mclk_div;
88 89 90 91 92
	/*
	 * RAMDAC control register is both of these or'ed together
	 */
	u_char			ramdac_ctrl;
	u_char			ramdac_powerdown;
Linus Torvalds's avatar
Linus Torvalds committed
93 94
};

Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
static char default_font_storage[40];
static char *default_font = "Acorn8x8";
MODULE_PARM(default_font, "s");
MODULE_PARM_DESC(default_font, "Default font name");

/*
 * Our access methods.
 */
#define cyber2000fb_writel(val,reg,cfb)	writel(val, (cfb)->regs + (reg))
#define cyber2000fb_writew(val,reg,cfb)	writew(val, (cfb)->regs + (reg))
#define cyber2000fb_writeb(val,reg,cfb)	writeb(val, (cfb)->regs + (reg))

#define cyber2000fb_readb(reg,cfb)	readb((cfb)->regs + (reg))

static inline void
cyber2000_crtcw(unsigned int reg, unsigned int val, struct cfb_info *cfb)
{
	cyber2000fb_writew((reg & 255) | val << 8, 0x3d4, cfb);
}

static inline void
cyber2000_grphw(unsigned int reg, unsigned int val, struct cfb_info *cfb)
{
	cyber2000fb_writew((reg & 255) | val << 8, 0x3ce, cfb);
}

static inline unsigned int
cyber2000_grphr(unsigned int reg, struct cfb_info *cfb)
{
	cyber2000fb_writeb(reg, 0x3ce, cfb);
	return cyber2000fb_readb(0x3cf, cfb);
}

static inline void
cyber2000_attrw(unsigned int reg, unsigned int val, struct cfb_info *cfb)
{
	cyber2000fb_readb(0x3da, cfb);
	cyber2000fb_writeb(reg, 0x3c0, cfb);
	cyber2000fb_readb(0x3c1, cfb);
	cyber2000fb_writeb(val, 0x3c0, cfb);
}

static inline void
cyber2000_seqw(unsigned int reg, unsigned int val, struct cfb_info *cfb)
{
	cyber2000fb_writew((reg & 255) | val << 8, 0x3c4, cfb);
}

Linus Torvalds's avatar
Linus Torvalds committed
143 144 145 146 147 148
/* -------------------- Hardware specific routines ------------------------- */

/*
 * Hardware Cyber2000 Acceleration
 */
static void
Russell King's avatar
Russell King committed
149
cyber2000fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
Linus Torvalds's avatar
Linus Torvalds committed
150
{
151 152
	struct cfb_info *cfb = (struct cfb_info *)info;
	unsigned long dst, col;
Linus Torvalds's avatar
Linus Torvalds committed
153

154 155 156
	if (!(cfb->fb.var.accel_flags & FB_ACCELF_TEXT)) {
		cfb_fillrect(info, rect);
		return;
Linus Torvalds's avatar
Linus Torvalds committed
157 158
	}

159 160 161
	cyber2000fb_writeb(0, CO_REG_CONTROL, cfb);
	cyber2000fb_writew(rect->width - 1, CO_REG_PIXWIDTH, cfb);
	cyber2000fb_writew(rect->height - 1, CO_REG_PIXHEIGHT, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
162

163 164 165 166
	col = rect->color;
	if (cfb->fb.var.bits_per_pixel > 8)
		col = ((u32 *)cfb->fb.pseudo_palette)[col];
	cyber2000fb_writel(col, CO_REG_FGCOLOUR, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
167

168 169
	dst = rect->dx + rect->dy * cfb->fb.var.xres_virtual;
	if (cfb->fb.var.bits_per_pixel == 24) {
170 171
		cyber2000fb_writeb(dst, CO_REG_X_PHASE, cfb);
		dst *= 3;
Linus Torvalds's avatar
Linus Torvalds committed
172 173
	}

174 175
	cyber2000fb_writel(dst, CO_REG_DEST_PTR, cfb);
	cyber2000fb_writeb(CO_FG_MIX_SRC, CO_REG_FGMIX, cfb);
176 177
	cyber2000fb_writew(CO_CMD_L_PATTERN_FGCOL, CO_REG_CMD_L, cfb);
	cyber2000fb_writew(CO_CMD_H_BLITTER, CO_REG_CMD_H, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
178 179 180
}

static void
Russell King's avatar
Russell King committed
181
cyber2000fb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
Linus Torvalds's avatar
Linus Torvalds committed
182
{
183 184 185 186 187 188 189 190
	struct cfb_info *cfb = (struct cfb_info *)info;
	unsigned int cmd = CO_CMD_L_PATTERN_FGCOL;
	unsigned long src, dst;

	if (!(cfb->fb.var.accel_flags & FB_ACCELF_TEXT)) {
		cfb_copyarea(info, region);
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
191

Russell King's avatar
Russell King committed
192 193 194 195 196 197 198
	cyber2000fb_writeb(0, CO_REG_CONTROL, cfb);
	cyber2000fb_writew(region->width - 1, CO_REG_PIXWIDTH, cfb);
	cyber2000fb_writew(region->height - 1, CO_REG_PIXHEIGHT, cfb);

	src = region->sx + region->sy * cfb->fb.var.xres_virtual;
	dst = region->dx + region->dy * cfb->fb.var.xres_virtual;

199
	if (region->sx < region->dx) {
Russell King's avatar
Russell King committed
200 201
		src += region->width - 1;
		dst += region->width - 1;
202 203
		cmd |= CO_CMD_L_INC_LEFT;
	}
Linus Torvalds's avatar
Linus Torvalds committed
204

205
	if (region->sy < region->dy) {
Russell King's avatar
Russell King committed
206 207
		src += (region->height - 1) * cfb->fb.var.xres_virtual;
		dst += (region->height - 1) * cfb->fb.var.xres_virtual;
208 209
		cmd |= CO_CMD_L_INC_UP;
	}
Linus Torvalds's avatar
Linus Torvalds committed
210

211
	if (cfb->fb.var.bits_per_pixel == 24) {
Linus Torvalds's avatar
Linus Torvalds committed
212
		cyber2000fb_writeb(dst, CO_REG_X_PHASE, cfb);
213
		src *= 3;
214
		dst *= 3;
Linus Torvalds's avatar
Linus Torvalds committed
215
	}
216
	cyber2000fb_writel(src, CO_REG_SRC1_PTR, cfb);
217
	cyber2000fb_writel(dst, CO_REG_DEST_PTR, cfb);
218 219 220 221
	cyber2000fb_writew(CO_FG_MIX_SRC, CO_REG_FGMIX, cfb);
	cyber2000fb_writew(cmd, CO_REG_CMD_L, cfb);
	cyber2000fb_writew(CO_CMD_H_FGSRCMAP | CO_CMD_H_BLITTER,
			   CO_REG_CMD_H, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
222 223 224
}

static void
Russell King's avatar
Russell King committed
225
cyber2000fb_imageblit(struct fb_info *info, const struct fb_image *image)
Linus Torvalds's avatar
Linus Torvalds committed
226
{
Russell King's avatar
Russell King committed
227
//	struct cfb_info *cfb = (struct cfb_info *)info;
Linus Torvalds's avatar
Linus Torvalds committed
228

229 230 231 232
//	if (!(cfb->fb.var.accel_flags & FB_ACCELF_TEXT)) {
		cfb_imageblit(info, image);
		return;
//	}
Linus Torvalds's avatar
Linus Torvalds committed
233 234
}

235
static int cyber2000fb_sync(struct fb_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
236
{
237 238
	struct cfb_info *cfb = (struct cfb_info *)info;
	int count = 100000;
Linus Torvalds's avatar
Linus Torvalds committed
239

240 241
	if (!(cfb->fb.var.accel_flags & FB_ACCELF_TEXT))
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
242

243 244 245 246 247 248 249 250 251
	while (cyber2000fb_readb(CO_REG_CONTROL, cfb) & CO_CTRL_BUSY) {
		if (!count--) {
			debug_printf("accel_wait timed out\n");
			cyber2000fb_writeb(0, CO_REG_CONTROL, cfb);
			break;
		}
		udelay(1);
	}
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
252 253
}

254 255 256
/*
 * ===========================================================================
 */
Linus Torvalds's avatar
Linus Torvalds committed
257

258 259 260 261 262 263 264
static inline u32 convert_bitfield(u_int val, struct fb_bitfield *bf)
{
	u_int mask = (1 << bf->length) - 1;

	return (val >> (16 - bf->length) & mask) << bf->offset;
}

Linus Torvalds's avatar
Linus Torvalds committed
265 266 267 268
/*
 *    Set a single color register. Return != 0 for invalid regno.
 */
static int
269 270
cyber2000fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
		      u_int transp, struct fb_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
271 272
{
	struct cfb_info *cfb = (struct cfb_info *)info;
273
	struct fb_var_screeninfo *var = &cfb->fb.var;
274 275
	u32 pseudo_val;
	int ret = 1;
Linus Torvalds's avatar
Linus Torvalds committed
276

277 278
	switch (cfb->fb.fix.visual) {
	default:
Linus Torvalds's avatar
Linus Torvalds committed
279 280
		return 1;

281 282 283 284 285 286 287 288 289 290 291 292
	/*
	 * Pseudocolour:
	 *         8     8
	 * pixel --/--+--/-->  red lut  --> red dac
	 *            |  8
	 *            +--/--> green lut --> green dac
	 *            |  8
	 *            +--/-->  blue lut --> blue dac
	 */
	case FB_VISUAL_PSEUDOCOLOR:
		if (regno >= NR_PALETTE)
			return 1;
Linus Torvalds's avatar
Linus Torvalds committed
293

294 295 296 297 298 299 300
		red >>= 8;
		green >>= 8;
		blue >>= 8;

		cfb->palette[regno].red   = red;
		cfb->palette[regno].green = green;
		cfb->palette[regno].blue  = blue;
Linus Torvalds's avatar
Linus Torvalds committed
301

Linus Torvalds's avatar
Linus Torvalds committed
302
		cyber2000fb_writeb(regno, 0x3c8, cfb);
303
		cyber2000fb_writeb(red, 0x3c9, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
304
		cyber2000fb_writeb(green, 0x3c9, cfb);
305 306
		cyber2000fb_writeb(blue, 0x3c9, cfb);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
307

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
	/*
	 * Direct colour:
	 *          n     rl
	 *  pixel --/--+--/-->  red lut  --> red dac
	 *             |  gl
	 *             +--/--> green lut --> green dac
	 *             |  bl
	 *             +--/-->  blue lut --> blue dac
	 * n = bpp, rl = red length, gl = green length, bl = blue length
	 */
	case FB_VISUAL_DIRECTCOLOR:
		red >>= 8;
		green >>= 8;
		blue >>= 8;

		if (var->green.length == 6 && regno < 64) {
			cfb->palette[regno << 2].green = green;

			/*
			 * The 6 bits of the green component are applied
			 * to the high 6 bits of the LUT.
			 */
			cyber2000fb_writeb(regno << 2, 0x3c8, cfb);
			cyber2000fb_writeb(cfb->palette[regno >> 1].red, 0x3c9, cfb);
			cyber2000fb_writeb(green, 0x3c9, cfb);
			cyber2000fb_writeb(cfb->palette[regno >> 1].blue, 0x3c9, cfb);

			green = cfb->palette[regno << 3].green;

			ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
338
		}
339 340 341 342 343 344 345 346 347 348

		if (var->green.length >= 5 && regno < 32) {
			cfb->palette[regno << 3].red   = red;
			cfb->palette[regno << 3].green = green;
			cfb->palette[regno << 3].blue  = blue;

			/*
			 * The 5 bits of each colour component are
			 * applied to the high 5 bits of the LUT.
			 */
Linus Torvalds's avatar
Linus Torvalds committed
349 350 351 352
			cyber2000fb_writeb(regno << 3, 0x3c8, cfb);
			cyber2000fb_writeb(red, 0x3c9, cfb);
			cyber2000fb_writeb(green, 0x3c9, cfb);
			cyber2000fb_writeb(blue, 0x3c9, cfb);
353
			ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
354 355
		}

356 357 358 359
		if (var->green.length == 4 && regno < 16) {
			cfb->palette[regno << 4].red   = red;
			cfb->palette[regno << 4].green = green;
			cfb->palette[regno << 4].blue  = blue;
Linus Torvalds's avatar
Linus Torvalds committed
360

361 362 363 364 365 366 367 368 369 370
			/*
			 * The 5 bits of each colour component are
			 * applied to the high 5 bits of the LUT.
			 */
			cyber2000fb_writeb(regno << 4, 0x3c8, cfb);
			cyber2000fb_writeb(red, 0x3c9, cfb);
			cyber2000fb_writeb(green, 0x3c9, cfb);
			cyber2000fb_writeb(blue, 0x3c9, cfb);
			ret = 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
371

372 373 374 375 376 377 378
		/*
		 * Since this is only used for the first 16 colours, we
		 * don't have to care about overflowing for regno >= 32
		 */
		pseudo_val = regno << var->red.offset |
			     regno << var->green.offset |
			     regno << var->blue.offset;
Linus Torvalds's avatar
Linus Torvalds committed
379 380
		break;

381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
	/*
	 * True colour:
	 *          n     rl
	 *  pixel --/--+--/--> red dac
	 *             |  gl
	 *             +--/--> green dac
	 *             |  bl
	 *             +--/--> blue dac
	 * n = bpp, rl = red length, gl = green length, bl = blue length
	 */
	case FB_VISUAL_TRUECOLOR:
		pseudo_val = convert_bitfield(transp ^ 0xffff, &var->transp);
		pseudo_val |= convert_bitfield(red, &var->red);
		pseudo_val |= convert_bitfield(green, &var->green);
		pseudo_val |= convert_bitfield(blue, &var->blue);
		break;
Linus Torvalds's avatar
Linus Torvalds committed
397 398
	}

399 400 401
	/*
	 * Now set our pseudo palette for the CFB16/24/32 drivers.
	 */
402 403
	if (regno < 16)
		((u32 *)cfb->fb.pseudo_palette)[regno] = pseudo_val;
404 405

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
406 407 408 409 410 411 412 413
}

struct par_info {
	/*
	 * Hardware
	 */
	u_char	clock_mult;
	u_char	clock_div;
414
	u_char	extseqmisc;
415
	u_char	co_pixfmt;
Linus Torvalds's avatar
Linus Torvalds committed
416 417 418 419 420 421 422 423 424
	u_char	crtc_ofl;
	u_char	crtc[19];
	u_int	width;
	u_int	pitch;
	u_int	fetch;

	/*
	 * Other
	 */
425
	u_char	ramdac;
Linus Torvalds's avatar
Linus Torvalds committed
426 427 428 429 430 431 432 433
};

static const u_char crtc_idx[] = {
	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	0x08, 0x09,
	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18
};

434 435 436 437 438 439 440 441 442 443 444 445
static void cyber2000fb_write_ramdac_ctrl(struct cfb_info *cfb)
{
	unsigned int i;
	unsigned int val = cfb->ramdac_ctrl | cfb->ramdac_powerdown;

	cyber2000fb_writeb(0x56, 0x3ce, cfb);
	i = cyber2000fb_readb(0x3cf, cfb);
	cyber2000fb_writeb(i | 4, 0x3cf, cfb);
	cyber2000fb_writeb(val, 0x3c6, cfb);
	cyber2000fb_writeb(i, 0x3cf, cfb);
}

Linus Torvalds's avatar
Linus Torvalds committed
446 447 448 449 450 451 452 453
static void cyber2000fb_set_timing(struct cfb_info *cfb, struct par_info *hw)
{
	u_int i;

	/*
	 * Blank palette
	 */
	for (i = 0; i < NR_PALETTE; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
454 455 456 457
		cyber2000fb_writeb(i, 0x3c8, cfb);
		cyber2000fb_writeb(0, 0x3c9, cfb);
		cyber2000fb_writeb(0, 0x3c9, cfb);
		cyber2000fb_writeb(0, 0x3c9, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
458 459
	}

Linus Torvalds's avatar
Linus Torvalds committed
460 461 462
	cyber2000fb_writeb(0xef, 0x3c2, cfb);
	cyber2000_crtcw(0x11, 0x0b, cfb);
	cyber2000_attrw(0x11, 0x00, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
463

Linus Torvalds's avatar
Linus Torvalds committed
464 465 466 467 468 469
	cyber2000_seqw(0x00, 0x01, cfb);
	cyber2000_seqw(0x01, 0x01, cfb);
	cyber2000_seqw(0x02, 0x0f, cfb);
	cyber2000_seqw(0x03, 0x00, cfb);
	cyber2000_seqw(0x04, 0x0e, cfb);
	cyber2000_seqw(0x00, 0x03, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
470 471

	for (i = 0; i < sizeof(crtc_idx); i++)
Linus Torvalds's avatar
Linus Torvalds committed
472
		cyber2000_crtcw(crtc_idx[i], hw->crtc[i], cfb);
Linus Torvalds's avatar
Linus Torvalds committed
473 474

	for (i = 0x0a; i < 0x10; i++)
Linus Torvalds's avatar
Linus Torvalds committed
475 476
		cyber2000_crtcw(i, 0, cfb);

477
	cyber2000_grphw(EXT_CRT_VRTOFL, hw->crtc_ofl, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
478 479 480 481 482 483 484 485 486
	cyber2000_grphw(0x00, 0x00, cfb);
	cyber2000_grphw(0x01, 0x00, cfb);
	cyber2000_grphw(0x02, 0x00, cfb);
	cyber2000_grphw(0x03, 0x00, cfb);
	cyber2000_grphw(0x04, 0x00, cfb);
	cyber2000_grphw(0x05, 0x60, cfb);
	cyber2000_grphw(0x06, 0x05, cfb);
	cyber2000_grphw(0x07, 0x0f, cfb);
	cyber2000_grphw(0x08, 0xff, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
487 488 489

	/* Attribute controller registers */
	for (i = 0; i < 16; i++)
Linus Torvalds's avatar
Linus Torvalds committed
490
		cyber2000_attrw(i, i, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
491

Linus Torvalds's avatar
Linus Torvalds committed
492 493 494 495 496
	cyber2000_attrw(0x10, 0x01, cfb);
	cyber2000_attrw(0x11, 0x00, cfb);
	cyber2000_attrw(0x12, 0x0f, cfb);
	cyber2000_attrw(0x13, 0x00, cfb);
	cyber2000_attrw(0x14, 0x00, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
497 498

	/* PLL registers */
499 500 501 502
	cyber2000_grphw(EXT_DCLK_MULT, hw->clock_mult, cfb);
	cyber2000_grphw(EXT_DCLK_DIV,  hw->clock_div, cfb);
	cyber2000_grphw(EXT_MCLK_MULT, cfb->mclk_mult, cfb);
	cyber2000_grphw(EXT_MCLK_DIV,  cfb->mclk_div, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
503 504 505 506
	cyber2000_grphw(0x90, 0x01, cfb);
	cyber2000_grphw(0xb9, 0x80, cfb);
	cyber2000_grphw(0xb9, 0x00, cfb);

507 508
	cfb->ramdac_ctrl = hw->ramdac;
	cyber2000fb_write_ramdac_ctrl(cfb);
Linus Torvalds's avatar
Linus Torvalds committed
509 510 511 512 513

	cyber2000fb_writeb(0x20, 0x3c0, cfb);
	cyber2000fb_writeb(0xff, 0x3c6, cfb);

	cyber2000_grphw(0x14, hw->fetch, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
514
	cyber2000_grphw(0x15, ((hw->fetch >> 8) & 0x03) |
Linus Torvalds's avatar
Linus Torvalds committed
515
			      ((hw->pitch >> 4) & 0x30), cfb);
516
	cyber2000_grphw(EXT_SEQ_MISC, hw->extseqmisc, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
517 518 519 520

	/*
	 * Set up accelerator registers
	 */
Linus Torvalds's avatar
Linus Torvalds committed
521 522
	cyber2000fb_writew(hw->width,     CO_REG_SRC_WIDTH,  cfb);
	cyber2000fb_writew(hw->width,     CO_REG_DEST_WIDTH, cfb);
523
	cyber2000fb_writeb(hw->co_pixfmt, CO_REG_PIXFMT, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
524 525 526 527 528
}

static inline int
cyber2000fb_update_start(struct cfb_info *cfb, struct fb_var_screeninfo *var)
{
529
	u_int base = var->yoffset * var->xres_virtual + var->xoffset;
Linus Torvalds's avatar
Linus Torvalds committed
530

531
	base *= var->bits_per_pixel;
Linus Torvalds's avatar
Linus Torvalds committed
532

533 534 535 536 537
	/*
	 * Convert to bytes and shift two extra bits because DAC
	 * can only start on 4 byte aligned data.
	 */
	base >>= 5;
Linus Torvalds's avatar
Linus Torvalds committed
538 539 540 541

	if (base >= 1 << 20)
		return -EINVAL;

Linus Torvalds's avatar
Linus Torvalds committed
542 543 544
	cyber2000_grphw(0x10, base >> 16 | 0x10, cfb);
	cyber2000_crtcw(0x0c, base >> 8, cfb);
	cyber2000_crtcw(0x0d, base, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614

	return 0;
}

static int
cyber2000fb_decode_crtc(struct par_info *hw, struct cfb_info *cfb,
			struct fb_var_screeninfo *var)
{
	u_int Htotal, Hblankend, Hsyncend;
	u_int Vtotal, Vdispend, Vblankstart, Vblankend, Vsyncstart, Vsyncend;
#define BIT(v,b1,m,b2) (((v >> b1) & m) << b2)

	hw->crtc[13] = hw->pitch;
	hw->crtc[17] = 0xe3;
	hw->crtc[14] = 0;
	hw->crtc[8]  = 0;

	Htotal      = var->xres + var->right_margin +
		      var->hsync_len + var->left_margin;

	if (Htotal > 2080)
		return -EINVAL;

	hw->crtc[0] = (Htotal >> 3) - 5;
	hw->crtc[1] = (var->xres >> 3) - 1;
	hw->crtc[2] = var->xres >> 3;
	hw->crtc[4] = (var->xres + var->right_margin) >> 3;

	Hblankend   = (Htotal - 4*8) >> 3;

	hw->crtc[3] = BIT(Hblankend,  0, 0x1f,  0) |
		      BIT(1,          0, 0x01,  7);

	Hsyncend    = (var->xres + var->right_margin + var->hsync_len) >> 3;

	hw->crtc[5] = BIT(Hsyncend,   0, 0x1f,  0) |
		      BIT(Hblankend,  5, 0x01,  7);

	Vdispend    = var->yres - 1;
	Vsyncstart  = var->yres + var->lower_margin;
	Vsyncend    = var->yres + var->lower_margin + var->vsync_len;
	Vtotal      = var->yres + var->lower_margin + var->vsync_len +
		      var->upper_margin - 2;

	if (Vtotal > 2047)
		return -EINVAL;

	Vblankstart = var->yres + 6;
	Vblankend   = Vtotal - 10;

	hw->crtc[6]  = Vtotal;
	hw->crtc[7]  = BIT(Vtotal,     8, 0x01,  0) |
			BIT(Vdispend,   8, 0x01,  1) |
			BIT(Vsyncstart, 8, 0x01,  2) |
			BIT(Vblankstart,8, 0x01,  3) |
			BIT(1,          0, 0x01,  4) |
	        	BIT(Vtotal,     9, 0x01,  5) |
			BIT(Vdispend,   9, 0x01,  6) |
			BIT(Vsyncstart, 9, 0x01,  7);
	hw->crtc[9]  = BIT(0,          0, 0x1f,  0) |
		        BIT(Vblankstart,9, 0x01,  5) |
			BIT(1,          0, 0x01,  6);
	hw->crtc[10] = Vsyncstart;
	hw->crtc[11] = BIT(Vsyncend,   0, 0x0f,  0) |
		       BIT(1,          0, 0x01,  7);
	hw->crtc[12] = Vdispend;
	hw->crtc[15] = Vblankstart;
	hw->crtc[16] = Vblankend;
	hw->crtc[18] = 0xff;

615 616 617
	/*
	 * overflow - graphics reg 0x11
	 * 0=VTOTAL:10 1=VDEND:10 2=VRSTART:10 3=VBSTART:10
Linus Torvalds's avatar
Linus Torvalds committed
618 619 620 621 622 623 624
	 * 4=LINECOMP:10 5-IVIDEO 6=FIXCNT
	 */
	hw->crtc_ofl =
		BIT(Vtotal,     10, 0x01,  0) |
		BIT(Vdispend,   10, 0x01,  1) |
		BIT(Vsyncstart, 10, 0x01,  2) |
		BIT(Vblankstart,10, 0x01,  3) |
625 626 627 628 629 630
		EXT_CRT_VRTOFL_LINECOMP10;

	/* woody: set the interlaced bit... */
	/* FIXME: what about doublescan? */
	if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED)
		hw->crtc_ofl |= EXT_CRT_VRTOFL_INTERLACE;
Linus Torvalds's avatar
Linus Torvalds committed
631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657

	return 0;
}

/*
 * The following was discovered by a good monitor, bit twiddling, theorising
 * and but mostly luck.  Strangely, it looks like everyone elses' PLL!
 *
 * Clock registers:
 *   fclock = fpll / div2
 *   fpll   = fref * mult / div1
 * where:
 *   fref = 14.318MHz (69842ps)
 *   mult = reg0xb0.7:0
 *   div1 = (reg0xb1.5:0 + 1)
 *   div2 =  2^(reg0xb1.7:6)
 *   fpll should be between 115 and 260 MHz
 *  (8696ps and 3846ps)
 */
static int
cyber2000fb_decode_clock(struct par_info *hw, struct cfb_info *cfb,
			 struct fb_var_screeninfo *var)
{
	u_long pll_ps = var->pixclock;
	const u_long ref_ps = cfb->ref_ps;
	u_int div2, t_div1, best_div1, best_mult;
	int best_diff;
Linus Torvalds's avatar
Linus Torvalds committed
658
	int vco;
Linus Torvalds's avatar
Linus Torvalds committed
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732

	/*
	 * Step 1:
	 *   find div2 such that 115MHz < fpll < 260MHz
	 *   and 0 <= div2 < 4
	 */
	for (div2 = 0; div2 < 4; div2++) {
		u_long new_pll;

		new_pll = pll_ps / cfb->divisors[div2];
		if (8696 > new_pll && new_pll > 3846) {
			pll_ps = new_pll;
			break;
		}
	}

	if (div2 == 4)
		return -EINVAL;

	/*
	 * Step 2:
	 *  Given pll_ps and ref_ps, find:
	 *    pll_ps * 0.995 < pll_ps_calc < pll_ps * 1.005
	 *  where { 1 < best_div1 < 32, 1 < best_mult < 256 }
	 *    pll_ps_calc = best_div1 / (ref_ps * best_mult)
	 */
	best_diff = 0x7fffffff;
	best_mult = 32;
	best_div1 = 255;
	for (t_div1 = 32; t_div1 > 1; t_div1 -= 1) {
		u_int rr, t_mult, t_pll_ps;
		int diff;

		/*
		 * Find the multiplier for this divisor
		 */
		rr = ref_ps * t_div1;
		t_mult = (rr + pll_ps / 2) / pll_ps;

		/*
		 * Is the multiplier within the correct range?
		 */
		if (t_mult > 256 || t_mult < 2)
			continue;

		/*
		 * Calculate the actual clock period from this multiplier
		 * and divisor, and estimate the error.
		 */
		t_pll_ps = (rr + t_mult / 2) / t_mult;
		diff = pll_ps - t_pll_ps;
		if (diff < 0)
			diff = -diff;

		if (diff < best_diff) {
			best_diff = diff;
			best_mult = t_mult;
			best_div1 = t_div1;
		}

		/*
		 * If we hit an exact value, there is no point in continuing.
		 */
		if (diff == 0)
			break;
	}

	/*
	 * Step 3:
	 *  combine values
	 */
	hw->clock_mult = best_mult - 1;
	hw->clock_div  = div2 << 6 | (best_div1 - 1);

Linus Torvalds's avatar
Linus Torvalds committed
733 734 735
	vco = ref_ps * best_div1 / best_mult;
	if ((ref_ps == 40690) && (vco < 5556))
		/* Set VFSEL when VCO > 180MHz (5.556 ps). */
736
		hw->clock_div |= EXT_DCLK_DIV_VFSEL;
Linus Torvalds's avatar
Linus Torvalds committed
737

Linus Torvalds's avatar
Linus Torvalds committed
738 739 740 741
	return 0;
}

/*
742
 *    Set the User Defined Part of the Display
Linus Torvalds's avatar
Linus Torvalds committed
743 744
 */
static int
745
cyber2000fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
746
{
747 748
	struct cfb_info *cfb = (struct cfb_info *)info;
	struct par_info hw;
749
	unsigned int mem;
Linus Torvalds's avatar
Linus Torvalds committed
750 751
	int err;

752 753 754 755
	var->transp.msb_right	= 0;
	var->red.msb_right	= 0;
	var->green.msb_right	= 0;
	var->blue.msb_right	= 0;
Linus Torvalds's avatar
Linus Torvalds committed
756 757 758

	switch (var->bits_per_pixel) {
	case 8:	/* PSEUDOCOLOUR, 256 */
759 760 761 762 763 764 765 766
		var->transp.offset	= 0;
		var->transp.length	= 0;
		var->red.offset		= 0;
		var->red.length		= 8;
		var->green.offset	= 0;
		var->green.length	= 8;
		var->blue.offset	= 0;
		var->blue.length	= 8;
Linus Torvalds's avatar
Linus Torvalds committed
767
		break;
Russell King's avatar
Russell King committed
768

769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
	case 16:/* DIRECTCOLOUR, 64k or 32k */
		switch (var->green.length) {
		case 6: /* RGB565, 64k */
			var->transp.offset	= 0;
			var->transp.length	= 0;
			var->red.offset		= 11;
			var->red.length		= 5;
			var->green.offset	= 5;
			var->green.length	= 6;
			var->blue.offset	= 0;
			var->blue.length	= 5;
			break;

		default:
		case 5: /* RGB555, 32k */
			var->transp.offset	= 0;
			var->transp.length	= 0;
			var->red.offset		= 10;
			var->red.length		= 5;
			var->green.offset	= 5;
			var->green.length	= 5;
			var->blue.offset	= 0;
			var->blue.length	= 5;
			break;

		case 4: /* RGB444, 4k + transparency? */
			var->transp.offset	= 12;
			var->transp.length	= 4;
			var->red.offset		= 8;
			var->red.length		= 4;
			var->green.offset	= 4;
			var->green.length	= 4;
			var->blue.offset	= 0;
			var->blue.length	= 4;
803 804
			break;
		}
Linus Torvalds's avatar
Linus Torvalds committed
805
		break;
Russell King's avatar
Russell King committed
806

Linus Torvalds's avatar
Linus Torvalds committed
807
	case 24:/* TRUECOLOUR, 16m */
808 809 810 811 812 813 814 815 816
		var->transp.offset	= 0;
		var->transp.length	= 0;
		var->red.offset		= 16;
		var->red.length		= 8;
		var->green.offset	= 8;
		var->green.length	= 8;
		var->blue.offset	= 0;
		var->blue.length	= 8;
		break;
Russell King's avatar
Russell King committed
817

818 819 820 821 822 823 824 825 826
	case 32:/* TRUECOLOUR, 16m */
		var->transp.offset	= 24;
		var->transp.length	= 8;
		var->red.offset		= 16;
		var->red.length		= 8;
		var->green.offset	= 8;
		var->green.length	= 8;
		var->blue.offset	= 0;
		var->blue.length	= 8;
Linus Torvalds's avatar
Linus Torvalds committed
827
		break;
Russell King's avatar
Russell King committed
828

Linus Torvalds's avatar
Linus Torvalds committed
829 830 831 832
	default:
		return -EINVAL;
	}

833 834 835 836 837 838 839 840 841 842
	mem = var->xres_virtual * var->yres_virtual * (var->bits_per_pixel / 8);
	if (mem > cfb->fb.fix.smem_len)
		var->yres_virtual = cfb->fb.fix.smem_len * 8 /
			(var->bits_per_pixel * var->xres_virtual);

	if (var->yres > var->yres_virtual)
		var->yres = var->yres_virtual;
	if (var->xres > var->xres_virtual)
		var->xres = var->xres_virtual;

843
	err = cyber2000fb_decode_clock(&hw, cfb, var);
Linus Torvalds's avatar
Linus Torvalds committed
844 845 846
	if (err)
		return err;

847
	err = cyber2000fb_decode_crtc(&hw, cfb, var);
Linus Torvalds's avatar
Linus Torvalds committed
848 849 850 851 852 853
	if (err)
		return err;

	return 0;
}

854
static int cyber2000fb_set_par(struct fb_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
855 856
{
	struct cfb_info *cfb = (struct cfb_info *)info;
857
	struct fb_var_screeninfo *var = &cfb->fb.var;
Linus Torvalds's avatar
Linus Torvalds committed
858
	struct par_info hw;
859
	unsigned int mem;
Linus Torvalds's avatar
Linus Torvalds committed
860

861 862
	hw.width = var->xres_virtual;
	hw.ramdac = RAMDAC_VREFEN | RAMDAC_DAC8BIT;
Linus Torvalds's avatar
Linus Torvalds committed
863

864 865 866 867 868 869
	switch (var->bits_per_pixel) {
	case 8:
		hw.co_pixfmt		= CO_PIXFMT_8BPP;
		hw.pitch		= hw.width >> 3;
		hw.extseqmisc		= EXT_SEQ_MISC_8;
		break;
870

871 872 873
	case 16:
		hw.co_pixfmt		= CO_PIXFMT_16BPP;
		hw.pitch		= hw.width >> 2;
874

875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
		switch (var->green.length) {
		case 6: /* RGB565, 64k */
			hw.extseqmisc	= EXT_SEQ_MISC_16_RGB565;
			break;
		case 5: /* RGB555, 32k */
			hw.extseqmisc	= EXT_SEQ_MISC_16_RGB555;
			break;
		case 4: /* RGB444, 4k + transparency? */
			hw.extseqmisc	= EXT_SEQ_MISC_16_RGB444;
			break;
		default:
			BUG();
		}
	case 24:/* TRUECOLOUR, 16m */
		hw.co_pixfmt		= CO_PIXFMT_24BPP;
		hw.width		*= 3;
		hw.pitch		= hw.width >> 3;
		hw.ramdac		|= (RAMDAC_BYPASS | RAMDAC_RAMPWRDN);
		hw.extseqmisc		= EXT_SEQ_MISC_24_RGB888;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
895

896 897 898 899 900 901
	case 32:/* TRUECOLOUR, 16m */
		hw.co_pixfmt		= CO_PIXFMT_32BPP;
		hw.pitch		= hw.width >> 1;
		hw.ramdac		|= (RAMDAC_BYPASS | RAMDAC_RAMPWRDN);
		hw.extseqmisc		= EXT_SEQ_MISC_32;
		break;
902

903 904 905
	default:
		BUG();
	}
Linus Torvalds's avatar
Linus Torvalds committed
906

907
	/*
908 909 910 911 912 913 914 915 916
	 * Sigh, this is absolutely disgusting, but caused by
	 * the way the fbcon developers want to separate out
	 * the "checking" and the "setting" of the video mode.
	 *
	 * If the mode is not suitable for the hardware here,
	 * we can't prevent it being set by returning an error.
	 *
	 * In theory, since NetWinders contain just one VGA card,
	 * we should never end up hitting this problem.
917
	 */
918 919 920 921 922 923 924 925
	BUG_ON(cyber2000fb_decode_clock(&hw, cfb, var) != 0);
	BUG_ON(cyber2000fb_decode_crtc(&hw, cfb, var) != 0);

	hw.width -= 1;
	hw.fetch = hw.pitch;
	if (!(cfb->mem_ctl2 & MEM_CTL2_64BIT))
		hw.fetch <<= 1;
	hw.fetch += 1;
926 927

	cfb->fb.fix.line_length	= var->xres_virtual * var->bits_per_pixel / 8;
Linus Torvalds's avatar
Linus Torvalds committed
928

929 930 931 932 933 934 935 936 937
	/*
	 * Same here - if the size of the video mode exceeds the
	 * available RAM, we can't prevent this mode being set.
	 *
	 * In theory, since NetWinders contain just one VGA card,
	 * we should never end up hitting this problem.
	 */
	mem = cfb->fb.fix.line_length * var->yres_virtual;
	BUG_ON(mem > cfb->fb.fix.smem_len);
Linus Torvalds's avatar
Linus Torvalds committed
938

939
	/*
940 941 942 943
	 * 8bpp displays are always pseudo colour.  16bpp and above
	 * are direct colour or true colour, depending on whether
	 * the RAMDAC palettes are bypassed.  (Direct colour has
	 * palettes, true colour does not.)
944 945 946 947 948 949 950 951
	 */
	if (var->bits_per_pixel == 8)
		cfb->fb.fix.visual = FB_VISUAL_PSEUDOCOLOR;
	else if (hw.ramdac & RAMDAC_BYPASS)
		cfb->fb.fix.visual = FB_VISUAL_TRUECOLOR;
	else
		cfb->fb.fix.visual = FB_VISUAL_DIRECTCOLOR;

Linus Torvalds's avatar
Linus Torvalds committed
952
	cyber2000fb_set_timing(cfb, &hw);
953 954
	cyber2000fb_update_start(cfb, var);

Linus Torvalds's avatar
Linus Torvalds committed
955 956 957 958 959 960 961 962
	return 0;
}


/*
 *    Pan or Wrap the Display
 */
static int
963
cyber2000fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
964 965 966 967 968 969
{
	struct cfb_info *cfb = (struct cfb_info *)info;

	if (cyber2000fb_update_start(cfb, var))
		return -EINVAL;

970 971 972
	cfb->fb.var.xoffset = var->xoffset;
	cfb->fb.var.yoffset = var->yoffset;

Linus Torvalds's avatar
Linus Torvalds committed
973
	if (var->vmode & FB_VMODE_YWRAP) {
974
		cfb->fb.var.vmode |= FB_VMODE_YWRAP;
Linus Torvalds's avatar
Linus Torvalds committed
975
	} else {
976
		cfb->fb.var.vmode &= ~FB_VMODE_YWRAP;
Linus Torvalds's avatar
Linus Torvalds committed
977 978 979 980 981 982 983
	}

	return 0;
}

/*
 *    (Un)Blank the display.
984 985 986 987 988 989 990 991 992 993 994 995 996 997
 *
 *  Blank the screen if blank_mode != 0, else unblank. If
 *  blank == NULL then the caller blanks by setting the CLUT
 *  (Color Look Up Table) to all black. Return 0 if blanking
 *  succeeded, != 0 if un-/blanking failed due to e.g. a
 *  video mode which doesn't support it. Implements VESA
 *  suspend and powerdown modes on hardware that supports
 *  disabling hsync/vsync:
 *    blank_mode == 2: suspend vsync
 *    blank_mode == 3: suspend hsync
 *    blank_mode == 4: powerdown
 *
 *  wms...Enable VESA DMPS compatible powerdown mode
 *  run "setterm -powersave powerdown" to take advantage
Linus Torvalds's avatar
Linus Torvalds committed
998
 */
999
static int cyber2000fb_blank(int blank, struct fb_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
1000 1001
{
	struct cfb_info *cfb = (struct cfb_info *)info;
1002
	unsigned int sync = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1003 1004 1005 1006
	int i;

	switch (blank) {
	case 4:	/* powerdown - both sync lines down */
1007
		sync = EXT_SYNC_CTL_VS_0 | EXT_SYNC_CTL_HS_0;
Linus Torvalds's avatar
Linus Torvalds committed
1008 1009
		break;	
	case 3:	/* hsync off */
1010
		sync = EXT_SYNC_CTL_VS_NORMAL | EXT_SYNC_CTL_HS_0;
Linus Torvalds's avatar
Linus Torvalds committed
1011 1012
		break;	
	case 2:	/* vsync off */
1013 1014 1015 1016 1017 1018
		sync = EXT_SYNC_CTL_VS_0 | EXT_SYNC_CTL_HS_NORMAL;
		break;
	case 1:	/* soft blank */
	default: /* unblank */
		break;
	}
1019

1020 1021
	cyber2000_grphw(EXT_SYNC_CTL, sync, cfb);

1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
	if (blank <= 1) {
		/* turn on ramdacs */
		cfb->ramdac_powerdown &= ~(RAMDAC_DACPWRDN | RAMDAC_BYPASS | RAMDAC_RAMPWRDN);
		cyber2000fb_write_ramdac_ctrl(cfb);
	}

	/*
	 * Soft blank/unblank the display.
	 */
	if (blank) {	/* soft blank */
Linus Torvalds's avatar
Linus Torvalds committed
1032
		for (i = 0; i < NR_PALETTE; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
1033 1034 1035 1036
			cyber2000fb_writeb(i, 0x3c8, cfb);
			cyber2000fb_writeb(0, 0x3c9, cfb);
			cyber2000fb_writeb(0, 0x3c9, cfb);
			cyber2000fb_writeb(0, 0x3c9, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1037
		}
1038
	} else {	/* unblank */
Linus Torvalds's avatar
Linus Torvalds committed
1039
		for (i = 0; i < NR_PALETTE; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
1040 1041 1042 1043
			cyber2000fb_writeb(i, 0x3c8, cfb);
			cyber2000fb_writeb(cfb->palette[i].red, 0x3c9, cfb);
			cyber2000fb_writeb(cfb->palette[i].green, 0x3c9, cfb);
			cyber2000fb_writeb(cfb->palette[i].blue, 0x3c9, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1044 1045
		}
	}
1046 1047 1048 1049 1050 1051 1052

	if (blank >= 2) {
		/* turn off ramdacs */
		cfb->ramdac_powerdown |= RAMDAC_DACPWRDN | RAMDAC_BYPASS | RAMDAC_RAMPWRDN;
		cyber2000fb_write_ramdac_ctrl(cfb);
	}

1053
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1054 1055 1056
}

static struct fb_ops cyber2000fb_ops = {
1057
	.owner		= THIS_MODULE,
1058 1059
	.fb_check_var	= cyber2000fb_check_var,
	.fb_set_par	= cyber2000fb_set_par,
1060 1061
	.fb_setcolreg	= cyber2000fb_setcolreg,
	.fb_blank	= cyber2000fb_blank,
1062 1063 1064 1065 1066 1067
	.fb_pan_display	= cyber2000fb_pan_display,
	.fb_fillrect	= cyber2000fb_fillrect,
	.fb_copyarea	= cyber2000fb_copyarea,
	.fb_imageblit	= cyber2000fb_imageblit,
	.fb_cursor	= soft_cursor,
	.fb_sync	= cyber2000fb_sync,
Linus Torvalds's avatar
Linus Torvalds committed
1068 1069
};

1070 1071 1072 1073 1074 1075 1076
/*
 * This is the only "static" reference to the internal data structures
 * of this driver.  It is here solely at the moment to support the other
 * CyberPro modules external to this driver.
 */
static struct cfb_info		*int_cfb_info;

Linus Torvalds's avatar
Linus Torvalds committed
1077 1078 1079
/*
 * Enable access to the extended registers
 */
1080
void cyber2000fb_enable_extregs(struct cfb_info *cfb)
Linus Torvalds's avatar
Linus Torvalds committed
1081 1082 1083 1084 1085 1086
{
	cfb->func_use_count += 1;

	if (cfb->func_use_count == 1) {
		int old;

1087 1088 1089
		old = cyber2000_grphr(EXT_FUNC_CTL, cfb);
		old |= EXT_FUNC_CTL_EXTREGENBL;
		cyber2000_grphw(EXT_FUNC_CTL, old, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1090 1091 1092 1093 1094 1095
	}
}

/*
 * Disable access to the extended registers
 */
1096
void cyber2000fb_disable_extregs(struct cfb_info *cfb)
Linus Torvalds's avatar
Linus Torvalds committed
1097 1098 1099 1100
{
	if (cfb->func_use_count == 1) {
		int old;

1101 1102 1103
		old = cyber2000_grphr(EXT_FUNC_CTL, cfb);
		old &= ~EXT_FUNC_CTL_EXTREGENBL;
		cyber2000_grphw(EXT_FUNC_CTL, old, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1104 1105
	}

1106 1107 1108 1109
	if (cfb->func_use_count == 0)
		printk(KERN_ERR "disable_extregs: count = 0\n");
	else
		cfb->func_use_count -= 1;
Linus Torvalds's avatar
Linus Torvalds committed
1110 1111
}

1112 1113
void cyber2000fb_get_fb_var(struct cfb_info *cfb, struct fb_var_screeninfo *var)
{
1114
	memcpy(var, &cfb->fb.var, sizeof(struct fb_var_screeninfo));
1115
}
Linus Torvalds's avatar
Linus Torvalds committed
1116 1117 1118 1119 1120 1121 1122 1123

/*
 * Attach a capture/tv driver to the core CyberX0X0 driver.
 */
int cyber2000fb_attach(struct cyberpro_info *info, int idx)
{
	if (int_cfb_info != NULL) {
		info->dev	      = int_cfb_info->dev;
Linus Torvalds's avatar
Linus Torvalds committed
1124
		info->regs	      = int_cfb_info->regs;
Linus Torvalds's avatar
Linus Torvalds committed
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
		info->fb	      = int_cfb_info->fb.screen_base;
		info->fb_size	      = int_cfb_info->fb.fix.smem_len;
		info->enable_extregs  = cyber2000fb_enable_extregs;
		info->disable_extregs = cyber2000fb_disable_extregs;
		info->info            = int_cfb_info;

		strncpy(info->dev_name, int_cfb_info->fb.fix.id, sizeof(info->dev_name));
	}

	return int_cfb_info != NULL;
}

/*
 * Detach a capture/tv driver from the core CyberX0X0 driver.
 */
void cyber2000fb_detach(int idx)
{
}

EXPORT_SYMBOL(cyber2000fb_attach);
EXPORT_SYMBOL(cyber2000fb_detach);
1146 1147 1148
EXPORT_SYMBOL(cyber2000fb_enable_extregs);
EXPORT_SYMBOL(cyber2000fb_disable_extregs);
EXPORT_SYMBOL(cyber2000fb_get_fb_var);
Linus Torvalds's avatar
Linus Torvalds committed
1149 1150 1151 1152 1153 1154

/*
 * These parameters give
 * 640x480, hsync 31.5kHz, vsync 60Hz
 */
static struct fb_videomode __devinitdata cyber2000fb_default_mode = {
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
	.refresh	= 60,
	.xres		= 640,
	.yres		= 480,
	.pixclock	= 39722,
	.left_margin	= 56,
	.right_margin	= 16,
	.upper_margin	= 34,
	.lower_margin	= 9,
	.hsync_len	= 88,
	.vsync_len	= 2,
	.sync		= FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
	.vmode		= FB_VMODE_NONINTERLACED
Linus Torvalds's avatar
Linus Torvalds committed
1167 1168 1169
};

static char igs_regs[] __devinitdata = {
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
	EXT_CRT_IRQ,		0,
	EXT_CRT_TEST,		0,
	EXT_SYNC_CTL,		0,
	EXT_SEG_WRITE_PTR,	0,
	EXT_SEG_READ_PTR,	0,
	EXT_BIU_MISC,		EXT_BIU_MISC_LIN_ENABLE |
				EXT_BIU_MISC_COP_ENABLE |
				EXT_BIU_MISC_COP_BFC,
	EXT_FUNC_CTL,		0,
	CURS_H_START,		0,
	CURS_H_START + 1,	0,
	CURS_H_PRESET,		0,
	CURS_V_START,		0,
	CURS_V_START + 1,	0,
	CURS_V_PRESET,		0,
	CURS_CTL,		0,
	EXT_ATTRIB_CTL,		EXT_ATTRIB_CTL_EXT,
	EXT_OVERSCAN_RED,	0,
	EXT_OVERSCAN_GREEN,	0,
	EXT_OVERSCAN_BLUE,	0,

	/* some of these are questionable when we have a BIOS */
	EXT_MEM_CTL0,		EXT_MEM_CTL0_7CLK |
				EXT_MEM_CTL0_RAS_1 |
				EXT_MEM_CTL0_MULTCAS,
	EXT_HIDDEN_CTL1,	0x30,
	EXT_FIFO_CTL,		0x0b,
	EXT_FIFO_CTL + 1,	0x17,
	0x76,			0x00,
	EXT_HIDDEN_CTL4,	0xc8
Linus Torvalds's avatar
Linus Torvalds committed
1200 1201 1202
};

/*
1203 1204 1205
 * Initialise the CyberPro hardware.  On the CyberPro5XXXX,
 * ensure that we're using the correct PLL (5XXX's may be
 * programmed to use an additional set of PLLs.)
Linus Torvalds's avatar
Linus Torvalds committed
1206
 */
1207
static void cyberpro_init_hw(struct cfb_info *cfb)
Linus Torvalds's avatar
Linus Torvalds committed
1208 1209 1210 1211
{
	int i;

	for (i = 0; i < sizeof(igs_regs); i += 2)
Linus Torvalds's avatar
Linus Torvalds committed
1212
		cyber2000_grphw(igs_regs[i], igs_regs[i+1], cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1213

1214
	if (cfb->id == ID_CYBERPRO_5000) {
1215 1216 1217 1218
		unsigned char val;
		cyber2000fb_writeb(0xba, 0x3ce, cfb);
		val = cyber2000fb_readb(0x3cf, cfb) & 0x80;
		cyber2000fb_writeb(val, 0x3cf, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1219 1220 1221 1222
	}
}

static struct cfb_info * __devinit
1223
cyberpro_alloc_fb_info(unsigned int id, char *name)
Linus Torvalds's avatar
Linus Torvalds committed
1224 1225 1226
{
	struct cfb_info *cfb;

1227
	cfb = kmalloc(sizeof(struct cfb_info) +
Linus Torvalds's avatar
Linus Torvalds committed
1228 1229 1230 1231 1232
		       sizeof(u32) * 16, GFP_KERNEL);

	if (!cfb)
		return NULL;

1233
	memset(cfb, 0, sizeof(struct cfb_info));
Linus Torvalds's avatar
Linus Torvalds committed
1234

1235 1236
	cfb->id			= id;

1237
	if (id == ID_CYBERPRO_5000)
Linus Torvalds's avatar
Linus Torvalds committed
1238 1239 1240 1241
		cfb->ref_ps	= 40690; // 24.576 MHz
	else
		cfb->ref_ps	= 69842; // 14.31818 MHz (69841?)

Linus Torvalds's avatar
Linus Torvalds committed
1242 1243 1244 1245
	cfb->divisors[0]	= 1;
	cfb->divisors[1]	= 2;
	cfb->divisors[2]	= 4;

1246
	if (id == ID_CYBERPRO_2000)
Linus Torvalds's avatar
Linus Torvalds committed
1247
		cfb->divisors[3] = 8;
Linus Torvalds's avatar
Linus Torvalds committed
1248 1249
	else
		cfb->divisors[3] = 6;
Linus Torvalds's avatar
Linus Torvalds committed
1250

Linus Torvalds's avatar
Linus Torvalds committed
1251
	strcpy(cfb->fb.fix.id, name);
Linus Torvalds's avatar
Linus Torvalds committed
1252 1253 1254 1255 1256 1257

	cfb->fb.fix.type	= FB_TYPE_PACKED_PIXELS;
	cfb->fb.fix.type_aux	= 0;
	cfb->fb.fix.xpanstep	= 0;
	cfb->fb.fix.ypanstep	= 1;
	cfb->fb.fix.ywrapstep	= 0;
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275

	switch (id) {
	case ID_IGA_1682:
		cfb->fb.fix.accel = 0;
		break;

	case ID_CYBERPRO_2000:
		cfb->fb.fix.accel = FB_ACCEL_IGS_CYBER2000;
		break;

	case ID_CYBERPRO_2010:
		cfb->fb.fix.accel = FB_ACCEL_IGS_CYBER2010;
		break;

	case ID_CYBERPRO_5000:
		cfb->fb.fix.accel = FB_ACCEL_IGS_CYBER5000;
		break;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1276 1277 1278 1279 1280 1281 1282 1283 1284

	cfb->fb.var.nonstd	= 0;
	cfb->fb.var.activate	= FB_ACTIVATE_NOW;
	cfb->fb.var.height	= -1;
	cfb->fb.var.width	= -1;
	cfb->fb.var.accel_flags	= FB_ACCELF_TEXT;

	cfb->fb.fbops		= &cyber2000fb_ops;
	cfb->fb.flags		= FBINFO_FLAG_DEFAULT;
1285
	cfb->fb.pseudo_palette	= (void *)(cfb + 1);
Linus Torvalds's avatar
Linus Torvalds committed
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305

	fb_alloc_cmap(&cfb->fb.cmap, NR_PALETTE, 0);

	return cfb;
}

static void __devinit
cyberpro_free_fb_info(struct cfb_info *cfb)
{
	if (cfb) {
		/*
		 * Free the colourmap
		 */
		fb_alloc_cmap(&cfb->fb.cmap, 0, 0);

		kfree(cfb);
	}
}

/*
Linus Torvalds's avatar
Linus Torvalds committed
1306 1307
 * Parse Cyber2000fb options.  Usage:
 *  video=cyber2000:font:fontname
Linus Torvalds's avatar
Linus Torvalds committed
1308
 */
Linus Torvalds's avatar
Linus Torvalds committed
1309 1310
int
cyber2000fb_setup(char *options)
Linus Torvalds's avatar
Linus Torvalds committed
1311
{
Linus Torvalds's avatar
Linus Torvalds committed
1312
	char *opt;
Linus Torvalds's avatar
Linus Torvalds committed
1313

Linus Torvalds's avatar
Linus Torvalds committed
1314 1315
	if (!options || !*options)
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1316

Linus Torvalds's avatar
Linus Torvalds committed
1317 1318 1319
	while ((opt = strsep(&options, ",")) != NULL) {
		if (!*opt)
			continue;
Linus Torvalds's avatar
Linus Torvalds committed
1320

Linus Torvalds's avatar
Linus Torvalds committed
1321 1322 1323 1324 1325
		if (strncmp(opt, "font:", 5) == 0) {
			strncpy(default_font_storage, opt + 5, sizeof(default_font_storage));
			default_font = default_font_storage;
			continue;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1326

Linus Torvalds's avatar
Linus Torvalds committed
1327
		printk(KERN_ERR "CyberPro20x0: unknown parameter: %s\n", opt);
Linus Torvalds's avatar
Linus Torvalds committed
1328 1329 1330 1331
	}
	return 0;
}

1332 1333 1334 1335 1336 1337 1338 1339 1340
/*
 * The CyberPro chips can be placed on many different bus types.
 * This probe function is common to all bus types.  The bus-specific
 * probe function is expected to have:
 *  - enabled access to the linear memory region
 *  - memory mapped access to the registers
 *  - initialised mem_ctl1 and mem_ctl2 appropriately.
 */
static int __devinit cyberpro_common_probe(struct cfb_info *cfb)
Linus Torvalds's avatar
Linus Torvalds committed
1341 1342
{
	u_long smem_size;
1343
	u_int h_sync, v_sync;
Linus Torvalds's avatar
Linus Torvalds committed
1344 1345
	int err;

1346 1347
	cyberpro_init_hw(cfb);

1348 1349 1350 1351 1352 1353 1354
	/*
	 * Get the video RAM size and width from the VGA register.
	 * This should have been already initialised by the BIOS,
	 * but if it's garbage, claim default 1MB VRAM (woody)
	 */
	cfb->mem_ctl1 = cyber2000_grphr(EXT_MEM_CTL1, cfb);
	cfb->mem_ctl2 = cyber2000_grphr(EXT_MEM_CTL2, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1355

1356 1357 1358
	/*
	 * Determine the size of the memory.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
1359 1360 1361
	switch (cfb->mem_ctl2 & MEM_CTL2_SIZE_MASK) {
	case MEM_CTL2_SIZE_4MB:	smem_size = 0x00400000; break;
	case MEM_CTL2_SIZE_2MB:	smem_size = 0x00200000; break;
1362
	case MEM_CTL2_SIZE_1MB: smem_size = 0x00100000; break;
Linus Torvalds's avatar
Linus Torvalds committed
1363 1364 1365
	default:		smem_size = 0x00100000; break;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1366
	cfb->fb.fix.smem_len   = smem_size;
1367
	cfb->fb.fix.mmio_len   = MMIO_SIZE;
Linus Torvalds's avatar
Linus Torvalds committed
1368
	cfb->fb.screen_base    = cfb->region;
Linus Torvalds's avatar
Linus Torvalds committed
1369

1370
	err = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
	if (!fb_find_mode(&cfb->fb.var, &cfb->fb, NULL, NULL, 0,
	    		  &cyber2000fb_default_mode, 8)) {
		printk("%s: no valid mode found\n", cfb->fb.fix.id);
		goto failed;
	}

	cfb->fb.var.yres_virtual = cfb->fb.fix.smem_len * 8 /
			(cfb->fb.var.bits_per_pixel * cfb->fb.var.xres_virtual);

	if (cfb->fb.var.yres_virtual < cfb->fb.var.yres)
		cfb->fb.var.yres_virtual = cfb->fb.var.yres;

1383
//	fb_set_var(&cfb->fb.var, -1, &cfb->fb);
Linus Torvalds's avatar
Linus Torvalds committed
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396

	/*
	 * Calculate the hsync and vsync frequencies.  Note that
	 * we split the 1e12 constant up so that we can preserve
	 * the precision and fit the results into 32-bit registers.
	 *  (1953125000 * 512 = 1e12)
	 */
	h_sync = 1953125000 / cfb->fb.var.pixclock;
	h_sync = h_sync * 512 / (cfb->fb.var.xres + cfb->fb.var.left_margin +
		 cfb->fb.var.right_margin + cfb->fb.var.hsync_len);
	v_sync = h_sync / (cfb->fb.var.yres + cfb->fb.var.upper_margin +
		 cfb->fb.var.lower_margin + cfb->fb.var.vsync_len);

1397
	printk(KERN_INFO "%s: %dKiB VRAM, using %dx%d, %d.%03dkHz, %dHz\n",
Linus Torvalds's avatar
Linus Torvalds committed
1398 1399 1400 1401 1402
		cfb->fb.fix.id, cfb->fb.fix.smem_len >> 10,
		cfb->fb.var.xres, cfb->fb.var.yres,
		h_sync / 1000, h_sync % 1000, v_sync);

	err = register_framebuffer(&cfb->fb);
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421

failed:
	return err;
}

static void cyberpro_common_resume(struct cfb_info *cfb)
{
	cyberpro_init_hw(cfb);

	/*
	 * Reprogram the MEM_CTL1 and MEM_CTL2 registers
	 */
	cyber2000_grphw(EXT_MEM_CTL1, cfb->mem_ctl1, cfb);
	cyber2000_grphw(EXT_MEM_CTL2, cfb->mem_ctl2, cfb);

	/*
	 * Restore the old video mode and the palette.
	 * We also need to tell fbcon to redraw the console.
	 */
1422
	cyber2000fb_set_par(&cfb->fb);
1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
}

#ifdef CONFIG_ARCH_SHARK

#include <asm/arch/hardware.h>

static int __devinit
cyberpro_vl_probe(void)
{
	struct cfb_info *cfb;
	int err = -ENOMEM;

	if (!request_mem_region(FB_START,FB_SIZE,"CyberPro2010")) return err;

	cfb = cyberpro_alloc_fb_info(ID_CYBERPRO_2010, "CyberPro2010");
	if (!cfb)
		goto failed_release;

	cfb->dev = NULL;
	cfb->region = ioremap(FB_START,FB_SIZE);
	if (!cfb->region)
		goto failed_ioremap;

	cfb->regs = cfb->region + MMIO_OFFSET;
	cfb->fb.fix.mmio_start = FB_START + MMIO_OFFSET;
	cfb->fb.fix.smem_start = FB_START;

	/*
	 * Bring up the hardware.  This is expected to enable access
	 * to the linear memory region, and allow access to the memory
	 * mapped registers.  Also, mem_ctl1 and mem_ctl2 must be
	 * initialised.
	 */
	cyber2000fb_writeb(0x18, 0x46e8, cfb);
	cyber2000fb_writeb(0x01, 0x102, cfb);
	cyber2000fb_writeb(0x08, 0x46e8, cfb);
	cyber2000fb_writeb(EXT_BIU_MISC, 0x3ce, cfb);
	cyber2000fb_writeb(EXT_BIU_MISC_LIN_ENABLE, 0x3cf, cfb);

	cfb->mclk_mult = 0xdb;
	cfb->mclk_div  = 0x54;

	err = cyberpro_common_probe(cfb);
	if (err)
		goto failed;

	if (int_cfb_info == NULL)
		int_cfb_info = cfb;

	return 0;

failed:
	iounmap(cfb->region);
failed_ioremap:
	cyberpro_free_fb_info(cfb);
failed_release:
	release_mem_region(FB_START,FB_SIZE);

	return err;
}
#endif /* CONFIG_ARCH_SHARK */

/*
 * PCI specific support.
 */
#ifdef CONFIG_PCI
/*
 * We need to wake up the CyberPro, and make sure its in linear memory
 * mode.  Unfortunately, this is specific to the platform and card that
 * we are running on.
 *
 * On x86 and ARM, should we be initialising the CyberPro first via the
 * IO registers, and then the MMIO registers to catch all cases?  Can we
 * end up in the situation where the chip is in MMIO mode, but not awake
 * on an x86 system?
 */
static int cyberpro_pci_enable_mmio(struct cfb_info *cfb)
{
1501 1502
	unsigned char val;

1503
#if defined(__sparc_v9__)
1504
#error "You lose, consult DaveM."
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
#elif defined(__sparc__)
	/*
	 * SPARC does not have an "outb" instruction, so we generate
	 * I/O cycles storing into a reserved memory space at
	 * physical address 0x3000000
	 */
	unsigned char *iop;

	iop = ioremap(0x3000000, 0x5000);
	if (iop == NULL) {
		prom_printf("iga5000: cannot map I/O\n");
		return -ENOMEM;
	}

	writeb(0x18, iop + 0x46e8);
	writeb(0x01, iop + 0x102);
	writeb(0x08, iop + 0x46e8);
	writeb(EXT_BIU_MISC, iop + 0x3ce);
	writeb(EXT_BIU_MISC_LIN_ENABLE, iop + 0x3cf);

	iounmap((void *)iop);
#else
	/*
	 * Most other machine types are "normal", so
	 * we use the standard IO-based wakeup.
	 */
	outb(0x18, 0x46e8);
	outb(0x01, 0x102);
	outb(0x08, 0x46e8);
	outb(EXT_BIU_MISC, 0x3ce);
	outb(EXT_BIU_MISC_LIN_ENABLE, 0x3cf);
#endif
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552

	/*
	 * Allow the CyberPro to accept PCI burst accesses
	 */
	val = cyber2000_grphr(EXT_BUS_CTL, cfb);
	if (!(val & EXT_BUS_CTL_PCIBURST_WRITE)) {
		printk(KERN_INFO "%s: enabling PCI bursts\n", cfb->fb.fix.id);

		val |= EXT_BUS_CTL_PCIBURST_WRITE;

		if (cfb->id == ID_CYBERPRO_5000)
			val |= EXT_BUS_CTL_PCIBURST_READ;

		cyber2000_grphw(EXT_BUS_CTL, val, cfb);
	}

1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600
	return 0;
}

static int __devinit
cyberpro_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
	struct cfb_info *cfb;
	char name[16];
	int err;

	sprintf(name, "CyberPro%4X", id->device);

	err = pci_enable_device(dev);
	if (err)
		return err;

	err = pci_request_regions(dev, name);
	if (err)
		return err;

	err = -ENOMEM;
	cfb = cyberpro_alloc_fb_info(id->driver_data, name);
	if (!cfb)
		goto failed_release;

	cfb->dev = dev;
	cfb->region = ioremap(pci_resource_start(dev, 0),
			      pci_resource_len(dev, 0));
	if (!cfb->region)
		goto failed_ioremap;

	cfb->regs = cfb->region + MMIO_OFFSET;
	cfb->fb.fix.mmio_start = pci_resource_start(dev, 0) + MMIO_OFFSET;
	cfb->fb.fix.smem_start = pci_resource_start(dev, 0);

	/*
	 * Bring up the hardware.  This is expected to enable access
	 * to the linear memory region, and allow access to the memory
	 * mapped registers.  Also, mem_ctl1 and mem_ctl2 must be
	 * initialised.
	 */
	err = cyberpro_pci_enable_mmio(cfb);
	if (err)
		goto failed;

	/*
	 * Use MCLK from BIOS. FIXME: what about hotplug?
	 */
1601 1602
	cfb->mclk_mult = cyber2000_grphr(EXT_MCLK_MULT, cfb);
	cfb->mclk_div  = cyber2000_grphr(EXT_MCLK_DIV, cfb);
Russell King's avatar
Russell King committed
1603 1604

#ifdef __arm__
1605 1606 1607
	/*
	 * MCLK on the NetWinder and the Shark is fixed at 75MHz
	 */
Russell King's avatar
Russell King committed
1608 1609 1610 1611
	if (machine_is_netwinder()) {
		cfb->mclk_mult = 0xdb;
		cfb->mclk_div  = 0x54;
	}
1612 1613 1614 1615
#endif

	err = cyberpro_common_probe(cfb);
	if (err)
Linus Torvalds's avatar
Linus Torvalds committed
1616 1617 1618 1619 1620
		goto failed;

	/*
	 * Our driver data
	 */
Linus Torvalds's avatar
Linus Torvalds committed
1621
	pci_set_drvdata(dev, cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1622 1623 1624 1625 1626 1627
	if (int_cfb_info == NULL)
		int_cfb_info = cfb;

	return 0;

failed:
Linus Torvalds's avatar
Linus Torvalds committed
1628 1629
	iounmap(cfb->region);
failed_ioremap:
Linus Torvalds's avatar
Linus Torvalds committed
1630
	cyberpro_free_fb_info(cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1631
failed_release:
Linus Torvalds's avatar
Linus Torvalds committed
1632 1633
	pci_release_regions(dev);

Linus Torvalds's avatar
Linus Torvalds committed
1634 1635 1636
	return err;
}

1637
static void __devexit cyberpro_pci_remove(struct pci_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1638
{
Linus Torvalds's avatar
Linus Torvalds committed
1639
	struct cfb_info *cfb = pci_get_drvdata(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650

	if (cfb) {
		/*
		 * If unregister_framebuffer fails, then
		 * we will be leaving hooks that could cause
		 * oopsen laying around.
		 */
		if (unregister_framebuffer(&cfb->fb))
			printk(KERN_WARNING "%s: danger Will Robinson, "
				"danger danger!  Oopsen imminent!\n",
				cfb->fb.fix.id);
Linus Torvalds's avatar
Linus Torvalds committed
1651
		iounmap(cfb->region);
Linus Torvalds's avatar
Linus Torvalds committed
1652 1653 1654 1655 1656 1657
		cyberpro_free_fb_info(cfb);

		/*
		 * Ensure that the driver data is no longer
		 * valid.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
1658
		pci_set_drvdata(dev, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
1659 1660
		if (cfb == int_cfb_info)
			int_cfb_info = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1661 1662

		pci_release_regions(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1663 1664 1665
	}
}

1666
static int cyberpro_pci_suspend(struct pci_dev *dev, u32 state)
Linus Torvalds's avatar
Linus Torvalds committed
1667
{
Linus Torvalds's avatar
Linus Torvalds committed
1668
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1669 1670 1671 1672 1673
}

/*
 * Re-initialise the CyberPro hardware
 */
1674
static int cyberpro_pci_resume(struct pci_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1675
{
Linus Torvalds's avatar
Linus Torvalds committed
1676
	struct cfb_info *cfb = pci_get_drvdata(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1677 1678

	if (cfb) {
1679 1680
		cyberpro_pci_enable_mmio(cfb);
		cyberpro_common_resume(cfb);
Linus Torvalds's avatar
Linus Torvalds committed
1681
	}
Linus Torvalds's avatar
Linus Torvalds committed
1682 1683

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1684 1685 1686
}

static struct pci_device_id cyberpro_pci_table[] __devinitdata = {
1687 1688 1689
//	Not yet
//	{ PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_1682,
//		PCI_ANY_ID, PCI_ANY_ID, 0, 0, ID_IGA_1682 },
Linus Torvalds's avatar
Linus Torvalds committed
1690
	{ PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_2000,
1691
		PCI_ANY_ID, PCI_ANY_ID, 0, 0, ID_CYBERPRO_2000 },
Linus Torvalds's avatar
Linus Torvalds committed
1692
	{ PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_2010,
1693
		PCI_ANY_ID, PCI_ANY_ID, 0, 0, ID_CYBERPRO_2010 },
Linus Torvalds's avatar
Linus Torvalds committed
1694
	{ PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_5000,
1695
		PCI_ANY_ID, PCI_ANY_ID, 0, 0, ID_CYBERPRO_5000 },
Linus Torvalds's avatar
Linus Torvalds committed
1696 1697 1698
	{ 0, }
};

1699 1700
MODULE_DEVICE_TABLE(pci,cyberpro_pci_table);

Linus Torvalds's avatar
Linus Torvalds committed
1701
static struct pci_driver cyberpro_driver = {
1702 1703 1704 1705 1706 1707
	.name		= "CyberPro",
	.probe		= cyberpro_pci_probe,
	.remove		= __devexit_p(cyberpro_pci_remove),
	.suspend	= cyberpro_pci_suspend,
	.resume		= cyberpro_pci_resume,
	.id_table	= cyberpro_pci_table
Linus Torvalds's avatar
Linus Torvalds committed
1708
};
1709
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1710 1711 1712 1713 1714 1715 1716 1717

/*
 * I don't think we can use the "module_init" stuff here because
 * the fbcon stuff may not be initialised yet.  Hence the #ifdef
 * around module_init.
 */
int __init cyber2000fb_init(void)
{
1718 1719
	int ret = -1, err;

1720 1721 1722
#ifdef CONFIG_ARCH_SHARK
	err = cyberpro_vl_probe();
	if (!err) {
1723
		ret = 0;
1724 1725 1726
		MOD_INC_USE_COUNT;
	}
#endif
1727
#ifdef CONFIG_PCI
1728 1729
	err = pci_module_init(&cyberpro_driver);
	if (!err)
1730 1731
		ret = 0;
#endif
1732

1733
	return ret ? err : 0;
Linus Torvalds's avatar
Linus Torvalds committed
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
}

static void __exit cyberpro_exit(void)
{
	pci_unregister_driver(&cyberpro_driver);
}

#ifdef MODULE
module_init(cyber2000fb_init);
#endif
module_exit(cyberpro_exit);
Linus Torvalds's avatar
Linus Torvalds committed
1745 1746 1747 1748

MODULE_AUTHOR("Russell King");
MODULE_DESCRIPTION("CyberPro 2000, 2010 and 5000 framebuffer driver");
MODULE_LICENSE("GPL");