matroxfb_maven.c

linux-2.4.29操作系统的源码

			m->regs[0x91] = vdec;
			m->regs[0x92] = vdec >> 8;
			m->regs[0xBE] = vlen;
		}
		m->regs[0xB0] = 0x08;	/* output: SVideo/Composite */
		return 0;
	}

	DAC1064_calcclock(mt->pixclock, 450000, &a, &bv, &c);
	m->regs[0x80] = a;
	m->regs[0x81] = bv;
	m->regs[0x82] = c | 0x80;

	m->regs[0xB3] = 0x01;
	m->regs[0x94] = 0xB2;

	/* htotal... */
	m->regs[0x96] = mt->HTotal;
	m->regs[0x97] = mt->HTotal >> 8;
	/* ?? */
	m->regs[0x98] = 0x00;
	m->regs[0x99] = 0x00;
	/* hsync len */
	tmpi = mt->HSyncEnd - mt->HSyncStart;
	m->regs[0x9A] = tmpi;
	m->regs[0x9B] = tmpi >> 8;
	/* hblank end */
	tmpi = mt->HTotal - mt->HSyncStart;
	m->regs[0x9C] = tmpi;
	m->regs[0x9D] = tmpi >> 8;
	/* hblank start */
	tmpi += mt->HDisplay;
	m->regs[0x9E] = tmpi;
	m->regs[0x9F] = tmpi >> 8;
	/* htotal + 1 */
	tmpi = mt->HTotal + 1;
	m->regs[0xA0] = tmpi;
	m->regs[0xA1] = tmpi >> 8;
	/* vsync?! */
	tmpi = mt->VSyncEnd - mt->VSyncStart - 1;
	m->regs[0xA2] = tmpi;
	m->regs[0xA3] = tmpi >> 8;
	/* ignored? */
	tmpi = mt->VTotal - mt->VSyncStart;
	m->regs[0xA4] = tmpi;
	m->regs[0xA5] = tmpi >> 8;
	/* ignored? */
	tmpi = mt->VTotal - 1;
	m->regs[0xA6] = tmpi;
	m->regs[0xA7] = tmpi >> 8;
	/* vtotal - 1 */
	m->regs[0xA8] = tmpi;
	m->regs[0xA9] = tmpi >> 8;
	/* hor vidrst */
	tmpi = mt->HTotal - mt->delay;
	m->regs[0xAA] = tmpi;
	m->regs[0xAB] = tmpi >> 8;
	/* vert vidrst */
	tmpi = mt->VTotal - 2;
	m->regs[0xAC] = tmpi;
	m->regs[0xAD] = tmpi >> 8;
	/* ignored? */
	m->regs[0xAE] = 0x00;
	m->regs[0xAF] = 0x00;

	m->regs[0xB0] = 0x03;	/* output: monitor */
	m->regs[0xB1] = 0xA0;	/* ??? */
	m->regs[0x8C] = 0x20;	/* must be set... */
	m->regs[0x8D] = 0x04;	/* defaults to 0x10: test signal */
	m->regs[0xB9] = 0x1A;	/* defaults to 0x2C: too bright */
	m->regs[0xBF] = 0x22;	/* makes picture stable */

	return 0;
}

static inline int maven_program_timming(struct maven_data* md,
		const struct mavenregs* m) {
	struct i2c_client* c = md->client;

	if (m->mode & MODE_MONITOR) {
		LR(0x80);
		LR(0x81);
		LR(0x82);

		LR(0xB3);
		LR(0x94);

		LRP(0x96);
		LRP(0x98);
		LRP(0x9A);
		LRP(0x9C);
		LRP(0x9E);
		LRP(0xA0);
		LRP(0xA2);
		LRP(0xA4);
		LRP(0xA6);
		LRP(0xA8);
		LRP(0xAA);
		LRP(0xAC);
		LRP(0xAE);

		LR(0xB0);	/* output: monitor */
		LR(0xB1);	/* ??? */
		LR(0x8C);	/* must be set... */
		LR(0x8D);	/* defaults to 0x10: test signal */
		LR(0xB9);	/* defaults to 0x2C: too bright */
		LR(0xBF);	/* makes picture stable */
	} else {
		maven_init_TV(c, m);
	}
	return 0;
}

static inline int maven_start(struct maven_data* md) {
	struct i2c_client* c = md->client;
	maven_set_reg(c, 0x95, 0x20);	/* start whole thing */
	return 0;
}

static int maven_get_queryctrl (struct maven_data* md, 
				struct matroxfb_queryctrl *p) {
	int i;
	
	i = get_ctrl_id(p->id);
	if (i >= 0) {
		*p = maven_controls[i].desc;
		return 0;
	}
	if (i == -ENOENT) {
		static const struct matroxfb_queryctrl disctrl = 
			{ 0, "", 0, 0, 0, 0, 0, 1, 1, "Disabled" };
			
		i = p->id;
		*p = disctrl;
		p->id = i;
		sprintf(p->name, "Ctrl #%08X", i);
		return 0;
	}
	return -EINVAL;
}

static int maven_set_control (struct maven_data* md, 
			      struct matroxfb_control *p) {
	int i;
	
	i = get_ctrl_id(p->id);
	if (i < 0) return -EINVAL;

	/*
	 * Check if changed.
	 */
	if (p->value == *get_ctrl_ptr(md, i)) return 0;

	/*
	 * Check limits.
	 */
	if (p->value > maven_controls[i].desc.maximum) return -EINVAL;
	if (p->value < maven_controls[i].desc.minimum) return -EINVAL;

	/*
	 * Store new value.
	 */
	*get_ctrl_ptr(md, i) = p->value;

	switch (p->id) {
		case MATROXFB_CID_BRIGHTNESS:
		case MATROXFB_CID_CONTRAST:
		{
		  int blacklevel, whitelevel;
		  maven_compute_bwlevel(md, &blacklevel, &whitelevel);
		  blacklevel = (blacklevel >> 2) | ((blacklevel & 3) << 8);
		  whitelevel = (whitelevel >> 2) | ((whitelevel & 3) << 8);
		  maven_set_reg_pair(md->client, 0x0e, blacklevel);
		  maven_set_reg_pair(md->client, 0x1e, whitelevel);
		}
		break;
		case MATROXFB_CID_SATURATION:
		{
		  maven_set_reg(md->client, 0x20, p->value);
		  maven_set_reg(md->client, 0x22, p->value);
		}
		break;
		case MATROXFB_CID_HUE:
		{
		  maven_set_reg(md->client, 0x25, p->value);
		}
		break;
		case MATROXFB_CID_GAMMA:
		{
		  const struct maven_gamma* g;
		  g = maven_compute_gamma(md);
		  maven_set_reg(md->client, 0x83, g->reg83);
		  maven_set_reg(md->client, 0x84, g->reg84);
		  maven_set_reg(md->client, 0x85, g->reg85);
		  maven_set_reg(md->client, 0x86, g->reg86);
		  maven_set_reg(md->client, 0x87, g->reg87);
		  maven_set_reg(md->client, 0x88, g->reg88);
		  maven_set_reg(md->client, 0x89, g->reg89);
		  maven_set_reg(md->client, 0x8a, g->reg8a);
		  maven_set_reg(md->client, 0x8b, g->reg8b);
		}
		break;
		case MATROXFB_CID_TESTOUT:
		{
			unsigned char val 
			  = maven_get_reg (md->client,0x8d);
			if (p->value) val |= 0x10;
			else          val &= ~0x10;
			maven_set_reg (md->client, 0x8d, val);
		}
		break;
		case MATROXFB_CID_DEFLICKER:
		{
		  maven_set_reg(md->client, 0x93, maven_compute_deflicker(md));
		}
		break;
	}
	

	return 0;
}

static int maven_get_control (struct maven_data* md, 
			      struct matroxfb_control *p) {
	int i;
	
	i = get_ctrl_id(p->id);
	if (i < 0) return -EINVAL;
	p->value = *get_ctrl_ptr(md, i);
	return 0;
}

/******************************************************/

static int maven_out_compute(void* md, struct my_timming* mt) {
#define mdinfo ((struct maven_data*)md)
#define minfo (mdinfo->primary_head)
	return maven_compute_timming(md, mt, &ACCESS_FBINFO(hw).maven);
#undef minfo
#undef mdinfo
}

static int maven_out_program(void* md) {
#define mdinfo ((struct maven_data*)md)
#define minfo (mdinfo->primary_head)
	return maven_program_timming(md, &ACCESS_FBINFO(hw).maven);
#undef minfo
#undef mdinfo
}

static int maven_out_start(void* md) {
	return maven_start(md);
}

static int maven_out_verify_mode(void* md, u_int32_t arg) {
	switch (arg) {
		case MATROXFB_OUTPUT_MODE_PAL:
		case MATROXFB_OUTPUT_MODE_NTSC:
		case MATROXFB_OUTPUT_MODE_MONITOR:
			return 0;
	}
	return -EINVAL;
}

static int maven_out_get_queryctrl(void* md, struct matroxfb_queryctrl* p) {
        return maven_get_queryctrl(md, p);
}

static int maven_out_get_ctrl(void* md, struct matroxfb_control* p) {
	return maven_get_control(md, p);
}

static int maven_out_set_ctrl(void* md, struct matroxfb_control* p) {
	return maven_set_control(md, p);
}

static struct matrox_altout maven_altout = {
	.owner   = THIS_MODULE,
	.name	 = "Secondary output",
	.compute = maven_out_compute,
	.program = maven_out_program,
	.start   = maven_out_start,
	.verifymode = maven_out_verify_mode,
	.getqueryctrl = maven_out_get_queryctrl,
	.getctrl = maven_out_get_ctrl,
	.setctrl = maven_out_set_ctrl,
};

static int maven_init_client(struct i2c_client* clnt) {
	struct i2c_adapter* a = clnt->adapter;
	struct maven_data* md = clnt->data;
	MINFO_FROM(list_entry(a, struct i2c_bit_adapter, adapter)->minfo);

	md->primary_head = MINFO;
	md->client = clnt;
	down_write(&ACCESS_FBINFO(altout.lock));
	ACCESS_FBINFO(outputs[1]).output = &maven_altout;
	ACCESS_FBINFO(outputs[1]).src = MATROXFB_SRC_NONE;
	ACCESS_FBINFO(outputs[1]).data = md;
	ACCESS_FBINFO(outputs[1]).mode = MATROXFB_OUTPUT_MODE_MONITOR;
	up_write(&ACCESS_FBINFO(altout.lock));
	if (maven_get_reg(clnt, 0xB2) < 0x14) {
		md->version = MGATVO_B;
		/* Tweak some things for this old chip */
	} else {
		md->version = MGATVO_C;
	}
	/*
	 * Set all parameters to its initial values.
	 */
	{
		unsigned int i;

		for (i = 0; i < MAVCTRLS; ++i) {
			*get_ctrl_ptr(md, i) = maven_controls[i].desc.default_value;
		}
	}

	return 0;
}

static int maven_shutdown_client(struct i2c_client* clnt) {
	struct maven_data* md = clnt->data;

	if (md->primary_head) {
		MINFO_FROM(md->primary_head);

		down_write(&ACCESS_FBINFO(altout.lock));
		ACCESS_FBINFO(outputs[1]).src = MATROXFB_SRC_NONE;
		ACCESS_FBINFO(outputs[1]).output = NULL;
		ACCESS_FBINFO(outputs[1]).data = NULL;
		ACCESS_FBINFO(outputs[1]).mode = MATROXFB_OUTPUT_MODE_MONITOR;
		up_write(&ACCESS_FBINFO(altout.lock));
		md->primary_head = NULL;
	}
	return 0;
}

static unsigned short normal_i2c[] = { MAVEN_I2CID, I2C_CLIENT_END };
static unsigned short normal_i2c_range[] = { MAVEN_I2CID, MAVEN_I2CID, I2C_CLIENT_END };
I2C_CLIENT_INSMOD;

static void maven_inc_use(struct i2c_client* clnt) {
	MOD_INC_USE_COUNT;
}

static void maven_dec_use(struct i2c_client* clnt) {
	MOD_DEC_USE_COUNT;
}

static struct i2c_driver maven_driver;

static int maven_detect_client(struct i2c_adapter* adapter, int address, unsigned short flags,
		int kind) {
	int err = 0;
	struct i2c_client* new_client;
	struct maven_data* data;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_WORD_DATA |
					      I2C_FUNC_SMBUS_BYTE_DATA |
					      I2C_FUNC_PROTOCOL_MANGLING))
		goto ERROR0;
	if (!(new_client = (struct i2c_client*)kmalloc(sizeof(struct i2c_client) + sizeof(struct maven_data),
			GFP_KERNEL))) {
		err = -ENOMEM;
		goto ERROR0;
	}
	data = (struct maven_data*)(new_client + 1);
	new_client->data = data;
	new_client->addr = address;
	new_client->adapter = adapter;
	new_client->driver = &maven_driver;
	new_client->flags = 0;
	if (kind < 0) {
		;
	}
	strcpy(new_client->name, "maven client");
	if ((err = i2c_attach_client(new_client)))
		goto ERROR3;
	err = maven_init_client(new_client);
	if (err)
		goto ERROR4;
	return 0;
ERROR4:;
	i2c_detach_client(new_client);
ERROR3:;
	kfree(new_client);
ERROR0:;
	return err;
}

static int maven_attach_adapter(struct i2c_adapter* adapter) {
	if (adapter->id == (I2C_ALGO_BIT | I2C_HW_B_G400))
		return i2c_probe(adapter, &addr_data, &maven_detect_client);
	return 0;
}

static int maven_detach_client(struct i2c_client* client) {
	int err;

	if ((err = i2c_detach_client(client))) {
		printk(KERN_ERR "maven: Cannot deregister client\n");
		return err;
	}
	maven_shutdown_client(client);
	kfree(client);
	return 0;
}

static int maven_command(struct i2c_client* client, unsigned int cmd, void* arg) {
	return -ENOIOCTLCMD;	/* or -EINVAL, depends on who will call this */
}

static int maven_driver_registered = 0;

static struct i2c_driver maven_driver={
	"maven",
	I2C_DRIVERID_MGATVO,
	I2C_DF_NOTIFY,
	maven_attach_adapter,
	maven_detach_client,
	maven_command,
	maven_inc_use,
	maven_dec_use
};

/* ************************** */

static int matroxfb_maven_init(void) {
	int err;

	err = i2c_add_driver(&maven_driver);
	if (err) {
		printk(KERN_ERR "maven: Maven driver failed to register (%d).\n", err);
		return err;
	}
	maven_driver_registered = 1;
	return 0;
}

static void matroxfb_maven_exit(void) {
	if (maven_driver_registered)
		i2c_del_driver(&maven_driver);
}

MODULE_AUTHOR("(c) 1999-2002 Petr Vandrovec <[e-mail]>");
MODULE_DESCRIPTION("Matrox G200/G400 Matrox MGA-TVO driver");
MODULE_LICENSE("GPL");
module_init(matroxfb_maven_init);
module_exit(matroxfb_maven_exit);
/* we do not have __setup() yet */