pciscc.c

高速同步串口芯片PEB20534的驱动程序

		return 0;
	scs = CreateService(scm,Name,Name,SERVICE_ALL_ACCESS,
						SERVICE_KERNEL_DRIVER,SERVICE_DEMAND_START,
						SERVICE_ERROR_NORMAL,Path,NULL,NULL,NULL,NULL,NULL);
	if (scs == NULL)
		scs = OpenService(scm,Name,SERVICE_ALL_ACCESS);
	if (scs != NULL)
	{ 
		StartService(scs,0,NULL);
		CloseServiceHandle(scs);
		ret = 1;
	}
	CloseServiceHandle(scm);
	return ret;
}

int remove_service(char *Name)
{
	SC_HANDLE		scm;
	SC_HANDLE		scs;
	SERVICE_STATUS	ss;
	int				ret = 0;

	scm = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
	if (!scm)
		return 0;
	scs = OpenService(scm,Name,SERVICE_ALL_ACCESS);
	if (scs != NULL)
	{
		ControlService(scs,SERVICE_CONTROL_STOP,&ss);
		DeleteService(scs);
		CloseServiceHandle(scs);
		ret = 1;
	}
	CloseServiceHandle(scm);
	return ret;
}

void read_config(HKEY hKey)
{
	DWORD	reglen;

	config[0].baud = 1200;
	config[0].mode = 0;
	config[0].txdelay = 200;

	reglen = sizeof(config[0].baud);
	RegQueryValueEx(hKey,"Baud0",NULL,NULL,(void*)&config[0].baud,&reglen);
	reglen = sizeof(config[0].mode);
	RegQueryValueEx(hKey,"Mode0",NULL,NULL,(void*)&config[0].mode,&reglen);
	reglen = sizeof(config[0].txdelay);
	RegQueryValueEx(hKey,"TxDelay0",NULL,NULL,(void*)&config[0].txdelay,&reglen);

	config[1].baud = 1200;
	config[1].mode = 0;
	config[1].txdelay = 200;

	reglen = sizeof(config[1].baud);
	RegQueryValueEx(hKey,"Baud1",NULL,NULL,(void*)&config[1].baud,&reglen);
	reglen = sizeof(config[1].mode);
	RegQueryValueEx(hKey,"Mode1",NULL,NULL,(void*)&config[1].mode,&reglen);
	reglen = sizeof(config[1].txdelay);
	RegQueryValueEx(hKey,"TxDelay1",NULL,NULL,(void*)&config[1].txdelay,&reglen);

	config[2].baud = 1200;
	config[2].mode = 0;
	config[2].txdelay = 200;

	reglen = sizeof(config[2].baud);
	RegQueryValueEx(hKey,"Baud2",NULL,NULL,(void*)&config[2].baud,&reglen);
	reglen = sizeof(config[2].mode);
	RegQueryValueEx(hKey,"Mode2",NULL,NULL,(void*)&config[2].mode,&reglen);
	reglen = sizeof(config[2].txdelay);
	RegQueryValueEx(hKey,"TxDelay2",NULL,NULL,(void*)&config[2].txdelay,&reglen);

	config[3].baud = 1200;
	config[3].mode = 0;
	config[3].txdelay = 200;

	reglen = sizeof(config[3].baud);
	RegQueryValueEx(hKey,"Baud3",NULL,NULL,(void*)&config[3].baud,&reglen);
	reglen = sizeof(config[3].mode);
	RegQueryValueEx(hKey,"Mode3",NULL,NULL,(void*)&config[3].mode,&reglen);
	reglen = sizeof(config[3].txdelay);
	RegQueryValueEx(hKey,"TxDelay3",NULL,NULL,(void*)&config[3].txdelay,&reglen);
}

void write_config(HKEY hKey)
{
	RegSetValueEx(hKey,"Baud0",0,REG_DWORD,(void*)&config[0].baud,sizeof(config[0].baud));
	RegSetValueEx(hKey,"Mode0",0,REG_DWORD,(void*)&config[0].mode,sizeof(config[0].mode));
	RegSetValueEx(hKey,"TxDelay0",0,REG_DWORD,(void*)&config[0].txdelay,sizeof(config[0].txdelay));

	RegSetValueEx(hKey,"Baud1",0,REG_DWORD,(void*)&config[1].baud,sizeof(config[1].baud));
	RegSetValueEx(hKey,"Mode1",0,REG_DWORD,(void*)&config[1].mode,sizeof(config[1].mode));
	RegSetValueEx(hKey,"TxDelay1",0,REG_DWORD,(void*)&config[1].txdelay,sizeof(config[1].txdelay));

	RegSetValueEx(hKey,"Baud2",0,REG_DWORD,(void*)&config[2].baud,sizeof(config[2].baud));
	RegSetValueEx(hKey,"Mode2",0,REG_DWORD,(void*)&config[2].mode,sizeof(config[2].mode));
	RegSetValueEx(hKey,"TxDelay2",0,REG_DWORD,(void*)&config[2].txdelay,sizeof(config[2].txdelay));

	RegSetValueEx(hKey,"Baud3",0,REG_DWORD,(void*)&config[3].baud,sizeof(config[3].baud));
	RegSetValueEx(hKey,"Mode3",0,REG_DWORD,(void*)&config[3].mode,sizeof(config[3].mode));
	RegSetValueEx(hKey,"TxDelay3",0,REG_DWORD,(void*)&config[3].txdelay,sizeof(config[3].txdelay));
}

int init_device(HKEY hKey)
{
	long result;

	if (system_isnt4())
	{
		char DriverPath[256];
		if (!flex_home(DriverPath,200))
			return 0;
		strcat(DriverPath,DriverName);
		create_service(ServiceName,DriverPath);
	}
	state.restart = 0;
	state.hndCtrl = CreateFile(	DeviceName,GENERIC_READ | GENERIC_WRITE,
								0,NULL,OPEN_EXISTING,0,NULL);
	if (state.hndCtrl == INVALID_HANDLE_VALUE)
		return 0;
	state.hndRead = CreateFile(	DeviceName,GENERIC_READ | GENERIC_WRITE,
								0,NULL,OPEN_EXISTING,0,NULL);
	if (state.hndRead == INVALID_HANDLE_VALUE)
		return 0;
	DeviceIoControl(state.hndCtrl,PCISCC_BLOCK_READ,NULL,0,NULL,0,&result,NULL);

	read_config(hKey);
	return 1;
}

void l1_exit(HKEY hKey)
{
	long result;

	DeviceIoControl(state.hndCtrl,PCISCC_NONBLOCK_READ,NULL,0,NULL,0,&result,NULL);
	CloseHandle(state.hndCtrl);
	CloseHandle(state.hndRead);
	state.hndCtrl = INVALID_HANDLE_VALUE;
	state.hndRead = INVALID_HANDLE_VALUE;

	write_config(hKey);

	if (state.restart)
		return;
	if (system_isnt4())
		remove_service(ServiceName);
}

int config_device(byte max_channels, HWND hDlg, byte channel)
{
	if (state.restart = DialogBoxParam(state.hInst,MAKEINTRESOURCE(IDD_DIALOG1),hDlg,EdParmDlgProc,0))
		return 4;
	return 0;
}

byte *config_info(byte chan)
{
	static char buf[32];

	sprintf(buf,"Channel %d",chan);
	return buf;
}

byte l1_init_kanal(byte chan, u16 baud, u16 mode)
{
	long arg[2];
	long bytes = 0;
	long cmd;

	arg[0] = config[chan].baud = baud * 100;
	arg[1] = config[chan].mode = mode;

	if (config[chan].baud)
		config[chan].scale = 614400 / config[chan].baud;

	switch (chan)
	{
		case 0: cmd = PCISCC_SET_PARAM_0;
				break;
		case 1: cmd = PCISCC_SET_PARAM_1;
				break;
		case 2: cmd = PCISCC_SET_PARAM_2;
				break;
		case 3: cmd = PCISCC_SET_PARAM_3;
				break;
	}
	DeviceIoControl(state.hndCtrl,cmd,&arg,sizeof(arg),
					NULL,0,&bytes,NULL);
	if (!bytes)
		return 0;
	return 1;
}

byte l1_ch_state(byte chan)
{
	long arg = 0xff;
	long bytes;
	long cmd;

	switch (chan)
	{
		case 0: cmd = PCISCC_GET_STATE_0;
				break;
		case 1: cmd = PCISCC_GET_STATE_1;
				break;
		case 2: cmd = PCISCC_GET_STATE_2;
				break;
		case 3: cmd = PCISCC_GET_STATE_3;
				break;
	}
	DeviceIoControl(state.hndCtrl,cmd,NULL,0,&arg,sizeof(arg),
					&bytes,NULL);
	return (byte)arg;
}

void l1_tx_calib(byte chan, byte min)
{
	long arg = min;
	long bytes;
	long cmd;

	switch (chan)
	{
		case 0: cmd = PCISCC_SET_CALIB_0;
				break;
		case 1: cmd = PCISCC_SET_CALIB_1;
				break;
		case 2: cmd = PCISCC_SET_CALIB_2;
				break;
		case 3: cmd = PCISCC_SET_CALIB_3;
				break;
	}
	DeviceIoControl(state.hndCtrl,cmd,&arg,sizeof(arg),NULL,0,
					&bytes,NULL);
}

L1_STATISTICS *l1_stat(byte chan, byte del)
{
	static L1_STATISTICS info;
	long bytes;
	long cmd;

	switch (chan)
	{
		case 0: cmd = PCISCC_GET_INFO_0;
				break;
		case 1: cmd = PCISCC_GET_INFO_1;
				break;
		case 2: cmd = PCISCC_GET_INFO_2;
				break;
		case 3: cmd = PCISCC_GET_INFO_3;
				break;
	}
	memset(&info,0,sizeof(L1_STATISTICS));
	DeviceIoControl(state.hndCtrl,cmd,NULL,0,&info,sizeof(L1_STATISTICS),
					&bytes,NULL);
	return &info;
}

L1FRAME *l1_rx_frame()
{
	long bytes = 0;

	while (1) {
		if (state.hndRead == INVALID_HANDLE_VALUE)
			return NULL;
		if (!ReadFile(state.hndRead,&state.rx_frame,sizeof(state.rx_frame),&bytes,NULL))
			return NULL;
		if (bytes)
			break;
	}
	state.rx_frame.kanal += state.base_chan;
	return &state.rx_frame;
}

byte l1_tx_frame(void)
{
	long bytes = 0;

	state.tx_frame.kanal = state.tx_chan;
	state.tx_frame.txdelay = config[state.tx_chan].txdelay / 10;

	WriteFile(state.hndCtrl,&state.tx_frame,sizeof(state.tx_frame),&bytes,NULL);
	if (!bytes)
		return 0;
	return 1;
}

L1FRAME *l1_get_framebuf(byte chan)
{
	state.tx_chan = chan;
	return &state.tx_frame;
}

char *l1_ident(byte chan)
{
	return ServiceName;
}

char *far l1_version(byte chan)
{
	return DriverVer;
}

u16 l1_get_ch_cnt(void)
{
	return 4;
}

byte l1_ch_active(byte chan)
{
	return 1;
}