← Back to branch summary

~ubuntu-branches/debian/squeeze/ntp/squeeze

« back to all changes in this revision

Viewing changes to ports/winnt/ntpd/hopf_PCI_io.c

  • Committer: Bazaar Package Importer
  • Author(s): Kurt Roeckx
  • Date: 2010-05-24 11:09:51 UTC
  • mfrom: (1.2.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20100524110951-1o7gh469ygochf4n
Tags: 1:4.2.6.p1+dfsg-1
http://bugs.debian.org/569530
* New upstream version
  - They no longer ship arlib, adjust dfsg.patch.
  - Drop kfreebsd.patch, applied upstream
  - Update patches for upstream changes.
* Remove the obsolete config files:

  for ntp:
  - /etc/logcheck/ignore.d.server/ntp, removed in 1:4.2.6+dfsg-1
  - /etc/dhcp3/dhclient-enter-hooks.d/ntp, replaced by exit hooks in
    1:4.2.4p4+dfsg-3
  - /etc/network/if-up.d/ntp, removed in 1:4.2.4p0+dfsg-1

  for ntpdate:
  - /etc/dhcp3/dhclient-enter-hooks.d/ntpdate, replaced by exit hooks in
    1:4.2.4p4+dfsg-3

  Use dpkg 1.15.7.2's dpkg-maintscript-helper.  This needs
  a Pre-Depends to work, else it's never going to be removed.
  (Closes: #569530)
* Add "Depends: ${misc:Depends}" to ntp-doc.

Show diffs side-by-side

added added

removed removed

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