![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to hopf_PCI_io.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ports / winnt / ntpd|
Return to hopf_PCI_io.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ports / winnt / ntpd |
1.1 misho 1: /*
2: * hopf_PCI_io.c
3: * Read data from a hopf PCI clock using the ATLSoft WinNT driver.
4: *
5: * Date: 21.03.2000 Revision: 01.10
6: *
7: * Copyright (C) 1999, 2000 by Bernd Altmeier altmeier@ATLSoft.de
8: *
9: */
10:
11: /*
12: * Ignore nonstandard extension warning.
13: * This happens when including winioctl.h
14: */
15: #pragma warning(disable: 4201)
16: #define _FILESYSTEMFSCTL_
17:
18: #include <config.h>
19: #include <windows.h>
20: #include <stdio.h>
21: #include <stdlib.h>
22: #include <stddef.h>
23: #include <winioctl.h>
24: #include "hopf_PCI_io.h"
25:
26:
27: #define ATL_PASSTHROUGH_READ_TOSIZE (3 * sizeof(ULONG))
28: #define ATL_PASSTHROUGH_READ_FROMSIZE 0
29: #define IOCTL_ATLSOFT_PASSTHROUGH_READ CTL_CODE( \
30: FILE_DEVICE_UNKNOWN, \
31: 0x805, \
32: METHOD_BUFFERED, \
33: FILE_ANY_ACCESS)
34:
35:
36: HANDLE hDevice = NULL; // this is the handle to the PCI Device
37:
38: HANDLE hRdEvent;
39: OVERLAPPED Rdoverlapped;
40: OVERLAPPED * pRdOverlapped;
41:
42: ULONG iobuffer[256];
43: DWORD cbReturned;
44: BOOL HaveBoard = FALSE;
45:
46: struct {
47: ULONG region;
48: ULONG offset;
49: ULONG count;
50: } io_params;
51:
52:
53: BOOL
54: OpenHopfDevice(void)
55: {
56: OSVERSIONINFO VersionInfo;
57: ULONG deviceNumber;
58: CHAR deviceName[255];
59:
60: VersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
61: GetVersionEx(&VersionInfo);
62: switch (VersionInfo.dwPlatformId) {
63:
64: case VER_PLATFORM_WIN32_WINDOWS: // Win95/98
65: return FALSE; // "NTP does not support Win 95-98."
66: break;
67:
68: case VER_PLATFORM_WIN32_NT: // WinNT
69: deviceNumber = 0;
70: snprintf(deviceName, sizeof(deviceName),
71: "\\\\.\\hclk6039%d", deviceNumber + 1);
72: hDevice = CreateFile(
73: deviceName,
74: GENERIC_WRITE | GENERIC_READ,
75: FILE_SHARE_WRITE | FILE_SHARE_READ,
76: NULL,
77: OPEN_EXISTING,
78: FILE_FLAG_DELETE_ON_CLOSE | FILE_FLAG_OVERLAPPED,
79: NULL);
80: break;
81:
82: default:
83: hDevice = INVALID_HANDLE_VALUE;
84: break;
85: } // end switch
86:
87: if (INVALID_HANDLE_VALUE == hDevice) // the system didn't return a handle
88: return FALSE; //"A handle to the driver could not be obtained properly"
89:
90: // an event to be used for async transfers
91: hRdEvent = CreateEvent(
92: NULL,
93: TRUE,
94: FALSE,
95: NULL);
96:
97: if (INVALID_HANDLE_VALUE == hRdEvent)
98: return FALSE; // the system didn't return a handle
99:
100: pRdOverlapped = &Rdoverlapped;
101: pRdOverlapped->hEvent = hRdEvent;
102:
103: HaveBoard = TRUE; // board installed and we have access
104:
105: return TRUE;
106: } // end of OpenHopfDevice()
107:
108:
109: BOOL
110: CloseHopfDevice(void)
111: {
112: CloseHandle(hRdEvent);// When done, close the handle to the driver
113:
114: return CloseHandle(hDevice);
115: } // end of CloseHopfDevice()
116:
117:
118: void
119: ReadHopfDevice(void)
120: {
121: if (!HaveBoard)
122: return;
123:
124: DeviceIoControl(
125: hDevice,
126: IOCTL_ATLSOFT_PASSTHROUGH_READ,
127: &io_params,
128: ATL_PASSTHROUGH_READ_TOSIZE,
129: iobuffer,
130: ATL_PASSTHROUGH_READ_FROMSIZE
131: + io_params.count * sizeof(ULONG),
132: &cbReturned,
133: pRdOverlapped
134: );
135: }
136:
137:
138: void
139: GetHardwareData(
140: LPDWORD Data32,
141: WORD Ofs
142: )
143: {
144: io_params.region = 1;
145: io_params.offset = Ofs;
146: io_params.count = 1;
147: ReadHopfDevice();
148: *Data32 = iobuffer[0];
149: }
150:
151:
152: void
153: GetHopfTime(
154: LPHOPFTIME Data,
155: DWORD Offset
156: )
157: {
158: io_params.region = 1;
159: io_params.offset = Offset;
160: io_params.count = 4;
161:
162: ReadHopfDevice();
163:
164: Data->wHour = 0;
165: Data->wMinute = 0;
166: Data->wSecond = 0;
167: while (iobuffer[0] >= 60 * 60 * 1000) {
168: iobuffer[0] = iobuffer[0] - 60 * 60 * 1000;
169: Data->wHour++;
170: }
171: while (iobuffer[0] >= 60 * 1000) {
172: iobuffer[0] = iobuffer[0] - 60 * 1000;
173: Data->wMinute++;
174: }
175: while (iobuffer[0] >= 1000) {
176: iobuffer[0] = iobuffer[0] - 1000;
177: Data->wSecond++;
178: }
179: Data->wMilliseconds = LOWORD(iobuffer[0]);
180: Data->wDay = HIBYTE(HIWORD(iobuffer[1]));
181: Data->wMonth = LOBYTE(HIWORD(iobuffer[1]));
182: Data->wYear = LOWORD(iobuffer[1]);
183: Data->wDayOfWeek = HIBYTE(HIWORD(iobuffer[2]));
184: if (Data->wDayOfWeek == 7) // Dow Korrektur
185: Data->wDayOfWeek = 0;
186:
187: io_params.region = 1;
188: io_params.offset += 0x08;
189: io_params.count = 1;
190:
191: ReadHopfDevice();
192:
193: Data->wStatus = LOBYTE(HIWORD(iobuffer[0]));
194: }
195:
196:
197: void
198: GetHopfLocalTime(
199: LPHOPFTIME Data
200: )
201: {
202: DWORD Offset = 0;
203:
204: GetHopfTime(Data, Offset);
205: }
206:
207:
208: void
209: GetHopfSystemTime(
210: LPHOPFTIME Data
211: )
212: {
213: DWORD Offset = 0x10;
214:
215: GetHopfTime(Data,Offset);
216: }
217:
218:
219: void
220: GetSatData(
221: LPSATSTAT Data
222: )
223: {
224: io_params.region = 1;
225: io_params.offset = 0xb0;
226: io_params.count = 5;
227:
228: ReadHopfDevice();
229:
230: Data->wVisible = HIBYTE(HIWORD(iobuffer[0]));
231: Data->wMode = LOBYTE(LOWORD(iobuffer[0]));
232: Data->wSat0 = HIBYTE(HIWORD(iobuffer[1]));
233: Data->wRat0 = LOBYTE(HIWORD(iobuffer[1]));
234: Data->wSat1 = HIBYTE(LOWORD(iobuffer[1]));
235: Data->wRat1 = LOBYTE(LOWORD(iobuffer[1]));
236: Data->wSat2 = HIBYTE(HIWORD(iobuffer[2]));
237: Data->wRat2 = LOBYTE(HIWORD(iobuffer[2]));
238: Data->wSat3 = HIBYTE(LOWORD(iobuffer[2]));
239: Data->wRat3 = LOBYTE(LOWORD(iobuffer[2]));
240: Data->wSat4 = HIBYTE(HIWORD(iobuffer[3]));
241: Data->wRat4 = LOBYTE(HIWORD(iobuffer[3]));
242: Data->wSat5 = HIBYTE(LOWORD(iobuffer[3]));
243: Data->wRat5 = LOBYTE(LOWORD(iobuffer[3]));
244: Data->wSat6 = HIBYTE(HIWORD(iobuffer[4]));
245: Data->wRat6 = LOBYTE(HIWORD(iobuffer[4]));
246: Data->wSat7 = HIBYTE(LOWORD(iobuffer[4]));
247: Data->wRat7 = LOBYTE(LOWORD(iobuffer[4]));
248: }
249:
250:
251: void
252: GetDiffTime(
253: LPLONG Data
254: )
255: {
256: io_params.region = 1;
257: io_params.offset = 0x0c;
258: io_params.count = 1;
259:
260: ReadHopfDevice();
261:
262: *Data = iobuffer[0];
263: }
264:
265:
266: void
267: GetPosition(
268: LPGPSPOS Data
269: )
270: {
271: io_params.region = 1;
272: io_params.offset = 0x90; // Positionsdaten Länge
273: io_params.count = 1;
274:
275: ReadHopfDevice();
276:
277: Data->wLongitude = iobuffer[0]; //in Millisekunden
278: io_params.region = 1;
279: io_params.offset = 0xa0; // Positionsdaten Breite
280: io_params.count = 1;
281:
282: ReadHopfDevice();
283:
284: Data->wLatitude = iobuffer[0];
285: Data->wAltitude = 0;
286: }
287:
288:
289: void
290: GetHardwareVersion(
291: LPCLOCKVER Data
292: )
293: {
294: int i;
295:
296: io_params.region = 1;
297: io_params.offset = 0x50;
298: io_params.count = 12;
299:
300: ReadHopfDevice();
301:
302: Data->cVersion[0] = '\0';
303: iobuffer[13] = 0;
304: for (i = 0; i < 13; i++) {
305: Data->cVersion[i * 4 ] = HIBYTE(HIWORD(iobuffer[i]));
306: Data->cVersion[i * 4 + 1] = LOBYTE(HIWORD(iobuffer[i]));
307: Data->cVersion[i * 4 + 2] = HIBYTE(LOWORD(iobuffer[i]));
308: Data->cVersion[i * 4 + 3] = LOBYTE(LOWORD(iobuffer[i]));
309: }
310: }
311:
312:
313: void
314: GetDCFAntenne(
315: LPDCFANTENNE Data
316: )
317: {
318: io_params.region = 1;
319: io_params.offset = 0xcc;
320: io_params.count = 1;
321:
322: ReadHopfDevice();
323: Data->bStatus1 = HIBYTE(HIWORD(iobuffer[0]));
324: Data->bStatus = LOBYTE(HIWORD(iobuffer[0]));
325: Data->wAntValue = LOWORD(iobuffer[0]);
326: }
327: