File: INCLUDE\HARDWARE\HWIO.H
1 /*
2 File : hwio.h
3 Project : XCTL
4 Author : Jan Picard <picard@informatik.hu-berlin.de> 2001-2002
5 Institut fuer Informatik,
6 Humboldt-Universitaet Berlin
7 Content : another level of indirection:
8 providing port I/O depending on Windows version
9 - for win16 direct inp/outp calls are allowed
10 - for win32 we use xport, a free generic kernel mode driver
11 downloadable from www.simtel.net, search for "xport"
12 */
13
14 #ifndef __HWIO_H
15 #define __HWIO_H
16
17 #if _MSC_VER > 1000
18 #pragma once
19 #endif // _MSC_VER > 1000
20
21 #define WIN32_LEAN_AND_MEAN // Do not include parts of windows headers that
22 // that are used only rarely
23
24 #include <windows.h>
25 #include <setupapi.h>
26 #include <TCHAR.h>
27 #include <winioctl.h>
28
29 #if defined (Build_Hardware)
31 #elif defined(Use_Hardware)
33 #else
34 #define _HWIOCLASS
35 #endif
36
37 #ifdef __cplusplus
38 extern "C"
39 {
40 #endif
41 LPCSTR _HWIOCLASS WINAPI hwGetVersion( void );
42 HINSTANCE _HWIOCLASS WINAPI hwGetInstance( void );
43 #ifdef __cplusplus
44 }
45 #endif
46
47 /////////////////////////////////////////////////////////////////
48 // Treiber IOCTLs
49 #define XCTL_TYPE FILE_DEVICE_UNKNOWN
50 #define IOCTL_MC_REPORT_ID CTL_CODE(XCTL_TYPE,0x900,METHOD_BUFFERED,FILE_READ_ACCESS)
51
52 #define IOCTL_MC_READ_BYTE CTL_CODE(XCTL_TYPE,0x901,METHOD_BUFFERED,FILE_READ_ACCESS)
53 #define IOCTL_MC_READ_WORD CTL_CODE(XCTL_TYPE,0x902,METHOD_BUFFERED,FILE_READ_ACCESS)
54 #define IOCTL_MC_READ_DWORD CTL_CODE(XCTL_TYPE,0x903,METHOD_BUFFERED,FILE_READ_ACCESS)
55
56 #define IOCTL_MC_WRITE_BYTE CTL_CODE(XCTL_TYPE,0x904,METHOD_BUFFERED,FILE_WRITE_ACCESS)
57 #define IOCTL_MC_WRITE_WORD CTL_CODE(XCTL_TYPE,0x905,METHOD_BUFFERED,FILE_WRITE_ACCESS)
58 #define IOCTL_MC_WRITE_DWORD CTL_CODE(XCTL_TYPE,0x906,METHOD_BUFFERED,FILE_WRITE_ACCESS)
59
60 // zusätzliche IOCTLs für BraunPSD
61 #define IOCTL_DC_SET_WFR_CYCLES CTL_CODE( XCTL_TYPE, 0x907, METHOD_BUFFERED, FILE_WRITE_ACCESS)
62 // Set Wait For Ready Cycles --> ersetzt ASA.DLL SetTimeOut()
63 // ein ULONG im Systembuffer übergeben mit Zyklenanzahl
64
65 #define IOCTL_DC_GET_DATA CTL_CODE( XCTL_TYPE, 0x908, METHOD_BUFFERED, FILE_WRITE_ACCESS)
66 // Get Data --> ersetzt ASA.DLL GetData()
67 // Puffer gefüllt mit Struktur IrpParamsGetData übergeben
68
69 /////////////////////////////////////////////////////////////////
70 // Identifier der Detektoren und Motoren
71 enum EDeviceType {C812= 1, C832, RADICON, BRAUN, GENERIC, STOE};
72
73
74 /////////////////////////////////////////////////////////////////
75 // Datentypen
76 struct WriteBuffer
77 {
78 DWORD Offset;
79 union
80 {
81 BYTE bData;
82 WORD wData;
83 DWORD dwData;
84 };
85 };
86
87 //Datenstrukturen für den BraunPSD
88 struct IrpParams
89 {
90 ULONG Port;
91 ULONG Value;
92 };
93
94 struct IrpParamsGetData
95 {
96 PUCHAR pBuffer; //Zeiger auf Puffer in den die Daten eingelesen werden sollen
97 ULONG MaxCount; //Anzahl der Einzulesenden Wörter -> größe von Buffer in WORD
98 //WORD ymax;
99 };
100
101 /////////////////////////////////////////////////////////////////
102 // allgemeine Hardwareverwaltungsfunktionen
103
104 //gibt Fehlermeldung aus
105 _HWIOCLASS void PrintError(DWORD dwError= 0);
106
107 //liefert die Anzahl der Devices zu einem DevivceInterface
108 _HWIOCLASS DWORD EnumDevices(const GUID& guid);
109
110 //liefert den DeviceName des Devices am angegebenen Index der DeviceListe des DeviceInterfaces
111 //dieser Name kann dann für CreateFile() genutzt werden
112 _HWIOCLASS bool GetDeviceDriver(const GUID& guid, DWORD devIndex, LPTSTR* pDriverName);
113
114 class _HWIOCLASS DeviceListEntry
115 {
116 private:
117 EDeviceType DeviceID; //GUID des Treibers
118 char HardwareID[9]; //IO-Adresse der Hardware (hex ohne führendes '0x')
119 char FileName[257]; //friendly name des Treibers
120
121 DeviceListEntry* prev;
122 DeviceListEntry* next;
123
124 public:
125 DeviceListEntry(EDeviceType DeviceID, LPTSTR HardwareID, LPTSTR FileName);
126 void SetPrevEntry(DeviceListEntry* pEntry);
127 void SetNextEntry(DeviceListEntry* pEntry);
128 DeviceListEntry* GetPrevEntry();
129 DeviceListEntry* GetNextEntry();
130 int GetDeviceID();
131 LPTSTR GetHardwareID();
132 LPTSTR GetFileName();
133 };
134
135 class _HWIOCLASS DeviceList
136 {
137 private:
138 DeviceListEntry* first;
139 DeviceListEntry* last;
140
141 public:
142 DeviceList();
143 virtual ~DeviceList();
144
145 void Add(EDeviceType DeviceID, LPTSTR HardwareID, LPTSTR FileName);
146 void Add(DeviceListEntry* pEntry);
147 void Clear();
148 LPTSTR GetFileName(int DeviceID, LPTSTR HardwareID);
149 };
150
151 //Erstellt eine Tabelle aus DeviceID und zugehörigem Treibernamen
152 _HWIOCLASS bool RegisterDrivers(DeviceList* Drivers, const GUID& guid, EDeviceType DeviceID);
153
154 //kapselt den Zugriff auf die Hardware (über Treiber)
155 class _HWIOCLASS HardwareIo
156 {
157 protected:
158 char szDeviceName[257];
159 HANDLE hDevice;
160
161 public:
162 HardwareIo();
163 HardwareIo(char* szDeviceName);
164 virtual ~HardwareIo();
165
166 virtual BOOL Read(DWORD Offset, BYTE* Data);
167 virtual BOOL Read(DWORD Offset, WORD* Data);
168 virtual BOOL Read(DWORD Offset, DWORD* Data);
169
170 virtual BOOL Write(DWORD Offset, BYTE Data);
171 virtual BOOL Write(DWORD Offset, WORD Data);
172 virtual BOOL Write(DWORD Offset, DWORD Data);
173 };
174
175 //fängt den Zugriff auf die Hardware ab (wenn kein Treiber vorhanden)
176 class _HWIOCLASS DummyIo : public HardwareIo
177 {
178
179 public:
180 //DummyIo();
181 DummyIo(int DeviceID, LPTSTR HardwareID, bool DoMessage= true);
182 //virtual ~DummyIo(){}
183
184 virtual BOOL Read(DWORD Offset, BYTE* Data)
185 {
186 *Data= 0xFF;
187 return (TRUE);
188 }
189 virtual BOOL Read(DWORD Offset, WORD* Data)
190 {
191 *Data= 0xFFFF;
192 return (TRUE);
193 }
194 virtual BOOL Read(DWORD Offset, DWORD* Data)
195 {
196 *Data= 0xFFFFFFFF;
197 return (TRUE);
198 }
199
200 virtual BOOL Write(DWORD Offset, BYTE Data)
201 {
202 return (TRUE);
203 }
204 virtual BOOL Write(DWORD Offset, WORD Data)
205 {
206 return (TRUE);
207 }
208 virtual BOOL Write(DWORD Offset, DWORD Data)
209 {
210 return (TRUE);
211 }
212
213 };
214
215 //spezielle Treiberzugriffe für BraunPSD
216 class _HWIOCLASS BraunPsdIo : public HardwareIo
217 {
218
219 public:
220 BraunPsdIo();
221 BraunPsdIo(char* id);
222 virtual ~BraunPsdIo();
223
224 virtual BOOL Read(DWORD Offset, BYTE* Data);
225 virtual BOOL Read(DWORD Offset, WORD* Data)
226 {
227 return (FALSE);
228 } //von BraunPSD nicht unterstützt
229 virtual BOOL Read(DWORD Offset, DWORD* Data)
230 {
231 return (FALSE);
232 } //von BraunPSD nicht unterstützt
233
234 virtual BOOL Write(DWORD Offset, BYTE Data);
235 virtual BOOL Write(DWORD Offset, WORD Data)
236 {
237 return (FALSE);
238 } //von BraunPSD nicht unterstützt
239 virtual BOOL Write(DWORD Offset, DWORD Data)
240 {
241 return (FALSE);
242 } //von BraunPSD nicht unterstützt
243
244 virtual BOOL SetTimeout(unsigned long Cycles);
245 virtual BOOL GetData(IrpParamsGetData *Params); // 31.06.2004 MEMCORRECT (IrpParamsGetData *Params)
246 };
247
248 //fängt den Zugriff auf die BraunPsd-Hardware ab (wenn kein Treiber vorhanden)
249 class _HWIOCLASS BraunPsdDummyIo : public BraunPsdIo
250 {
251
252 public:
253 BraunPsdDummyIo();
254 BraunPsdDummyIo(char* id);
255 virtual ~BraunPsdDummyIo()
256 {}
257
258 virtual BOOL Read(DWORD Offset, BYTE* Data)
259 {
260 return (FALSE);
261 }
262 virtual BOOL Read(DWORD Offset, WORD* Data)
263 {
264 return (FALSE);
265 }
266 virtual BOOL Read(DWORD Offset, DWORD* Data)
267 {
268 return (FALSE);
269 }
270
271 virtual BOOL Write(DWORD Offset, BYTE Data)
272 {
273 return (FALSE);
274 }
275 virtual BOOL Write(DWORD Offset, WORD Data)
276 {
277 return (FALSE);
278 }
279 virtual BOOL Write(DWORD Offset, DWORD Data)
280 {
281 return (FALSE);
282 }
283
284 virtual BOOL SetTimeout(unsigned long Cycles)
285 {
286 return (FALSE);
287 }
288
289 virtual BOOL GetData(IrpParamsGetData *Params) // 31.06.2004 MEMCORRECT (IrpParamsGetData *Params)
290 {
291 return (FALSE);
292 }
293 };
294
295 //Controller-Interface
296 class _HWIOCLASS Controller
297 {
298 protected:
299 HardwareIo* Hardware; //Hardwarezugriffe
300 const EDeviceType DeviceID; //GUID des zugehörigen Treibers
301 char HardwareID[9]; //IO-Adresse des Controllers
302 unsigned Clients; //Anzahl der durch den Controller verwalteten Geräte
303 const unsigned MaxClients; //Anzahl der max. zu verwaltenden Geräte
304
305 public:
306 Controller(EDeviceType DeviceID, LPTSTR HardwareID, unsigned MaxClients);
307 virtual ~Controller(){};
308
309 int GetDeviceID();
310 LPTSTR GetHardwareID();
311 BOOL AddClient();
312
313 virtual BOOL Read(DWORD Offset, BYTE* Data);
314 virtual BOOL Read(DWORD Offset, WORD* Data);
315 virtual BOOL Read(DWORD Offset, DWORD* Data);
316
317 virtual BOOL Write(DWORD Offset, BYTE Data);
318 virtual BOOL Write(DWORD Offset, WORD Data);
319 virtual BOOL Write(DWORD Offset, DWORD Data);
320
321 //-> Controller ist abstract
322 virtual BOOL Check()= 0; //Test, ob Hardware angeschlossen
323 };
324
325 //kapselt das HardwareIo-Objekt für Geräte, die an einen Controller angeschlossen sind
326 //dies ist lediglich ein Basiscontroller
327 //- speziellere Controller (z.B. für TC_832) können von diesem ageleitet werden
328 class _HWIOCLASS StandardController : public Controller
329 {
330 public:
331 StandardController(EDeviceType DeviceID, LPTSTR HardwareID, LPTSTR szDeviceName);
332 StandardController(EDeviceType DeviceID, LPTSTR HardwareID, DeviceList* Devices);
333 virtual ~StandardController();
334
335 virtual BOOL Check();
336 };
337
338 class _HWIOCLASS ControllerListEntry
339 {
340 private:
341 Controller* asController; //assigned Controller
342
343 ControllerListEntry* prev;
344 ControllerListEntry* next;
345
346 public:
347 ControllerListEntry(Controller* asController);
348 virtual ~ControllerListEntry();
349
350 void SetPrevEntry(ControllerListEntry* pEntry);
351 void SetNextEntry(ControllerListEntry* pEntry);
352 ControllerListEntry* GetPrevEntry();
353 ControllerListEntry* GetNextEntry();
354 int GetDeviceID();
355 LPTSTR GetHardwareID();
356 Controller* GetController();
357 };
358
359 class _HWIOCLASS ControllerList
360 {
361 private:
362 ControllerListEntry* first;
363 ControllerListEntry* last;
364
365 public:
366 ControllerList();
367 virtual ~ControllerList();
368
369 void Add(Controller* asController);
370 void Add(ControllerListEntry* pEntry);
371 void Clear();
372 Controller* GetController(int DeviceID, LPTSTR HardwareID);
373 Controller* GetController(unsigned index);
374 DWORD GetControllerIndex(int DeviceID, LPTSTR HardwareID);
375 };
376
377 //legt eine Liste aller in der Hardware.ini eingetragenen Controller an
378 //(ControllerClass= {Motor, Device})
379 _HWIOCLASS bool RegisterControllers(ControllerList* Controllers, LPTSTR pControllerClass);
380
381
382 #endif // #ifndef __HWIO_H
383
384
385