Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / kernel / msm / 39a37ce1cc5eef420604fa68b776ff5dab400340 / . / drivers / staging / wlags49_h2 / hcfcfg.h
blob: 83475b1060a18c5652f057510545ed39da629878 [file] [log] [blame]
Henk de Groot68c0bdf2009-09-27 11:12:52 +0200[diff] [blame]1
2// vim:tw=110:ts=4:
3#ifndef HCFCFG_H
4#define HCFCFG_H 1
5
6/*************************************************************************************************************
7*
8* FILE : hcfcfg.tpl // hcfcfg.h
9*
10* DATE : $Date: 2004/08/05 11:47:10 $ $Revision: 1.6 $
11* Original: 2004/04/08 15:18:16 Revision: 1.40 Tag: t20040408_01
12* Original: 2004/04/01 15:32:55 Revision: 1.38 Tag: t7_20040401_01
13* Original: 2004/03/10 15:39:28 Revision: 1.34 Tag: t20040310_01
14* Original: 2004/03/03 14:10:12 Revision: 1.32 Tag: t20040304_01
15* Original: 2004/03/02 09:27:12 Revision: 1.30 Tag: t20040302_03
16* Original: 2004/02/24 13:00:28 Revision: 1.25 Tag: t20040224_01
17* Original: 2004/02/18 17:13:57 Revision: 1.23 Tag: t20040219_01
18*
19* AUTHOR : Nico Valster
20*
21* DESC : HCF Customization Macros
22* hcfcfg.tpl list all #defines which must be specified to:
23* adjust the HCF functions defined in HCF.C to the characteristics of a specific environment
24* o maximum sizes for messages
25* o Endianess
26* Compiler specific macros
27* o port I/O macros
28* o type definitions
29*
30* By copying HCFCFG.TPL to HCFCFG.H and -if needed- modifying the #defines the WCI functionality can be
31* tailored
32*
33* Supported environments:
34* WVLAN_41 Miniport NDIS 3.1
35* WVLAN_42 Packet Microsoft Visual C 1.5
36* WVLAN_43 16 bits DOS ODI Microsoft Visual C 1.5
37* WVLAN_44 32 bits ODI (__NETWARE_386__) WATCOM
38* WVLAN_45 MAC_OS MPW?, Symantec?
39* WVLAN_46 Windows CE (_WIN32_WCE) Microsoft ?
40* WVLAN_47 LINUX (__LINUX__) GCC, discarded, based on GPL'ed HCF-light
41* WVLAN_48 Miniport NDIS 5
42* WVLAN_49 LINUX (__LINUX__) GCC, originally based on pre-compiled HCF_library
43* migrated to use the HCF sources when Lucent Technologies
44* brought the HCF module under GPL
45* WVLAN_51 Miniport USB NDIS 5
46* WVLAN_52 Miniport NDIS 4
47* WVLAN_53 VxWorks END Station driver
48* WVLAN_54 VxWorks END Access Point driver
49* WVLAN_81 WavePoint BORLAND C
50* WCITST Inhouse test tool Microsoft Visual C 1.5
51* WSU WaveLAN Station Update Microsoft Visual C ??
52* SCO UNIX not yet actually used ? ?
53* __ppc OEM supplied ?
54* _AM29K OEM supplied ?
55* ? OEM supplied Microtec Research 80X86 Compiler
56*
57**************************************************************************************************************
58*
59*
60* SOFTWARE LICENSE
61*
62* This software is provided subject to the following terms and conditions,
63* which you should read carefully before using the software. Using this
64* software indicates your acceptance of these terms and conditions. If you do
65* not agree with these terms and conditions, do not use the software.
66*
67* COPYRIGHT © 1994 - 1995 by AT&T. All Rights Reserved
68* COPYRIGHT © 1996 - 2000 by Lucent Technologies. All Rights Reserved
69* COPYRIGHT © 2001 - 2004 by Agere Systems Inc. All Rights Reserved
70* All rights reserved.
71*
72* Redistribution and use in source or binary forms, with or without
73* modifications, are permitted provided that the following conditions are met:
74*
75* . Redistributions of source code must retain the above copyright notice, this
76* list of conditions and the following Disclaimer as comments in the code as
77* well as in the documentation and/or other materials provided with the
78* distribution.
79*
80* . Redistributions in binary form must reproduce the above copyright notice,
81* this list of conditions and the following Disclaimer in the documentation
82* and/or other materials provided with the distribution.
83*
84* . Neither the name of Agere Systems Inc. nor the names of the contributors
85* may be used to endorse or promote products derived from this software
86* without specific prior written permission.
87*
88* Disclaimer
89*
90* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
91* INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
92* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ANY
93* USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
94* RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
95* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
96* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
97* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
98* ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
99* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
100* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
101* DAMAGE.
102*
103*
104*************************************************************************************************************/
105
106/* Alignment
107* Some platforms can access words on odd boundaries (with possibly an performance impact), at other
108* platforms such an access may result in a memory access violation.
109* It is assumed that everywhere where the HCF casts a char pointer into a word pointer, the alignment
110* criteria are met. This put some restrictions on the MSF, which are assumed to be "automatically" fulfilled
111* at the applicable platforms
112* To assert this assumption, the macro HCF_ALIGN can be defined. The default value is 1, meaning byte
113* alignment (or no alignment), a value of 2 means word alignment, a value of 4 means double word alignment
114*/
115
116/***************************** IN_PORT_STRING_8_16 S a m p l e s *****************************************
117
118 // C implementation which let the processor handle the word-at-byte-boundary problem
119#define IN_PORT_STRING_8_16( port, addr, n) while ( n-- ) \
120 { *(hcf_16 FAR*)addr = IN_PORT_WORD( port ); ((hcf_8 FAR*)addr)+=2; }
121
122 // C implementation which handles the word-at-byte-boundary problem
123#define IN_PORT_STRING_8_16( port, addr, n) while ( n-- ) \
124 { hcf_16 i = IN_PORT_WORD(port); *((hcf_8 FAR*)addr)++ = (hcf_8)i; *((hcf_8 FAR*)addr)++ = (hcf_8)(i>>8);}
125
126 // Assembler implementation
127#define IN_PORT_STRING_8_16( port, addr, len) __asm \
128{ \
129 __asm push di \
130 __asm push es \
131 __asm mov cx,len \
132 __asm les di,addr \
133 __asm mov dx,port \
134 __asm rep insw \
135 __asm pop es \
136 __asm pop di \
137}
138
139
140***************************** OUT_PORT_STRING_8_16 S a m p l e s ******************************************
141
142 // C implementation which let the processor handle the word-at-byte-boundary problem
143#define OUT_PORT_STRING_8_16( port, addr, n) while ( n-- ) \
144 { OUT_PORT_WORD( port, *(hcf_16 FAR*)addr ) ; ((hcf_8 FAR*)addr)+=2; }
145
146 // C implementation which handles the word-at-byte-boundary problem
147#define OUT_PORT_STRING_8_16( port, addr, n) while ( n-- ) \
148 { OUT_PORT_WORD( port, *((hcf_8 FAR*)addr) | *(((hcf_8 FAR*)addr)+1)<<8 ); (hcf_8 FAR*)addr+=2; }
149
150 // Assembler implementation
151#define OUT_PORT_STRING_8_16( port, addr, len) __asm \
152{ \
153 __asm push si \
154 __asm push ds \
155 __asm mov cx,len \
156 __asm lds si,addr \
157 __asm mov dx,port \
158 __asm rep outsw \
159 __asm pop ds \
160 __asm pop si \
161}
162
163*************************************************************************************************************/
164
165
166/************************************************************************************************/
167/****************** C O M P I L E R S P E C I F I C M A C R O S ***************************/
168/************************************************************************************************/
169/*************************************************************************************************
170*
171* !!!!!!!!!!!!!!!!!!!!!!!!! Note to the HCF-implementor !!!!!!!!!!!!!!!!!!!!!!!!!
172* !!!! Do not call these macros with parameters which introduce side effects !!!!
173* !!!!!!!!!!!!!!!!!!!!!!!!! Note to the HCF-implementor !!!!!!!!!!!!!!!!!!!!!!!!!
174*
175*
176* By selecting the appropriate Macro definitions by means of modifying the "#ifdef 0/1" lines, the HCF can be
177* adjusted for the I/O characteristics of a specific compiler
178*
179* If needed the macros can be modified or replaced with definitions appropriate for your personal platform.
180* If you need to make such changes it is appreciated if you inform Agere Systems
181* That way the changes can become part of the next release of the WCI
182*
183* For convenience of the MSF-programmer, all macros are allowed to modify their parameters (although some
184* might argue that this would constitute bad coding practice). This has its implications on the HCF, e.g. as a
185* consequence these macros should not be called with parameters which have side effects, e.g auto-increment.
186*
187* in the Microsoft implementation of inline assembly it is O.K. to corrupt all flags except the direction flag
188* and to corrupt all registers except the segment registers and EDI, ESI, ESP and EBP (or their 16 bits
189* equivalents). Other environments may have other constraints
190*
191* in the Intel environment it is O.K to have a word (as a 16 bits quantity) at a byte boundary, hence
192* IN_/OUT_PORT_STRING_8_16 can move words between PC-memory and NIC-memory with as only constraint that the
193* words are on a word boundary in NIC-memory. This does not hold true for all conceivable environments, e.g.
194* an Motorola 68xxx does not allow this. Probably/hopefully the boundary conditions imposed by these type of
195* platforms prevent this case from materializing. If this is not the case, OUT_PORT_STRING_8_16 must be coded
196* by combining two Host memory hcf_8 values at a time to a single hcf_16 value to be passed to the NIC and
197* IN_PORT_STRING_8_16 the single hcf_16 retrieved from the NIC must be split in two hcf_8 values to be stored
198* in Host memory (see the sample code above)
199*
200* The prototypes and functional description of the macros are:
201*
202* hcf_16 IN_PORT_WORD( hcf_16 port )
203* Reads a word (16 bits) from the specified port
204*
205* void OUT_PORT_WORD( hcf_16 port, hcf_16 value)
206* Writes a word (16 bits) to the specified port
207*
208* hcf_16 IN_PORT_DWORD( hcf_16 port )
209* Reads a dword (32 bits) from the specified port
210*
211* void OUT_PORT_DWORD( hcf_16 port, hcf_32 value)
212* Writes a dword (32 bits) to the specified port
213*
214* void IN_PORT_STRING_8_16( port, addr, len)
215* Reads len number of words (16 bits) from NIC memory via the specified port to the (FAR)
216* byte-pointer addr in PC-RAM
217* Note that len specifies the number of words, NOT the number of bytes
218* !!!NOTE, although len specifies the number of words, addr MUST be a char pointer NOTE!!!
219* See also the common notes for IN_PORT_STRING_8_16 and OUT_PORT_STRING_8_16
220*
221* void OUT_PORT_STRING_8_16( port, addr, len)
222* Writes len number of words (16 bits) from the (FAR) byte-pointer addr in PC-RAM via the specified
223* port to NIC memory
224* Note that len specifies the number of words, NOT the number of bytes.
225* !!!NOTE, although len specifies the number of words, addr MUST be a char pointer NOTE!!!
226*
227* The peculiar combination of word-length and char pointers for IN_PORT_STRING_8_16 as well as
228* OUT_PORT_STRING_8_16 is justified by the assumption that it offers a more optimal algorithm
229*
230* void IN_PORT_STRING_32( port, addr, len)
231* Reads len number of double-words (32 bits) from NIC memory via the specified port to the (FAR)
232* double-word address addr in PC-RAM
233*
234* void OUT_PORT_STRING_32( port, addr, len)
235* Writes len number of double-words (32 bits) from the (FAR) double-word address addr in PC-RAM via
236* the specified port to NIC memory
237*
238* !!!!!!!!!!!!!!!!!!!!!!!!! Note to the HCF-implementor !!!!!!!!!!!!!!!!!!!!!!!!!
239* !!!! Do not call these macros with parameters which introduce side effects !!!!
240* !!!!!!!!!!!!!!!!!!!!!!!!! Note to the HCF-implementor !!!!!!!!!!!!!!!!!!!!!!!!!
241*
242*************************************************************************************************/
243
244/**************************** define INT Types ******************************/
245typedef unsigned char hcf_8;
246typedef unsigned short hcf_16;
247typedef unsigned long hcf_32;
248
249/**************************** define I/O Types ******************************/
250#define HCF_IO_MEM 0x0001 // memory mapped I/O ( 0: Port I/O )
251#define HCF_IO_32BITS 0x0002 // 32Bits support ( 0: only 16 Bits I/O)
252
253/****************************** #define HCF_TYPE ********************************/
254#define HCF_TYPE_NONE 0x0000 // No type
255#define HCF_TYPE_WPA 0x0001 // WPA support
256#define HCF_TYPE_USB 0x0002 // reserved (USB Dongle driver support)
257//#define HCF_TYPE_HII 0x0004 // Hermes-II, to discriminate H-I and H-II CFG_HCF_OPT_STRCT
258#define HCF_TYPE_WARP 0x0008 // WARP F/W
259#define HCF_TYPE_PRELOADED 0x0040 // pre-loaded F/W
260#define HCF_TYPE_HII5 0x0080 // Hermes-2.5 H/W
261#define HCF_TYPE_CCX 0x0100 // CKIP
262#define HCF_TYPE_BEAGLE_HII5 0x0200 // Beagle Hermes-2.5 H/W
263#define HCF_TYPE_TX_DELAY 0x4000 // Delayed transmission ( non-DMA only)
264
265/****************************** #define HCF_ASSERT ******************************/
266#define HCF_ASSERT_NONE 0x0000 // No assert support
267#define HCF_ASSERT_PRINTF 0x0001 // Hermes generated debug info
268#define HCF_ASSERT_SW_SUP 0x0002 // logging via Hermes support register
269#define HCF_ASSERT_MB 0x0004 // logging via Mailbox
270#define HCF_ASSERT_RT_MSF_RTN 0x4000 // dynamically binding of msf_assert routine
271#define HCF_ASSERT_LNK_MSF_RTN 0x8000 // statically binding of msf_assert routine
272
273/****************************** #define HCF_ENCAP *******************************/
274#define HCF_ENC_NONE 0x0000 // No encapsulation support
275#define HCF_ENC 0x0001 // HCF handles En-/Decapsulation
276#define HCF_ENC_SUP 0x0002 // HCF supports MSF to handle En-/Decapsulation
277
278/****************************** #define HCF_EXT *********************************/
279#define HCF_EXT_NONE 0x0000 // No expanded features
280#define HCF_EXT_INFO_LOG 0x0001 // logging of Hermes Info frames
281//#define HCF_EXT_INT_TX_OK 0x0002 // RESERVED!!! monitoring successful Tx message
282#define HCF_EXT_INT_TX_EX 0x0004 // monitoring unsuccessful Tx message
283//#define HCF_EXT_MON_MODE 0x0008 // LEGACY
284#define HCF_EXT_TALLIES_FW 0x0010 // support for up to 32 Hermes Engineering tallies
285#define HCF_EXT_TALLIES_HCF 0x0020 // support for up to 8 HCF Engineering tallies
286#define HCF_EXT_NIC_ACCESS 0x0040 // direct access via Aux-ports and to Hermes registers and commands
287#define HCF_EXT_MB 0x0080 // MailBox code expanded
288#define HCF_EXT_IFB_STRCT 0x0100 // MSF custom pointer in IFB
289#define HCF_EXT_DESC_STRCT 0x0200 // MSF custom pointer in Descriptor
290#define HCF_EXT_TX_CONT 0x4000 // Continuous transmit test
291#define HCF_EXT_INT_TICK 0x8000 // enables TimerTick interrupt generation
292
293/****************************** #define HCF_SLEEP *******************************/
294#define HCF_DDS 0x0001 // Disconnected Deep Sleep
295#define HCF_CDS 0x0002 // Connected Deep Sleep
296
297/****************************** #define HCF_TALLIES ******************************/
298#define HCF_TALLIES_NONE 0x0000 // No tally support
299#define HCF_TALLIES_NIC 0x0001 // Hermes Tallies accumulated in IFB
300#define HCF_TALLIES_HCF 0x0002 // HCF Tallies accumulated in IFB
301#define HCF_TALLIES_RESET 0x8000 // Tallies in IFB are reset when reported via hcf_get_info
302
303
304/************************************************************************************************/
305/****************************** M I N I P O R T N D I S *************************************/
306/************************************************************************************************/
307
308#if defined WVLAN_41 || defined WVLAN_48 || defined WVLAN_52 || defined _WIN32_WCE
309
310#ifndef WVLAN_46
311#define HCF_EXT (HCF_EXT_INFO_LOG | HCF_EXT_MB | HCF_EXT_NIC_ACCESS )
312#else
313#define HCF_EXT ( HCF_EXT_TX_CONT | HCF_EXT_INFO_LOG | HCF_EXT_MB | HCF_EXT_NIC_ACCESS )
314#endif
315#define HCF_DLV 1 //H-I legacy, superfluous for H-II
316
317#ifdef _WIN32_WCE
318#define HCF_IO HCF_IO_MEM
319#define HCF_DMA 0 // To enable DMA
320#endif
321
322#if _VARIANT == 7
323#define HCF_SLEEP HCF_CDS
324#endif // _VARIANT == 7
325
326#if _VARIANT == 5 || _VARIANT == 6
327#define _WARP
328#define _AES
329#define HCF_SLEEP HCF_CDS
330#if _VARIANT == 6
331//! #define _RSN
332#endif // _VARIANT == 6
333#ifndef _WIN32_WCE
334#define HCF_IO HCF_IO_32BITS
335#define HCF_DMA 1 // To enable DMA
336#endif
337#endif // _VARIANT == 5 || _VARIANT == 6
338
339
340//HWi for migration purposes I defined a define which will be TRUE for ALL drivers
341//Meaning that _CCX defined code which we think will get a all driver OK flag can be defined from _CCX to _CCX_OK
342#if defined WVLAN_48 // && !defined _WIN32_WCE
343#if _VARIANT == 4 || _VARIANT == 6
344#define _CCX_OK 1
345#endif // _VARIANT == 4 || _VARIANT == 6
346#endif // WVLAN_48
347
348//#if !defined WVLAN_46
349#if defined WVLAN_48
350#if _VARIANT == 4 || _VARIANT == 6
351#define _CCX
352#define HCF_MAX_MSG_CKIP_PADDING 86 //, use 86 for rx fragmentation. 28 is enuf for MIC+PPK encapsulation
353#define HCF_MAX_MSG ( 1514 + HCF_MAX_MSG_CKIP_PADDING ) // need extra padding for CKIP (need to subtract 28 for NDIS)
354#endif // _VARIANT == 4 || _VARIANT == 6
355#endif // WVLAN_48
356//#endif // WVLAN_46
357
358#if !defined WVLAN_46
359#define _PEEK
360#endif
361
362#ifndef _WIN32_WCE
363// ASSERT already used by WinCE...
364#ifdef ASSERT
365#undef ASSERT
366#define ASSERT(x) ASSERTDEBUGMSG((x), (TEXT("SIMULATE ASSERT:")))
367#endif
368#endif
369
370
371#if defined WVLAN_41
372#define MSF_COMPONENT_ID COMP_ID_MINIPORT_NDIS_31
373#endif // WVLAN_41
374#if defined WVLAN_48 && !defined _WIN32_WCE
375#define MSF_COMPONENT_ID COMP_ID_MINIPORT_NDIS_50
376#endif // WVLAN_48 / _WIN32_WCE
377#if defined WVLAN_52 && !defined _WIN32_WCE
378#define MSF_COMPONENT_ID COMP_ID_MINIPORT_NDIS_40
379#endif // WVLAN_52 / _WIN32_WCE
380#if defined WVLAN_46
381#define MSF_COMPONENT_ID COMP_ID_WIN_CE
382#endif // _WIN32_WCE
383
384#define MSF_COMPONENT_VAR _VARIANT
385
386#define T1__HCF_TYPE (HCF_TYPE_NONE)
387
388#define T2__HCF_TYPE (T1__HCF_TYPE)
389
390#ifdef _WARP
391#define T3__HCF_TYPE (T2__HCF_TYPE | HCF_TYPE_HII5 | HCF_TYPE_WARP )
392#else
393#if _VARIANT == 7
394#define T3__HCF_TYPE (T2__HCF_TYPE | HCF_TYPE_HII5)
395#else // _VARIANT == 7
396#define T3__HCF_TYPE (T2__HCF_TYPE)
397#endif // _VARIANT == 7
398#endif // _WARP
399
400#ifdef _CCX_OK
401#define T4__HCF_TYPE (T3__HCF_TYPE | HCF_TYPE_CCX)
402#else
403#define T4__HCF_TYPE (T3__HCF_TYPE)
404#endif // _CCX_OK
405
406//not suitable for H-II #define HCF_CFG_STA_1_BOTTOM 16
407
408// Default WPA in ON for all drivers except for WARP driver
409#ifdef _WARP
410#define T5__HCF_TYPE (T4__HCF_TYPE)
411#else // _WARP
412#define T5__HCF_TYPE (T4__HCF_TYPE | HCF_TYPE_WPA)
413#endif // _WARP
414
415#define HCF_TYPE (T5__HCF_TYPE)
416
417// This is needed to get aux_ctrl() from the HCF for WlFreezeAndDump()
418#if (defined DBG && DBG != 0)
419#ifndef STATIC
420#define STATIC
421#endif
422#endif
423
424#if !defined SOFTRONICS_CODE && !defined _APIDLL && !defined _WIN32_WCE
425#include <ndis.h>
426#endif // SOFTRONICS_CODE / _APIDLL / _WIN32_WCE
427#if defined _WIN32_WCE
428#include <windows.h>
429#include <winnt.h>
430#endif // _WIN32_WCE
431#include "version.h"
432
433#define MSF_COMPONENT_MAJOR_VER TPI_MAJOR_VERSION
434#define MSF_COMPONENT_MINOR_VER TPI_MINOR_VERSION
435
436#if !defined _APIDLL && !defined _WIN32_WCE
437
438__inline UCHAR NDIS_IN_BYTE( ULONG port )
439{
440 UCHAR value;
441 NdisRawReadPortUchar(port , &value);
442 return (value);
443}
444
445__inline ULONG NDIS_IN_LONG( ULONG port )
446{
447 ULONG value;
448 NdisRawReadPortUlong(port , &value);
449 return (value);
450}
451__inline USHORT NDIS_IN_WORD( ULONG port )
452{
453 USHORT value;
454 NdisRawReadPortUshort(port , &value);
455 return (value);
456}
457
458#define IN_PORT_DWORD(port) NDIS_IN_LONG( (ULONG) (port) )
459#define IN_PORT_WORD(port) NDIS_IN_WORD( (ULONG) (port) )
460#define OUT_PORT_DWORD(port, value) NdisRawWritePortUlong((ULONG) (port) , value)
461#define OUT_PORT_WORD(port, value) NdisRawWritePortUshort((ULONG) (port) , (USHORT) (value))
462
463#define IN_PORT_STRING_8_16(port, addr, len) IN_PORT_STRING_16(port, addr, len)
464#define OUT_PORT_STRING_8_16(port, addr, len) OUT_PORT_STRING_16(port, addr, len)
465
466#define IN_PORT_STRING_32(port, addr, len) { \
467 NdisRawReadPortBufferUlong(port, addr, (len)); \
468}
469
470#define OUT_PORT_STRING_32(port, addr, len) { \
471 NdisRawWritePortBufferUlong(port, addr, (len)); \
472}
473
474#define IN_PORT_STRING_16(port, addr, len) NdisRawReadPortBufferUshort(port, addr, (len));
475#define OUT_PORT_STRING_16(port, addr, len) NdisRawWritePortBufferUshort(port, addr, (len));
476
477#endif // _APIDLL / _WIN32_WCE
478
479#if defined _WIN32_WCE
480
481#define HCF_ALIGN 2
482#define HCF_MEM_IO 1 // overrule standard Port I/O with Memory mapped I/O
483#define HCF_PROT_TIME 49
484
485#define IN_PORT_BYTE CE_IN_PORT_BYTE
486#define OUT_PORT_BYTE CE_OUT_PORT_BYTE
487#define IN_PORT_WORD CE_IN_PORT_WORD
488#define OUT_PORT_WORD CE_OUT_PORT_WORD
489#define IN_PORT_STRING_16 CE_IN_PORT_STRING
490#define OUT_PORT_STRING_16 CE_OUT_PORT_STRING
491
492extern hcf_8 CE_IN_PORT_BYTE(hcf_32 port);
493extern void CE_OUT_PORT_BYTE(hcf_32 port, hcf_8 value);
494extern hcf_16 CE_IN_PORT_WORD(hcf_32 port);
495extern void CE_OUT_PORT_WORD(hcf_32 port, hcf_16 value);
496extern void CE_IN_PORT_STRING(hcf_32 port, void *addr, hcf_16 len);
497extern void CE_OUT_PORT_STRING(hcf_32 port, void *addr, hcf_16 len);
498
499
500#endif
501
502#if defined _DEBUG || (defined DBG && DBG != 0)
503#define HCF_ASSERT ( HCF_ASSERT_LNK_MSF_RTN | HCF_ASSERT_RT_MSF_RTN | HCF_ASSERT_PRINTF ) //0xC001
504//#define HCF_ASSERT ( HCF_ASSERT_LNK_MSF_RTN | HCF_ASSERT_RT_MSF_RTN | HCF_ASSERT_PRINTF | HCF_ASSERT_MB ) //just to test
505#endif // _DEBUG || DBG
506
507#if defined DEBUG || defined _DEBUG || (defined DBG && DBG != 0)
508#ifdef _WIN32_WCE
509#define DBGA2W(DBGSTR) CeConvertAnsiToUnicodeLen((char*)DBGSTR)
510#define OUTPUTDEBUGMSG(dprintf_exp) ((void)((! ZONE_DEBUG) ? 0:ce_debug_out dprintf_exp))
511#define ASSERTDEBUGMSG(cond, dprintf_exp) ((void)((cond) ? 0:ce_debug_out dprintf_exp))
512
513#define ZONE_ERROR DEBUGZONE(0)
514#define ZONE_WARN DEBUGZONE(1)
515#define ZONE_FUNCTION DEBUGZONE(2)
516#define ZONE_INIT DEBUGZONE(3)
517#define ZONE_INTR DEBUGZONE(4)
518#define ZONE_RCV DEBUGZONE(5)
519#define ZONE_XMIT DEBUGZONE(6)
520#define ZONE_ASSERT DEBUGZONE(7)
521#define ZONE_DEBUG DEBUGZONE(8)
522#define ZONE_OEM DEBUGZONE(9)
523#define ZONE_HCF DEBUGZONE(10)
524#define ZONE_PORTIO DEBUGZONE(11)
525#define ZONE_LOGTOFILE DEBUGZONE(15)
526
527#else // !(_WIN32_WCE)
528
529#define OUTPUTDEBUGMSG(dprintf_exp) ((void) (DbgPrint dprintf_exp))
530// the assertdebugmsg macro will print filename, line followed by a caller-defined text, when cond == 0
531#define ASSERTDEBUGMSG(cond, print) ((void)((cond) ? 0: (DbgPrint("%s %s:%d - ", print, __FILE__, __LINE__))))
532
533#define ZONE_ERROR 1
534#define ZONE_WARN 1
535#define ZONE_FUNCTION 1
536#define ZONE_INIT 1
537#define ZONE_INTR 1
538#define ZONE_RCV 1
539#define ZONE_XMIT 1
540#define ZONE_ASSERT 1
541#define ZONE_DEBUG 1
542#define ZONE_OEM 1
543#define ZONE_HCF 1
544#define ZONE_PORTIO 1
545#define ZONE_LOGTOFILE 1
546
547#endif // _WIN32_WCE
548#ifndef DBGA2W
549#define DBGA2W
550#endif // DBGA2W
551
552#else // !(defined DEBUG || defined _DEBUG || (defined DBG && DBG != 0) )
553#define OUTPUTDEBUGMSG(dprintf_exp)
554#define ASSERTDEBUGMSG(cond, dprintf_exp)
555#endif // DEBUG / DBG
556
557#if !defined HCF_MAX_MSG_CKIP_PADDING
558#define HCF_MAX_MSG_CKIP_PADDING 0
559#endif // HCF_MAX_MSG_CKIP_PADDING
560
561#if !defined HCF_MAX_MSG
562#define HCF_MAX_MSG 1514
563#endif // HCF_MAX_MSG
564
565#define HCF_LEGACY 1 //;?nv je moet wat
566
567#endif //WVLAN_41 / WVLAN_48 / WVLAN_52 / _WIN32_WCE
568
569
570/************************************************************************************************/
571/**************************** P A C K E T D R I V E R ***************************************/
572/********************************** D O S O D I *********************************************/
573/************************************************************************************************/
574
575#if defined WVLAN_42 || defined WVLAN_43
576
577#pragma warning ( disable: 4001 )
578#define FAR __far //segmented 16 bits mode
579#define BASED __based(__segname("_CODE")) //force all the "const" structures in the CODE segment
580
581//#define HCF_IO 0 //no DMA, no 32 bits
582
583//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To ease testing the different options ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
584
585#define HCF_EXT HCF_EXT_MB
586#define HCF_PROT_TIME 49 //49*10240 microseconds H/W failure protection timer
587
588//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To ease testing the different options ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
589
590/******************************** CONFIGURATION MANAGEMENT *****************************************/
591#ifdef WVLAN_42
592#define MSF_COMPONENT_ID COMP_ID_PACKET
593#define MSF_COMPONENT_VAR 1
594#define MSF_COMPONENT_MAJOR_VER 6
595#define MSF_COMPONENT_MINOR_VER 12
596#endif // WVLAN_42
597
598#ifdef WVLAN_43
599#define MSF_COMPONENT_ID COMP_ID_ODI_16
600#define MSF_COMPONENT_VAR 1
601#define MSF_COMPONENT_MAJOR_VER 6
602#define MSF_COMPONENT_MINOR_VER 10
603#endif // WVLAN_43
604
605/************************************** INPUT / OUTPUT **********************************************/
606#ifndef H_2_INC
607#include <stdio.h>
608#include <conio.h>
609#if 1 //temorary use functions defined in hcf.c
610#ifndef _DEBUG
611#pragma intrinsic( _inp, _inpw, _outp, _outpw )
612#endif // _DEBUG
613
614#define IN_PORT_WORD(port) ((hcf_16)_inpw( (hcf_io)(port) ))
615#define OUT_PORT_WORD(port, value) ((void)_outpw( (hcf_io)(port), value ))
616
617#if 1 // C implementation which let the processor handle the word-at-byte-boundary problem
618#define IN_PORT_STRING_8_16( port, addr, n) while (n--) \
619 { *(hcf_16 FAR*)addr = IN_PORT_WORD( port ); ((hcf_8 FAR*)addr)+=2; }
620#define OUT_PORT_STRING_8_16( port, addr, n) while (n--) \
621 { OUT_PORT_WORD( port, *(hcf_16 FAR*)addr ) ; ((hcf_8 FAR*)addr)+=2; }
622#elif 0 // C implementation which handles the word-at-byte-boundary problem
623#define IN_PORT_STRING_8_16( port, addr, n) while ( n-- ) \
624 { hcf_16 i = IN_PORT_WORD(port); *((hcf_8 FAR*)addr)++ = (hcf_8)i; *((hcf_8 FAR*)addr)++ = (hcf_8)(i>>8);}
625#define OUT_PORT_STRING_8_16( port, addr, n) while ( n-- ) \
626 { OUT_PORT_WORD( port, *((hcf_8 FAR*)addr) | *(((hcf_8 FAR*)addr)+1)<<8 ); (hcf_8 FAR*)addr+=2; }
627#else // Assembler implementation
628#define IN_PORT_STRING_8_16( port, addr, n) __asm \
629{ \
630 __asm push di \
631 __asm push es \
632 __asm mov cx,n \
633 __asm les di,addr \
634 __asm mov dx,port \
635 __asm rep insw \
636 __asm pop es \
637 __asm pop di \
638}
639
640#define OUT_PORT_STRING_8_16( port, addr, n) __asm \
641{ \
642 __asm push si \
643 __asm push ds \
644 __asm mov cx,n \
645 __asm lds si,addr \
646 __asm mov dx,port \
647 __asm rep outsw \
648 __asm pop ds \
649 __asm pop si \
650}
651
652#endif // Asm or C implementation
653#define IN_PORT_STRING_32( port, addr, n) { int n2 = 2*n; IN_PORT_STRING_8_16(port, addr, n2) }
654#define OUT_PORT_STRING_32( port, addr, n) { int n2 = 2*n; OUT_PORT_STRING_8_16(port, addr, n2) }
655#endif // 0 //temorary use functions defined in hcf.c
656#endif // H_2_INC
657
658#endif // WVLAN_42 / WVLAN_43
659
660
661
662/************************************************************************************************/
663/**************************** D O S H - I / II L O A D E R **********************************/
664/************************************************************************************************/
665
666#if defined H0_LDR || defined H1_LDR || defined H2_LDR || defined H5_LDR
667
668#if defined H0_LDR //implies H-I
669#define HCF_DLV 0 //H-I legacy, meaningless under H-II
670#define HCF_DLNV 1 //H-I legacy, meaningless under H-II
671#endif // H0_LDR
672
673#if defined H1_LDR //implies H-I
674#define HCF_DLV 1 //H-I legacy, meaningless under H-II
675#define HCF_DLNV 0 //H-I legacy, meaningless under H-II
676#endif // H1_LDR / H2_LDR
677
678//#if defined H2_LDR : not needed, H-II defaults are O.K for H2_LDR
679
680#ifdef H5_LDR
681#define HCF_TYPE (HCF_TYPE_HII5 | HCF_TYPE_WARP )
682//;? why does only this subset of the H_LDRs need HCF_TYPE to be defined here
683#endif
684
685#define HCF_ASSERT HCF_ASSERT_LNK_MSF_RTN //support dynamic linking of msf_assert routine
686#define HCF_ENCAP 0
687#define HCF_INT_ON 0
688#define HCF_TALLIES 0
689
690#define MSF_COMPONENT_ID COMP_ID_ODI_16 //;?By lack of any better
691#define MSF_COMPONENT_VAR 1
692#define MSF_COMPONENT_MAJOR_VER 0
693#define MSF_COMPONENT_MINOR_VER 0
694
695#include <stdio.h>
696#include <conio.h>
697#if defined NDEBUG
698#pragma intrinsic( _inp, _inpw, _outp, _outpw )
699#endif // NDEBUG
700
701#if 0 //use 0 to replace I/O Macros with logging facility
702#define IN_PORT_WORD(port) ((hcf_16)_inpw( (hcf_io)(port) ))
703#define OUT_PORT_WORD(port, value) ((void)_outpw( (hcf_io)(port), value ))
704#define IN_PORT_STRING_16( port, addr, n) \
705 while ( n-- ) { *(hcf_16 FAR*)addr = IN_PORT_WORD( port ); (cast)addr += 2; }
706#define OUT_PORT_STRING_16( port, addr, n) \
707 while ( n-- ) { OUT_PORT_WORD( port, *(hcf_16 FAR*)addr ) ; (cast)addr += 2; }
708#endif //use 0 to replace I/O Macros with logging facility
709
710#endif // H0_LDR / H1_LDR / H2_LDR
711
712
713
714/************************************************************************************************/
715/**************************** H C F D E M O P R O G R A M ***********************************/
716/************************************************************************************************/
717
718#if defined HCF_DEMO
719
720#define HCF_DLV 1 //;?should become the default !defaults to 1 anyway for H-II
721//#define HCF_DLNV 0 //defaults to 0 anyway for H-II
722
723#define HCF_ASSERT HCF_ASSERT_LNK_MSF_RTN //support dynamic linking of msf_assert routine
724
725#define HCF_ENCAP 0
726#define HCF_INT_ON 0
727#define HCF_TALLIES ( HCF_TALLIES_NIC | HCF_TALLIES_HCF )
728
729//#define MSF_COMPONENT_ID NO configuration management
730
731#include <stdio.h>
732#include <conio.h>
733#if defined NDEBUG
734#pragma intrinsic( _inp, _inpw, _outp, _outpw )
735#endif // NDEBUG
736
737#if 0 //use 0 to replace I/O Macros with logging facility
738#define IN_PORT_WORD(port) ((hcf_16)_inpw( (hcf_io)(port) ))
739#define OUT_PORT_WORD(port, value) ((void)_outpw( (hcf_io)(port), value ))
740#define IN_PORT_STRING_16( port, addr, n) \
741 while ( n-- ) { *(hcf_16 FAR*)addr = IN_PORT_WORD( port ); (cast)addr += 2; }
742#define OUT_PORT_STRING_16( port, addr, n) \
743 while ( n-- ) { OUT_PORT_WORD( port, *(hcf_16 FAR*)addr ) ; (cast)addr += 2; }
744#endif //use 0 to replace I/O Macros with logging facility
745
746#endif // HCF_DEMO
747
748
749
750/************************************************************************************************/
751/*********************************** M A C O S **********************************************/
752/************************************************************************************************/
753
754#if defined WVLAN_45
755
756#include "Version.h"
757
758#define MSF_COMPONENT_ID COMP_ID_MAC_OS
759#define MSF_COMPONENT_VAR VARIANT
760#define MSF_COMPONENT_MAJOR_VER VERSION_MAJOR
761#define MSF_COMPONENT_MINOR_VER VERSION_MINOR
762
763#define MAC_OS 1
764
765#define HCF_BIG_ENDIAN 1 // selects Big Endian (a.k.a. Motorola), most significant byte first
766
767#if defined DEBUG
768#define HCF_ASSERT HCF_ASSERT_MB // logging via Mailbox
769#endif // DEBUG
770
771#ifdef __cplusplus
772extern "C" {
773#endif // __cplusplus
774extern volatile unsigned char *MacIOaddr;
775extern hcf_16 IN_PORT_WORD(hcf_16 port);
776extern void OUT_PORT_WORD(hcf_16 port, hcf_16 value);
777extern void IN_PORT_STRING_16(hcf_16 port, void *addr, hcf_16 len);
778extern void OUT_PORT_STRING_16(hcf_16 port, void *addr, hcf_16 len);
779
780#define SwapBytes(t) (((t) >> 8) + (((t) & 0xff) << 8))
781
782#ifdef __cplusplus
783}
784#endif // __cplusplus
785
786#endif // WVLAN_45
787
788
789
790/************************************************************************************************/
791/****************************************** L I N U X *****************************************/
792/************************************************************************************************/
793
794#ifdef WVLAN_49
795#include <asm/io.h>
796//#include <linux/module.h>
797#include <wl_version.h>
798
799/* The following macro ensures that no symbols are exported, minimizing the chance of a symbol
800 collision in the kernel */
801//EXPORT_NO_SYMBOLS; //;?this place seems not appropriately to me
802
803//#define HCF_SLEEP (HCF_CDS | HCF_DDS )
804#define HCF_SLEEP (HCF_CDS)
805
806//#define HCF_TYPE (HCF_TYPE_HII5|HCF_TYPE_STA|HCF_TYPE_AP)
807#ifdef HERMES25
808#ifdef WARP
809#define HCF_TYPE ( HCF_TYPE_WARP | HCF_TYPE_HII5 )
810#else
811#define HCF_TYPE HCF_TYPE_HII5
812#endif // WARP
813#else
814#define HCF_TYPE HCF_TYPE_NONE
815#endif // HERMES25
816
817#ifdef ENABLE_DMA
818#define HCF_DMA 1
819#endif // ENABLE_DMA
820
821/* We now need a switch to include support for the Mailbox and other necessary extensions */
822#define HCF_EXT ( HCF_EXT_MB | HCF_EXT_INFO_LOG | HCF_EXT_INT_TICK )//get deepsleep exercise going
823
824/* ;? The Linux MSF still uses these definitions; define it here until it's removed */
825#ifndef HCF_TYPE_HII
826#define HCF_TYPE_HII 0x0004
827#endif
828
829#ifndef HCF_TYPE_AP
830#define HCF_TYPE_AP 0x0010
831#endif
832
833#ifndef HCF_TYPE_STA
834#define HCF_TYPE_STA 0x0020
835#endif // HCF_TYPE_STA
836
837/* Guarantees word alignment */
838#define HCF_ALIGN 2
839
840/* Endian macros CNV_INT_TO_LITTLE() and CNV_LITTLE_TO_INT() were renamed to
841 CNV_SHORT_TO_LITTLE() and CNV_LITTLE_TO_SHORT() */
842#ifndef CNV_INT_TO_LITTLE
843#define CNV_INT_TO_LITTLE CNV_SHORT_TO_LITTLE
844#endif
845
846#ifndef CNV_LITTLE_TO_INT
847#define CNV_LITTLE_TO_INT CNV_LITTLE_TO_SHORT
848#endif
849
850#define HCF_ERR_BUSY 0x06
851
852/* UIL defines were removed from the HCF */
853#define UIL_SUCCESS HCF_SUCCESS
854#define UIL_ERR_TIME_OUT HCF_ERR_TIME_OUT
855#define UIL_ERR_NO_NIC HCF_ERR_NO_NIC
856#define UIL_ERR_LEN HCF_ERR_LEN
857#define UIL_ERR_MIN HCF_ERR_MAX /*end of HCF errors which are passed through to UIL
858 *** ** *** ****** ***** *** ****** ******* ** *** */
859#define UIL_ERR_IN_USE 0x44
860#define UIL_ERR_WRONG_IFB 0x46
861#define UIL_ERR_MAX 0x7F /*upper boundary of UIL errors without HCF-pendant
862 ***** ******** ** *** ****** ******* *** ******* */
863#define UIL_ERR_BUSY HCF_ERR_BUSY
864#define UIL_ERR_DIAG_1 HCF_ERR_DIAG_1
865#define UIL_FAILURE 0xFF /* 20010705 nv this relick should be eridicated */
866#define UIL_ERR_PIF_CONFLICT 0x40 //obsolete
867#define UIL_ERR_INCOMP_DRV 0x41 //obsolete
868#define UIL_ERR_DOS_CALL 0x43 //obsolete
869#define UIL_ERR_NO_DRV 0x42 //obsolete
870#define UIL_ERR_NSTL 0x45 //obsolete
871
872
873
874#if 0 //;? #ifdef get this going LATER HERMES25
875#define HCF_IO HCF_IO_32BITS
876#define HCF_DMA 1
877#define HCF_DESC_STRCT_EXT 4
878
879/* Switch for BusMaster DMA support. Note that the above define includes the DMA-specific HCF
880 code in the build. This define sets the MSF to use DMA; if ENABLE_DMA is not defined, then
881 port I/O will be used in the build */
882#ifndef BUS_PCMCIA
883#define ENABLE_DMA
884#endif // USE_PCMCIA
885
886#endif // HERMES25
887
888
889/* Overrule standard WaveLAN Packet Size when in DMA mode */
890#ifdef ENABLE_DMA
891#define HCF_MAX_PACKET_SIZE 2304
892#else
893#define HCF_MAX_PACKET_SIZE 1514
894#endif // ENABLE_DMA
895
896/* The following sets the component ID, as well as the versioning. See also wl_version.h */
897#define MSF_COMPONENT_ID COMP_ID_LINUX
898
899#define MSF_COMPONENT_VAR DRV_VARIANT
900#define MSF_COMPONENT_MAJOR_VER DRV_MAJOR_VERSION
901#define MSF_COMPONENT_MINOR_VER DRV_MINOR_VERSION
902
903/* Define the following to turn on assertions in the HCF */
904//#define HCF_ASSERT 0x8000
905#define HCF_ASSERT HCF_ASSERT_LNK_MSF_RTN // statically binding of msf_assert routine
906
907#ifdef USE_BIG_ENDIAN
908#define HCF_BIG_ENDIAN 1
909#else
910#define HCF_BIG_ENDIAN 0
911#endif /* USE_BIG_ENDIAN */
912
913/* Define the following if your system uses memory-mapped IO */
914//#define HCF_MEM_IO
915
916/* The following defines the standard macros required by the HCF to move data to/from the card */
917#define IN_PORT_BYTE(port) ((hcf_8)inb( (hcf_io)(port) ))
918#define IN_PORT_WORD(port) ((hcf_16)inw( (hcf_io)(port) ))
919#define OUT_PORT_BYTE(port, value) (outb( (hcf_8) (value), (hcf_io)(port) ))
920#define OUT_PORT_WORD(port, value) (outw((hcf_16) (value), (hcf_io)(port) ))
921
922#define IN_PORT_STRING_16(port, dst, n) insw((hcf_io)(port), dst, n)
923#define OUT_PORT_STRING_16(port, src, n) outsw((hcf_io)(port), src, n)
924//#define IN_PORT_STRINGL(port, dst, n) insl((port), (dst), (n))
925//#define OUT_PORT_STRINGL(port, src, n) outsl((port), (src), (n))
926#define IN_PORT_STRING_32(port, dst, n) insl((port), (dst), (n))
927#define OUT_PORT_STRING_32(port, src, n) outsl((port), (src), (n))
928#define IN_PORT_HCF32(port) inl( (hcf_io)(port) )
929#define OUT_PORT_HCF32(port, value) outl((hcf_32)(value), (hcf_io)(port) )
930
931#define IN_PORT_DWORD(port) IN_PORT_HCF32(port)
932#define OUT_PORT_DWORD(port, value) OUT_PORT_HCF32(port, value)
933
934#define IN_PORT_STRING_8_16(port, addr, len) IN_PORT_STRING_16(port, addr, len)
935#define OUT_PORT_STRING_8_16(port, addr, len) OUT_PORT_STRING_16(port, addr, len)
936
937
938#ifndef OUTPUTDEBUGMSG
939#define OUTPUTDEBUGMSG(dprintf_exp)
940#endif
941
942
943#ifndef ASSERTDEBUGMSG
944#define ASSERTDEBUGMSG(cond, dprintf_exp)
945#endif
946
947#ifndef CFG_SCAN_CHANNELS_2GHZ
948#define CFG_SCAN_CHANNELS_2GHZ 0xFCC2
949#endif /* CFG_SCAN_CHANNELS_2GHZ */
950
951#define HCF_MAX_MSG 1600 //get going ;?
952#endif // WVLAN_49
953
954
955
956/************************************************************************************************/
957/********************************************* Q N X ******************************************/
958/************************************************************************************************/
959
960#if defined __QNX__ || defined WVLAN_50
961
962#define MSF_COMPONENT_ID 0 //Although there is no DUI support, we need this to get ...
963#define MSF_COMPONENT_VAR 0 //...compatibilty check to function
964#define MSF_COMPONENT_MAJOR_VER 0 //...;?this is worth looking into to make this a more
965#define MSF_COMPONENT_MINOR_VER 0 //..."defined" I/F so OEMers can figure out what to do
966
967#include <conio.h>
968
969#define IN_PORT_WORD(port) ((hcf_16)inpw( (hcf_io)(port) ))
970#define OUT_PORT_WORD(port, value) (outpw( (hcf_io)(port), (hcf_16) (value) ))
971/*
972#define IN_PORT_STRING_16( port, addr, n) \
973 while ( n-- ) { *(hcf_16*)addr = IN_PORT_WORD( port ); (cast)addr += 2; }
974#define OUT_PORT_STRING_16( port, addr, n) \
975 while ( n-- ) { OUT_PORT_WORD( port, *(hcf_16*)addr ) ; (cast)addr += 2; }
976*/
977
978#endif // QNX / WVLAN_50
979
980
981
982/************************************************************************************************/
983/********************************************* B E O S ****************************************/
984/************************************************************************************************/
985
986#if defined __BEOS__
987
988#define MSF_COMPONENT_ID 0 //Although there is no DUI support, we need this to get ...
989#define MSF_COMPONENT_VAR 0 //...compatibilty check to function
990#define MSF_COMPONENT_MAJOR_VER 0 //...;?this is worth looking into to make this a more
991#define MSF_COMPONENT_MINOR_VER 0 //..."defined" I/F so OEMers can figure out what to do
992
993#include <drivers/Drivers.h>
994#include <drivers/KernelExport.h>
995
996uint8 read_io_8 (int);
997void write_io_8 (int, uint8);
998uint16 read_io_16 (int);
999void write_io_16 (int, uint16);
1000
1001#define IN_PORT_WORD(port) ((hcf_16)read_io_16( (hcf_io)(port) ))
1002#define OUT_PORT_WORD(port, value) (write_io_16( (hcf_io)(port), (hcf_16) (value) ))
1003/*
1004#define IN_PORT_STRING_16( port, addr, n) \
1005 while ( n-- ) { *(hcf_16*)addr = IN_PORT_WORD( port ); (cast)addr += 2; }
1006#define OUT_PORT_STRING_16( port, addr, n) \
1007 while ( n-- ) { OUT_PORT_WORD( port, *(hcf_16*)addr ) ; (cast)addr += 2; }
1008*/
1009#endif // __BEOS__
1010
1011
1012
1013/************************************************************************************************/
1014/******************************** U S B D O N G L E *****************************************/
1015/************************************************************************************************/
1016
1017#if defined USB
1018#include "gpif.h"
1019
1020#define MSF_COMPONENT_MAJOR_VER 0
1021#define MSF_COMPONENT_MINOR_VER 1
1022
1023#define IN_PORT_WORD(port) (Hermes_IO_Read( (hcf_8)(port)))
1024#define OUT_PORT_WORD(port, value) (Hermes_IO_Write( (hcf_8)port, /*(hcf_16)*/(value) ) )
1025/* !!!! NOTE USB supports only 16-bits I/O and no 8-bits I/O
1026 * as a consequence the IN_/OUT_PORT_STRING_16 macros use hcf_16* rather than hcf_8 pointers
1027 * to get more optimal code
1028 * therefore the pointers are incremented by 1 (which means two "bytes") rather than by 2
1029 */
1030//#define IN_PORT_STRING_16( port, addr, n) while ( n-- ) { *((hcf_16*)addr)++ = IN_PORT_WORD( port ); }
1031//#define OUT_PORT_STRING_16( port, addr, n) while ( n-- ) { OUT_PORT_WORD( port, *((hcf_16*)addr)++ ); }
1032#define IN_PORT_STRING_16( port, dst, n) while ( n-- ) { *dst++ = IN_PORT_WORD( port ); }
1033#define OUT_PORT_STRING_16( port, src, n) while ( n-- ) { OUT_PORT_WORD( port, *src++ ); }
1034
1035//#define HCF_TYPE ( HCF_TYPE_AP | HCF_TYPE_WPA )
1036#define HCF_TYPE HCF_TYPE_WPA
1037
1038#endif // USB
1039
1040
1041/************************************************************************************************/
1042/****************************************** FreeBSD *******************************************/
1043/************************************************************************************************/
1044
1045#if defined __FREE_BSD__
1046
1047#define MSF_COMPONENT_ID COMP_ID_FreeBSD
1048#define MSF_COMPONENT_VAR 1
1049#define MSF_COMPONENT_MAJOR_VER 1
1050#define MSF_COMPONENT_MINOR_VER 0
1051
1052#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1053
1054#include <machine/cpufunc.h>
1055
1056#define IN_PORT_WORD(port) ((hcf_16)inw( (hcf_io)(port) ))
1057#define OUT_PORT_WORD(port, value) (outw((hcf_io)(port), (hcf_16)(value)))
1058
1059/*
1060#define IN_PORT_STRING_16( port, addr, n) \
1061 while ( n-- ) { *(hcf_16*)addr = IN_PORT_WORD( port ); (cast)addr += 2; }
1062#define OUT_PORT_STRING_16( port, addr, n) \
1063 while ( n-- ) { OUT_PORT_WORD( port, *(hcf_16*)addr ) ; (cast)addr += 2; }
1064*/
1065#endif // __FREE_BSD__
1066
1067
1068
1069/************************************************************************************************/
1070/********************************* W A V E P O I N T ******************************************/
1071/************************************************************************************************/
1072
1073#if defined WVLAN_81 /* BORLANDC */
1074
1075#define EXTERN_C extern // needed because DHF uses this instead of 'extern'
1076
1077#define MSF_COMPONENT_ID COMP_ID_AP1
1078#define MSF_COMPONENT_VAR 1
1079#define MSF_COMPONENT_MAJOR_VER 4
1080#define MSF_COMPONENT_MINOR_VER 0
1081
1082#define HCF_PROT_TIME 49 //49*10240 microseconds H/W failure protection timer
1083
1084//#define HCF_ASSERT HCF_ASSERT_MB // logging via Mailbox /* debug build only */
1085
1086#if !defined FAR
1087#define FAR far // segmented 16 bits mode
1088#endif // FAR
1089
1090#define IN_PORT_WORD(port) (inport( (hcf_io)(port) ))
1091#define OUT_PORT_WORD(port, value) (outport( (hcf_io)(port), value ))
1092
1093#define IN_PORT_STRING_16(port, addr, len) \
1094 asm { push di; push es; mov cx,len; les di,addr; mov dx,port; rep insw; pop es; pop di }
1095
1096#define OUT_PORT_STRING_16(port, addr, len) \
1097 asm { push si; push ds; mov cx,len; lds si,addr; mov dx,port; rep outsw; pop ds; pop si }
1098
1099#endif // WVLAN_81
1100
1101
1102/************************************************************************************************/
1103/******************************** W A V E L A U N C H *****************************************/
1104/************************************************************************************************/
1105
1106#if defined WVLAUNCH
1107
1108#include "DriverX.h"
1109extern HWDEVICE* g_pDevice;
1110
1111//#define MSF_COMPONENT_ID 0 //;? to get around browser problem
1112
1113#define IN_PORT_WORD(port) HwInpw( g_pDevice, port )
1114#define OUT_PORT_WORD(port, value) HwOutpw( g_pDevice, port, value )
1115
1116
1117// C implementation which let the processor handle the word-at-byte-boundary problem
1118/*
1119#define IN_PORT_STRING_16( port, addr, n) \
1120 while ( n-- ) { *(hcf_16 FAR*)addr = IN_PORT_WORD( port ); (cast)addr += 2; }
1121#define OUT_PORT_STRING_16( port, addr, n) \
1122 while ( n-- ) { OUT_PORT_WORD( port, *(hcf_16 FAR*)addr ) ; (cast)addr += 2; }
1123*/
1124#endif // WVLAUNCH
1125
1126
1127
1128/************************************************************************************************/
1129/************************************* W C I T S T *********************************************/
1130/************************************************************************************************/
1131
1132#if defined WCITST
1133#define MSF_COMPONENT_ID 0 //Although there is no DUI support, we need this to get ...
1134#define MSF_COMPONENT_VAR 0 //...compatibilty check to function
1135#define MSF_COMPONENT_MAJOR_VER 0 //...;?this is worth looking into to make this a more
1136#define MSF_COMPONENT_MINOR_VER 0 //..."defined" I/F so OEMers can figure out what to do
1137
1138//#define HCF_ENCAP HCF_ENC_NONE //to get going
1139//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To ease testing the different options ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1140#define HCF_TYPE (HCF_TYPE_WPA | HCF_TYPE_PRELOADED) // Hermes-I for HCF6, II for HCF7
1141#define HCF_DMA 1
1142//#define LLB //!!!!MIC Debug Only
1143#if defined LLB && !((HCF_TYPE) & HCF_TYPE_WPA)
1144err: no LLB unless SSN;
1145#endif // LLB / HCF_TYPE_WPA
1146//#define HCF_ALIGN 2
1147#define HCF_DLV 1 //just to change memory layout ????;?
1148//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To ease testing the different options ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1149
1150#define HCF_ASSERT HCF_ASSERT_SW_SUP // logging via Hermes support registerr
1151//#define HCF_ASSERT HCF_ASSERT_MB // logging via Mailbox
1152
1153#if defined __GNUC__
1154#include "stdio.h"
1155//#include "unistd.h" //ioperm libc5
1156#include "sys/io.h" //ioperm glibc
1157#define extern //see IO Port Programming mini-HOWTO
1158//#include "asm/io.h" //
1159#define IN_PORT_WORD(port) inw( (hcf_io)(port) )
1160#define IN_PORT_DWORD(port) inl( (hcf_io)(port) )
1161#define OUT_PORT_WORD(port, value) outw( (hcf_io)(port), (hcf_16)(value) )
1162#define OUT_PORT_DWORD(port, value) outl( (hcf_io)(port), (hcf_16)(value) )
1163#else
1164#pragma warning ( disable: 4001 )
1165#define FAR __far // segmented 16 bits mode
1166
1167#include <stdio.h>
1168#include <conio.h>
1169#ifndef _DEBUG
1170#pragma intrinsic( _inp, _inpw, _outp, _outpw )
1171#endif // _DEBUG
1172
1173#ifdef LOG
1174extern FILE* utm_logfile;
1175hcf_16 ipw( hcf_16 port );
1176hcf_8 ipb( hcf_16 port );
1177void opw( hcf_16 port, hcf_16 value );
1178void opb( hcf_16 port, hcf_8 value );
1179
1180#define IN_PORT_WORD(port) ipw( (hcf_io)(port) )
1181#define OUT_PORT_WORD(port, value) opw( (hcf_io)(port), (hcf_16)(value) )
1182#else // LOG
1183#define IN_PORT_WORD(port) ((hcf_16)_inpw( (hcf_io)(port) ))
1184#define OUT_PORT_WORD(port, value) ((void)_outpw( (hcf_io)(port), value ))
1185#endif // LOG
1186
1187#if 1 //ASM example
1188#define IN_PORT_STRING_16( port, addr, len) __asm \
1189{ \
1190 __asm push di \
1191 __asm push es \
1192 __asm mov cx,len \
1193 __asm les di,addr \
1194 __asm mov dx,port \
1195 __asm rep insw \
1196 __asm pop es \
1197 __asm pop di \
1198}
1199
1200#define OUT_PORT_STRING_16( port, addr, len) __asm \
1201{ \
1202 __asm push si \
1203 __asm push ds \
1204 __asm mov cx,len \
1205 __asm lds si,addr \
1206 __asm mov dx,port \
1207 __asm rep outsw \
1208 __asm pop ds \
1209 __asm pop si \
1210}
1211
1212#endif // asm example
1213
1214#endif // __GCC__
1215
1216#if ! defined IN_PORT_STRING_16
1217#define IN_PORT_STRING_16( port, addr, n) while (n--) \
1218 { *(hcf_16 FAR*)addr = IN_PORT_WORD( port ); ((hcf_16 FAR*)addr)++; }
1219#define OUT_PORT_STRING_16( port, addr, n) while (n--) \
1220 { OUT_PORT_WORD( port, *(hcf_16 FAR*)addr ); ((hcf_16 FAR*)addr)++; }
1221#endif // IN_PORT_STRING_16
1222
1223#endif // WCITST
1224
1225
1226/************************************************************************************************/
1227/******************************* Motorola Power PC 800 family *********************************/
1228/************************************************************************************************/
1229/* known users: LH@I
1230 */
1231
1232#if defined I_MPC8XX
1233
1234#define MSF_COMPONENT_VAR 0
1235#define MSF_COMPONENT_ID 0
1236#define MSF_COMPONENT_MAJOR_VER 1
1237#define MSF_COMPONENT_MINOR_VER 0
1238
1239#define HCF_HSI_VAR 1
1240
1241#define HCF_BIG_ENDIAN 1
1242#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1243
1244#include "o_portbl.h"
1245#include "ipcmcia.h"
1246typedef o_uint8_t hcf_8;
1247typedef o_uint16_t hcf_16;
1248typedef o_uint32_t hcf_32;
1249
1250/***************************************************************************/
1251
1252
1253#ifdef _lint
1254#else
1255asm hcf_16 IN_PORT_WORD(int port)
1256{
1257% reg port
1258 lhbrx r3,r0,port
1259 eieio
1260}
1261#endif // _lint
1262
1263
1264#ifdef _lint
1265#else
1266asm void OUT_PORT_WORD(int port, hcf_16 value)
1267{
1268% reg port, value
1269 sthbrx value,r0,port
1270 eieio
1271}
1272#endif // _lint
1273
1274/***************************************************************************/
1275
1276#define IN_PORT_STRING_16(port, addr, len) \
1277 { \
1278 unsigned l = (len); \
1279 hcf_16 *d = (volatile hcf_16 *)(addr); \
1280 while (l--) \
1281 { \
1282 *d++ = *(volatile hcf_16 *)(port); \
1283 EIEIO(); \
1284 } \
1285 }
1286
1287#define OUT_PORT_STRING_16(port, addr, len) \
1288 { \
1289 unsigned l = (len); \
1290 hcf_16 *s = (volatile hcf_16 *)(addr); \
1291 while (l--) \
1292 { \
1293 *(volatile hcf_16 *)(port) = *s++; \
1294 EIEIO(); \
1295 } \
1296 }
1297
1298#endif // I_MPC8XX
1299
1300
1301
1302/************************************************************************************************/
1303/********************************** Diab or High C 29K **************************************/
1304/************************************************************************************************/
1305/* known users: GK@C
1306 */
1307
1308#if defined _AM29K
1309
1310#define MSF_COMPONENT_VAR 0
1311#define MSF_COMPONENT_ID COMP_ID_AP1
1312#define MSF_COMPONENT_MAJOR_VER 1
1313#define MSF_COMPONENT_MINOR_VER 0
1314
1315#define HCF_BIG_ENDIAN 1
1316#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1317
1318#define SwapBytes(t) /*lint -e572*/(((t) >> 8) + (((t) & 0xff) << 8))/*lint +e572*/
1319
1320#if defined __ppc
1321 #ifndef __GNUC__
1322 #define __asm__ asm
1323 #endif
1324
1325 #if ! defined _lint
1326 #define EIEIO() __asm__(" eieio")
1327 #else
1328 #define EIEIO()
1329 #endif
1330
1331 static hcf_16 IN_PORT_WORD(int port) {
1332 hcf_16 value = *(volatile hcf_16 *)(port); EIEIO();
1333 value = SwapBytes(value);
1334 return value;
1335 }
1336
1337 #define OUT_PORT_WORD(port, value) \
1338 { *(volatile hcf_16 *)(port) = SwapBytes(value); EIEIO(); }
1339#else
1340 #define IN_PORT_WORD(port) (*(volatile hcf_16 *)(port))
1341 #define OUT_PORT_WORD(port, value) (*(volatile hcf_16 *)(port) = (value))
1342#endif // __ppc
1343
1344/***************************************************************************/
1345
1346#define IN_PORT_STRING_16( port, addr, len) { \
1347 unsigned l = (len); \
1348 hcf_16 t, *d = (volatile hcf_16 *)(addr); \
1349 while (l--) { \
1350 t = IN_PORT_WORD(port); \
1351 *d++ = SwapBytes(t); \
1352 } \
1353 }
1354
1355#define OUT_PORT_STRING_16( port, addr, len) { \
1356 unsigned l = (len); \
1357 hcf_16 t, *s = (volatile hcf_16 *)(addr); \
1358 while (l--) { \
1359 t = *s++; \
1360 OUT_PORT_WORD(port, SwapBytes(t)); \
1361 } \
1362 }
1363
1364#if PRODUCT == 9150
1365 #define HCF_ASSERT HCF_ASSERT_MB // logging via Mailbox
1366 #undef MSF_COMPONENT_ID
1367#endif // 9150
1368
1369#endif // _AM29K
1370
1371
1372
1373/************************************************************************************************/
1374/***************************************** MPC860 **********************************************/
1375/************************************************************************************************/
1376/* known users: RR
1377 */
1378
1379#if defined CPU
1380#if CPU == PPC860
1381
1382#define MSF_COMPONENT_VAR 0
1383#define MSF_COMPONENT_ID 0
1384#define MSF_COMPONENT_MAJOR_VER 1
1385#define MSF_COMPONENT_MINOR_VER 0
1386
1387#define HCF_BIG_ENDIAN 1
1388#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1389
1390#define SwapBytes(t) /*lint -e572*/(((t) >> 8) + (((t) & 0xff) << 8))/*lint +e572*/
1391
1392#ifndef __GNUC__
1393 #define __asm__ asm
1394#endif
1395
1396#if ! defined _lint
1397 #define EIEIO() __asm__(" eieio")
1398#else
1399 #define EIEIO()
1400#endif
1401
1402static hcf_16 IN_PORT_WORD(int port) {
1403 hcf_16 value = *(volatile hcf_16 *)(port); EIEIO();
1404 value = SwapBytes(value);
1405 return value;
1406 #ifdef __GNUC__
1407 /* the following serves to avoid the compiler warnings that
1408 * IN_PORT_WORD() is not used in some files */
1409 (void)IN_PORT_WORD;
1410 #endif
1411}
1412
1413#define OUT_PORT_WORD(port, value) \
1414 { *(volatile hcf_16 *)(port) = SwapBytes(value); EIEIO(); }
1415
1416/***************************************************************************/
1417
1418#define IN_PORT_STRING_16( port, addr, len) { \
1419 unsigned l = (len); \
1420 hcf_16 t; \
1421 volatile hcf_16 *d = (volatile hcf_16 *)(addr); \
1422 while (l--) { \
1423 t = IN_PORT_WORD(port); \
1424 *d++ = SwapBytes(t); \
1425 } \
1426 }
1427
1428#define OUT_PORT_STRING_16( port, addr, len) { \
1429 unsigned l = (len); \
1430 hcf_16 t; \
1431 volatile hcf_16 *s = (volatile hcf_16 *)(addr); \
1432 while (l--) { \
1433 t = *s++; \
1434 OUT_PORT_WORD(port, SwapBytes(t)); \
1435 } \
1436 }
1437
1438#if PRODUCT == 9150
1439 #define HCF_ASSERT HCF_ASSERT_MB // logging via Mailbox
1440 #undef MSF_COMPONENT_ID
1441#endif
1442
1443#endif /* PPC860 */
1444#endif /* CPU */
1445
1446
1447
1448/************************************************************************************************/
1449/**************************** Microtec Research 80X86 Compiler *********************************/
1450/************************************************************************************************/
1451
1452#if 0
1453
1454//#undef HCF_TYPE // Hermes-I Station F/W without SSN support
1455
1456#define MSF_COMPONENT_VAR 0
1457#define MSF_COMPONENT_ID 0
1458#define MSF_COMPONENT_MAJOR_VER 1
1459#define MSF_COMPONENT_MINOR_VER 0
1460
1461extern int far inp( int );
1462extern void far outp( int, int );
1463extern int far inpw( int );
1464extern void far outpw( int, int );
1465
1466#define IN_PORT_WORD(port) ((hcf_16)inpw( (hcf_io)(port) ))
1467#define OUT_PORT_WORD(port, value) ((void)outpw( (hcf_io)(port), value ))
1468
1469#define IN_PORT_STRING_16( port, addr, len) { \
1470 unsigned l = (len); \
1471 hcf_16 *d = (hcf_16 *)(addr); \
1472 while (l--) *d++ = IN_PORT_WORD(port); \
1473 }
1474
1475#define OUT_PORT_STRING_16( port, addr, len) { \
1476 unsigned l = (len); \
1477 hcf_16 *s = (hcf_16 *)(addr); \
1478 while (l--) OUT_PORT_WORD(port, *s++); \
1479 }
1480#endif /* Microtec 80X86 C Compiler */
1481
1482
1483
1484/************************************************************************************************/
1485/****************************** W A V E L A N E C ********************************************/
1486/************************************************************************************************/
1487/* known users: KM
1488 */
1489
1490#ifdef mc68302
1491
1492#define MSF_COMPONENT_ID COMP_ID_EC
1493
1494#include <version.h>
1495
1496#define MSF_COMPONENT_VAR 1
1497#define MSF_COMPONENT_MAJOR_VER MAJOR_VERSION
1498#define MSF_COMPONENT_MINOR_VER MINOR_VERSION
1499
1500#define HCF_BIG_ENDIAN 1
1501#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1502
1503#define SwapBytes(t) /*lint -e572*/(((t) >> 8) + (((t) & 0xff) << 8))/*lint +e572*/
1504
1505#define PCMCIA_ADDRESS 0xc80000UL
1506
1507#define IN_PORT_2BYTES(port) (*(hcf_16 *)(port))
1508#if 0
1509static hcf_16 IN_PORT_WORD(hcf_32 port) // should be hcf_io, not hcf_32
1510{
1511 hcf_16 word = IN_PORT_2BYTES(port);
1512 return SwapBytes(word);
1513}
1514#else
1515static hcf_16 swap_var;
1516#define IN_PORT_WORD(port) \
1517 (((swap_var = IN_PORT_2BYTES(port)) >> 8) + (((swap_var) & 0xff) << 8))
1518#endif
1519#define OUT_PORT_2BYTES(port, value) (*(hcf_16 *)(port) = (hcf_16)(value))
1520#define OUT_PORT_WORD(port, value) OUT_PORT_2BYTES(port, SwapBytes(value))
1521
1522/*
1523#define IN_PORT_STRING_16(port, addr, len) \
1524 while ((len)--) {*(hcf_16 *)(addr) = IN_PORT_2BYTES(port); ((cast)addr) += 2; }
1525#define OUT_PORT_STRING_16(port, addr, len) \
1526 while ((len)--) {OUT_PORT_2BYTES((port), *(hcf_16 *)(addr)) ; ((cast)addr) += 2; }
1527*/
1528
1529#endif /* mc68302 */
1530
1531
1532
1533/************************************************************************************************/
1534/********************************* NGAP ***************************************/
1535/************************************************************************************************/
1536
1537#if defined __VX_WORKS__ /* VxWorks */
1538
1539#if defined WLC_STATION
1540//#undef HCF_TYPE /* Hermes-I Station F/W without SSN support */
1541#define MSF_COMPONENT_ID COMP_ID_VX_WORKS_ENDSTA
1542#else
1543#define MSF_COMPONENT_ID COMP_ID_VX_WORKS_ENDAP
1544#endif // WLC_STATION
1545
1546#define HCF_YIELD (taskDelay(0) == 0)
1547
1548#define MSF_COMPONENT_VAR 1
1549#define MSF_COMPONENT_MAJOR_VER 1
1550#define MSF_COMPONENT_MINOR_VER 0
1551
1552// #define HCF_ASSERT HCF_ASSERT_MB // logging via Mailbox
1553
1554#if defined PC486BSP
1555
1556#define IN_PORT_WORD(port) (sysInWord ((hcf_io)(port)))
1557#define OUT_PORT_WORD(port, value) (sysOutWord ((hcf_io)(port), (hcf_16) (value)))
1558#define IN_PORT_STRING_16(port, addr, n) (sysInWordString ((hcf_io)(port), addr, n))
1559#define OUT_PORT_STRING_16(port, addr, n) (sysOutWordString ((hcf_io)(port), addr, n))
1560
1561#elif defined AS2000BSP
1562
1563#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1564
1565/* Define PCI stuff here. */
1566unsigned short sysRead16( unsigned short *port );
1567void sysWrite16( unsigned short *port, unsigned short value );
1568
1569#define PCI_IN_BYTE( port ) \
1570 *(unsigned char *)( port )
1571
1572#define PCI_IN_WORD( port ) \
1573 sysRead16( (unsigned short *)( port ) )
1574
1575#define PCI_OUT_BYTE( port, value ) \
1576 *(unsigned char *)( port ) = (unsigned char)( value )
1577
1578#define PCI_OUT_WORD( port, value ) \
1579 sysWrite16( (unsigned short *)( port ), (unsigned short)( value ) )
1580
1581#define IN_PORT_WORD( port ) \
1582 PCI_IN_WORD( port )
1583
1584#define OUT_PORT_WORD( port, value ) \
1585 PCI_OUT_WORD( port, value )
1586
1587#define IN_PORT_STRING_16( port, buf, len ) \
1588 do { \
1589 hcf_16 *p; \
1590 \
1591 for ( p = (hcf_16 *)(buf); p < &( (hcf_16 *)(buf) )[ (int)len ]; p++ ) { \
1592 *p = PCI_IN_WORD( port ); \
1593 } \
1594 } while ( 0 )
1595
1596#define OUT_PORT_STRING_16( port, buf, len ) \
1597 do { \
1598 const hcf_16 *p; \
1599 \
1600 for ( p = (const hcf_16 *)( buf ); p < &( (const hcf_16 *)(buf) )[ (int)len ]; p++ ) { \
1601 PCI_OUT_WORD( port, *p ); \
1602 } \
1603 } while ( 0 )
1604
1605#elif defined FADS860BSP /* elif defined AS2000BSP */
1606
1607#define HCF_BIG_ENDIAN 1
1608
1609#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1610
1611#ifndef __GNUC__
1612 #define __asm__ asm
1613#endif
1614
1615#if ! defined _lint
1616 #define EIEIO() __asm__(" eieio")
1617#else
1618 #define EIEIO()
1619#endif
1620
1621static hcf_16 IN_PORT_WORD(int port) {
1622 hcf_16 value = *(volatile hcf_16 *)(port); EIEIO();
1623 value = ((value & 0xff00) >> 8) + ((value & 0x00ff) << 8);
1624/* value = CNV_LITTLE_TO_SHORT(value); */
1625 return value;
1626 #ifdef __GNUC__
1627 /* the following serves to avoid the compiler warnings that
1628 * IN_PORT_WORD() is not used in some files */
1629 (void)IN_PORT_WORD;
1630 #endif
1631}
1632
1633#define OUT_PORT_WORD(port, value) \
1634 { *(volatile hcf_16 *)(port) = CNV_SHORT_TO_LITTLE(value); EIEIO(); }
1635
1636/***********************************************************************/
1637
1638#define IN_PORT_STRING_16( port, addr, len) { \
1639 unsigned l = (len); \
1640 volatile hcf_16 *d = (volatile hcf_16 *)(addr); \
1641 while (l--) { \
1642 *d++ = *(volatile hcf_16 *)(port); \
1643 EIEIO(); \
1644 } \
1645 }
1646
1647#define OUT_PORT_STRING_16( port, addr, len) { \
1648 unsigned l = (len); \
1649 volatile hcf_16 *s = (volatile hcf_16 *)(addr); \
1650 while (l--) { \
1651 *(volatile hcf_16 *)(port) = *s++; \
1652 EIEIO(); \
1653 } \
1654 }
1655
1656#elif defined DAYTONABSP
1657
1658#define HCF_BIG_ENDIAN 1
1659
1660#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1661
1662#ifndef __GNUC__
1663 #define __asm__ asm
1664#endif
1665
1666#define IN_PORT_WORD(port) (sysOrinocoInWord((unsigned long)(port)))
1667#define OUT_PORT_WORD(port,value) (sysOrinocoOutWord((unsigned long)(port), (unsigned short)(value)))
1668
1669#define IN_PORT_STRING_16(port,addr,len) (sysOrinocoInString((port), (addr), (len)))
1670#define OUT_PORT_STRING_16(port,addr,len) (sysOrinocoOutString((port), (addr), (len)))
1671
1672extern unsigned char sysOrinocoInByte (unsigned long port);
1673extern unsigned short sysOrinocoInWord (unsigned long port);
1674extern void sysOrinocoInString (unsigned long port, void *addr, unsigned short len);
1675
1676extern void sysOrinocoOutByte (unsigned long port, unsigned char value);
1677extern void sysOrinocoOutWord (unsigned long port, unsigned short value);
1678extern void sysOrinocoOutString (unsigned long port, void *addr, unsigned short len);
1679
1680#elif defined ALPHA_BSP
1681
1682#define HCF_BIG_ENDIAN 1
1683
1684#define HCF_IO HCF_IO_MEM // overrule standard Port I/O with Memory mapped I/O
1685
1686#ifndef __GNUC__
1687 #define __asm__ asm
1688#endif
1689
1690#define IN_PORT_WORD(port) (sysOrinocoInWord((unsigned long)(port)))
1691#define OUT_PORT_WORD(port,value) (sysOrinocoOutWord((unsigned long)(port), (unsigned short)(value)))
1692
1693#define IN_PORT_STRING_16(port,addr,len) (sysOrinocoInString((port), (addr), (len)))
1694#define OUT_PORT_STRING_16(port,addr,len) (sysOrinocoOutString((port), (addr), (len)))
1695
1696extern unsigned char sysOrinocoInByte (unsigned long port);
1697extern unsigned short sysOrinocoInWord (unsigned long port);
1698extern void sysOrinocoInString (unsigned long port, void *addr, unsigned short len);
1699
1700extern void sysOrinocoOutByte (unsigned long port, unsigned char value);
1701extern void sysOrinocoOutWord (unsigned long port, unsigned short value);
1702extern void sysOrinocoOutString (unsigned long port, void *addr, unsigned short len);
1703
1704#else
1705
1706err: /* commented here */ /* "BSP is not defined..." */
1707
1708#endif /* else PC486BSP */
1709
1710#endif // __VX_WORKS__
1711
1712
1713
1714/************************************************************************************************/
1715/****************************** VXWORKS. Motorola Sandpoint PowerPC 824X ***********************/
1716/************************************************************************************************/
1717#ifdef __VX_WORKS_SANDPOINT_824X__
1718
1719#include <vxWorks.h>
1720#include <sysLib.h>
1721#include <taskLib.h>
1722
1723#ifdef WVLAN_53
1724#define MSF_COMPONENT_ID COMP_ID_VX_WORKS_ENDSTA
1725#endif /* WVLAN_53 */
1726
1727#ifdef WVLAN_54
1728#define MSF_COMPONENT_ID COMP_ID_VX_WORKS_ENDAP
1729#endif /* WVLAN_54 */
1730
1731#ifdef WVLAN_56
1732#define MSF_COMPONENT_ID COMP_ID_VX_WORKS_END
1733#endif /* WVLAN_56 */
1734
1735#if !defined MSF_COMPONENT_ID
1736#error "you must define an MSF component ID: WVLAN_53, WVLAN_54, WVLAN_56"
1737#endif
1738
1739#define MSF_COMPONENT_VAR 1
1740
1741#define HCF_EXT HCF_EXT_INFO_LOG
1742#define HCF_SLEEP ( HCF_CDS | HCF_DDS )
1743//#define HCF_SLEEP ( HCF_DDS )
1744
1745#ifndef HCF_ACT_WAKEUP
1746#define HCF_ACT_WAKEUP 0x1D
1747#endif // HCF_ACT_WAKEUP
1748
1749#if defined FATNIC | defined BEAGLE_H253
1750#define T1__HCF_TYPE HCF_TYPE_STA
1751#else
1752#define T1__HCF_TYPE HCF_TYPE_AP | HCF_TYPE_STA
1753#endif
1754
1755#ifdef HERMES_USB
1756#define T2__HCF_TYPE (T1__HCF_TYPE | HCF_TYPE_USB)
1757#else // HERMES_USB
1758#define T2__HCF_TYPE (T1__HCF_TYPE)
1759#endif // HERMES_USB
1760
1761#ifdef _WARP
1762#define T3__HCF_TYPE (T2__HCF_TYPE | HCF_TYPE_HII5)
1763#else // _WARP
1764#define T3__HCF_TYPE (T2__HCF_TYPE | HCF_TYPE_WPA | HCF_TYPE_HII)
1765#endif // WARP
1766
1767#ifdef _CCX
1768#define T4__HCF_TYPE (T3__HCF_TYPE | HCF_TYPE_CCX)
1769#else // _WARP
1770#define T4__HCF_TYPE (T3__HCF_TYPE)
1771#endif // _CCX
1772
1773#define T5__HCF_TYPE (T4__HCF_TYPE)
1774
1775// Default to TYPE_AP + SSN!
1776#define HCF_TYPE (T5__HCF_TYPE )
1777
1778
1779
1780#define MSF_COMPONENT_MAJOR_VER 2
1781#define MSF_COMPONENT_MINOR_VER 0
1782
1783#define HCF_IO HCF_IO_MEM
1784#define HCF_DMA 0
1785#define HCF_MEM_IO 1
1786#define HCF_BIG_ENDIAN 1
1787
1788//#define support_32bits 1
1789
1790#define IN_PORT_WORD(port) (sysInWord( (hcf_io)(port) ))
1791#define OUT_PORT_WORD(port, value) (sysOutWord( (hcf_io)(port), (hcf_16)(value) ))
1792#define IN_PORT_DWORD(port) (sysInLong( (hcf_io)(port) ))
1793#define OUT_PORT_DWORD(port, value) (sysOutLong( (hcf_io)(port), (hcf_16)(value) ))
1794#define IN_PORT_STRING_16(port, dst, n) (sysInWordString((hcf_io)(port), (hcf_16 *)dst, n))
1795#define OUT_PORT_STRING_16(port, src, n) (sysOutWordString((hcf_io)(port), (hcf_16 *)src, n))
1796
1797#ifdef WVLAN_DEBUG
1798#define DBG 1
1799#define _DEBUG 1
1800#endif
1801
1802/* we'll need to add these prints someday */
1803#define OUTPUTDEBUGMSG(dprintf_exp)
1804#define ASSERTDEBUGMSG(cond, dprintf_exp)
1805
1806#define HCF_INTERFACE_CONNECT(ifbp)
1807#define HCF_INTERFACE_DISCONNECT(ifbp)
1808#define HCF_ENTER_INTERFACE_FUNCT(ibfb)
1809#define HCF_LEAVE_INTERFACE_FUNCT(ifbp)
1810
1811#define CNV_END_INT(w) ( ((hcf_16)(w) & 0x00FF) << 8 | ((hcf_16)(w) & 0xFF00) >> 8 )
1812#define CNV_LITTLE_TO_INT(w) CNV_END_INT(w)
1813#define CNV_INT_TO_LITTLE(w) CNV_LITTLE_TO_INT(w)
1814
1815#endif /* __VX_WORKS_SANDPOINT_824X__ */
1816
1817/************************************************************************************************/
1818/************************************* VXWORKS. ARM T8300 IPPhone *****************************/
1819/************************************************************************************************/
1820#if defined( IPT_T8300 ) || defined( IPT_T8307 )
1821
1822#include <vxWorks.h>
1823#include <sysLib.h>
1824#include <taskLib.h>
1825
1826#define HCF_ALIGN 4 /* default to 4 byte alignment */
1827
1828#define BEAGLE_H253 /* Hermes 2.5.3 build, better to be in the project file */
1829#define OOR_DDS /* Hermes 2.5.3 build, better to be in the project file */
1830#define FATNIC
1831
1832
1833#ifdef WVLAN_53
1834#define MSF_COMPONENT_ID COMP_ID_VX_WORKS_ENDSTA
1835#endif /* WVLAN_53 */
1836
1837#ifdef WVLAN_54
1838#define MSF_COMPONENT_ID COMP_ID_VX_WORKS_ENDAP
1839#endif /* WVLAN_54 */
1840
1841#ifdef WVLAN_56
1842#define MSF_COMPONENT_ID COMP_ID_VX_WORKS_END
1843#endif /* WVLAN_56 */
1844
1845#if !defined MSF_COMPONENT_ID
1846#error "you must define an MSF component ID: WVLAN_53, WVLAN_54, WVLAN_56"
1847#endif
1848
1849#define MSF_COMPONENT_VAR 1
1850
1851#define HCF_EXT HCF_EXT_INFO_LOG
1852//#define HCF_EXT HCF_EXT_INFO_LOG | HCF_EXT_MB
1853#define HCF_SLEEP ( HCF_CDS | HCF_DDS )
1854//#define HCF_SLEEP ( HCF_DDS )
1855
1856#ifndef HCF_ACT_WAKEUP
1857#define HCF_ACT_WAKEUP 0x1D
1858#endif // HCF_ACT_WAKEUP
1859
1860#if defined FATNIC || defined BEAGLE_H253
1861#define T1__HCF_TYPE HCF_TYPE_STA
1862#else
1863//#define T1__HCF_TYPE HCF_TYPE_AP | HCF_TYPE_STA
1864#define T1__HCF_TYPE HCF_TYPE_STA /* dz, Station code only */
1865#endif
1866
1867#ifdef HERMES_USB
1868#define T2__HCF_TYPE (T1__HCF_TYPE | HCF_TYPE_USB)
1869#else // HERMES_USB
1870#define T2__HCF_TYPE (T1__HCF_TYPE)
1871#endif // HERMES_USB
1872
1873#ifdef _WARP
1874#define T3__HCF_TYPE (T2__HCF_TYPE | HCF_TYPE_HII5)
1875#else // _WARP
1876#define T3__HCF_TYPE (T2__HCF_TYPE | HCF_TYPE_WPA | HCF_TYPE_HII)
1877//#define T3__HCF_TYPE (T2__HCF_TYPE | HCF_TYPE_HII) /* dz. no WPA support at this time, test code */
1878#endif // WARP
1879
1880#ifdef _CCX
1881#define T4__HCF_TYPE (T3__HCF_TYPE | HCF_TYPE_CCX)
1882#else // _WARP
1883#define T4__HCF_TYPE (T3__HCF_TYPE)
1884#endif // _CCX
1885
1886#define T5__HCF_TYPE (T4__HCF_TYPE)
1887
1888// Default to TYPE_AP + SSN!
1889#define HCF_TYPE (T5__HCF_TYPE )
1890
1891
1892#define MSF_COMPONENT_MAJOR_VER 2
1893#define MSF_COMPONENT_MINOR_VER 0
1894
1895#define HCF_IO HCF_IO_MEM
1896#define HCF_DMA 0
1897#define HCF_MEM_IO 1
1898
1899
1900/* Endian is determined by vxWorks project compile option */
1901#if (_BYTE_ORDER == _BIG_ENDIAN)
1902#undef HCF_LITTLE_ENDIAN
1903#define HCF_BIG_ENDIAN 1
1904#endif
1905
1906
1907#define CNV_END(w) ( ((hcf_16)(w) & 0x00FF) << 8 | ((hcf_16)(w) & 0xFF00) >> 8 )
1908#if defined HCF_BIG_ENDIAN
1909//******************************************** B I G E N D I A N *******************************************
1910#define CNV_LITTLE_TO_INT(w) CNV_END(w) // endianess conversion needed
1911#define CNV_BIG_TO_INT(w) (w) // no endianess conversion needed
1912#else
1913//****************************************** L I T T L E E N D I A N ****************************************
1914#define CNV_LITTLE_TO_INT(w) (w) // no endianess conversion needed
1915#define CNV_BIG_TO_INT(w) CNV_END(w) // endianess conversion needed
1916#endif // HCF_BIG_ENDIAN
1917
1918// conversion macros which can be expressed in other macros
1919#define CNV_INT_TO_LITTLE(w) CNV_LITTLE_TO_INT(w)
1920#define CNV_INT_TO_BIG(w) CNV_BIG_TO_INT(w)
1921
1922
1923
1924#define IN_PORT_WORD( port ) *((volatile hcf_16 *)( port ))
1925#define OUT_PORT_WORD( port, value ) *((volatile hcf_16 *)( port )) = ((hcf_16)( value ))
1926//#define IN_PORT_BYTE( port ) *((volatile hcf_8 *)( port ))
1927
1928#define IN_PORT_STRING( port, addr, len) { \
1929 unsigned l = len; \
1930 hcf_16 *d = (hcf_16 *)(addr); \
1931 hcf_16 t; \
1932 while (l--) { \
1933 t = IN_PORT_WORD(port); \
1934 *d++ = CNV_LITTLE_TO_INT(t); \
1935 } \
1936} // IN_PORT_STRING
1937
1938#define OUT_PORT_STRING( port, addr, len) { \
1939 unsigned l = (len); \
1940 hcf_16 *s = (hcf_16 *)(addr); \
1941 hcf_16 t; \
1942 while (l--) { \
1943 t = *s++; \
1944 t = CNV_LITTLE_TO_INT(t); \
1945 OUT_PORT_WORD(port, t); \
1946 } \
1947} // OUT_PORT_STRING
1948
1949#define IN_PORT_STRING_16(port, dst, n) { \
1950 unsigned l = (n); \
1951 hcf_16 *d = (hcf_16 *)(dst); \
1952 while (l--) { \
1953 *d++ = IN_PORT_WORD(port); \
1954 } \
1955} // IN_PORT_STRING_16
1956
1957#define OUT_PORT_STRING_16(port, src, n) { \
1958 hcf_16 t; \
1959 int l = (n); \
1960 hcf_16 *s = (hcf_16 *)(src); \
1961 while (l--) { \
1962 t = *s++; \
1963 OUT_PORT_WORD(port, t); \
1964 } \
1965} // OUT_PORT_STRING_16
1966
1967/* #define HCF_YIELD (taskDelay(0) == 0) */
1968
1969
1970
1971#ifdef WVLAN_DEBUG
1972#define DBG 1
1973#define _DEBUG 1
1974#endif
1975
1976/* we'll need to add these prints someday */
1977#define OUTPUTDEBUGMSG(dprintf_exp)
1978#define ASSERTDEBUGMSG(cond, dprintf_exp)
1979
1980#define HCF_INTERFACE_CONNECT(ifbp)
1981#define HCF_INTERFACE_DISCONNECT(ifbp)
1982#define HCF_ENTER_INTERFACE_FUNCT(ibfb)
1983#define HCF_LEAVE_INTERFACE_FUNCT(ifbp)
1984
1985#define sysInWord(offsetAddr) IN_PORT_WORD(offsetAddr)
1986#define sysInByte(offsetAddr) IN_PORT_BYTE(offsetAddr)
1987#define sysOutWord(addr, value) OUT_PORT_WORD(addr, value)
1988
1989#endif /*IPT_T8300 */
1990
1991/************************************************************************************************************/
1992/*********************************** **************************************/
1993/************************************************************************************************************/
1994#if ! defined HCF_ALIGN
1995#define HCF_ALIGN 1 //default to no alignment
1996#endif // HCF_ALIGN
1997
1998#if ! defined HCF_ASSERT
1999#define HCF_ASSERT 0
2000#endif // HCF_ASSERT
2001
2002#if ! defined HCF_BIG_ENDIAN
2003#define HCF_BIG_ENDIAN 0
2004#endif // HCF_BIG_ENDIAN
2005
2006#if ! defined HCF_DL_ONLY
2007#define HCF_DL_ONLY 0
2008#endif // HCF_DL_ONLY
2009
2010#if ! defined HCF_DMA
2011#define HCF_DMA 0
2012#endif // HCF_DMA
2013
2014#if ! defined HCF_ENCAP
2015#define HCF_ENCAP HCF_ENC
2016#endif // HCF_ENCAP
2017
2018#if ! defined HCF_ENTRY
2019#define HCF_ENTRY( ifbp )
2020#endif // HCF_ENTRY
2021
2022#if ! defined HCF_EXIT
2023#define HCF_EXIT( ifbp )
2024#endif // HCF_EXIT
2025
2026#if ! defined HCF_EXT
2027#define HCF_EXT 0
2028#endif // HCF_EXT
2029
2030#if ! defined HCF_INT_ON
2031#define HCF_INT_ON 1
2032#endif // HCF_INT_ON
2033
2034#if ! defined HCF_IO
2035#define HCF_IO 0 //default 16 bits support only, port I/O
2036#endif // HCF_IO
2037
2038#if ! defined HCF_LEGACY
2039#define HCF_LEGACY 0
2040#endif // HCF_LEGACY
2041
2042#if ! defined HCF_MAX_LTV
2043#define HCF_MAX_LTV 1200 // sufficient for all known purposes
2044#endif // HCF_MAX_LTV
2045
2046#if ! defined HCF_PROT_TIME
2047#define HCF_PROT_TIME 100 // number of 10K microsec protection timer against H/W malfunction
2048#endif // HCF_PROT_TIME
2049
2050#if ! defined HCF_SLEEP
2051#define HCF_SLEEP 0
2052#endif // HCF_SLEEP
2053
2054#if ! defined HCF_TALLIES
2055#define HCF_TALLIES ( HCF_TALLIES_NIC | HCF_TALLIES_HCF )
2056#endif // HCF_TALLIES
2057
2058#if ! defined HCF_TYPE
2059#define HCF_TYPE 0
2060#endif // HCF_TYPE
2061
2062#if HCF_BIG_ENDIAN
2063#undef HCF_BIG_ENDIAN
2064#define HCF_BIG_ENDIAN 1 //just for convenience of generating cfg_hcf_opt
2065#endif // HCF_BIG_ENDIAN
2066
2067#if HCF_DL_ONLY
2068#undef HCF_DL_ONLY
2069#define HCF_DL_ONLY 1 //just for convenience of generating cfg_hcf_opt
2070#endif // HCF_DL_ONLY
2071
2072#if HCF_DMA
2073#undef HCF_DMA
2074#define HCF_DMA 1 //just for convenience of generating cfg_hcf_opt
2075#endif // HCF_DMA
2076
2077#if HCF_INT_ON
2078#undef HCF_INT_ON
2079#define HCF_INT_ON 1 //just for convenience of generating cfg_hcf_opt
2080#endif // HCF_INT_ON
2081
2082
2083#if ! defined IN_PORT_STRING_8_16
2084#define IN_PORT_STRING_8_16(port, addr, len) IN_PORT_STRING_16(port, addr, len)
2085#define OUT_PORT_STRING_8_16(port, addr, len) OUT_PORT_STRING_16(port, addr, len)
2086#endif // IN_PORT_STRING_8_16
2087
2088/************************************************************************************************/
2089/********** *************/
2090/************************************************************************************************/
2091
2092#if ! defined FAR
2093#define FAR // default to flat 32-bits code
2094#endif // FAR
2095
2096typedef hcf_8 FAR *wci_bufp; // segmented 16-bits or flat 32-bits pointer to 8 bits unit
2097typedef hcf_16 FAR *wci_recordp; // segmented 16-bits or flat 32-bits pointer to 16 bits unit
2098
2099/* I/O Address size
2100* Platforms which use port mapped I/O will (in general) have a 64k I/O space, conveniently expressed in a
2101* 16-bits quantity
2102* Platforms which use memory mapped I/O will (in general) have an I/O space much larger than 64k, and need a
2103* 32-bits quantity to express the I/O base
2104*/
2105
2106#if HCF_IO & HCF_IO_MEM
2107typedef hcf_32 hcf_io;
2108#else
2109typedef hcf_16 hcf_io;
2110#endif //HCF_IO
2111
2112#if HCF_PROT_TIME > 128
2113#define HCF_PROT_TIME_SHFT 3
2114#define HCF_PROT_TIME_DIV 8
2115#elif HCF_PROT_TIME > 64
2116#define HCF_PROT_TIME_SHFT 2
2117#define HCF_PROT_TIME_DIV 4
2118#elif HCF_PROT_TIME > 32
2119#define HCF_PROT_TIME_SHFT 1
2120#define HCF_PROT_TIME_DIV 2
2121#else //HCF_PROT_TIME >= 19
2122#define HCF_PROT_TIME_SHFT 0
2123#define HCF_PROT_TIME_DIV 1
2124#endif
2125
2126#define HCF_PROT_TIME_CNT (HCF_PROT_TIME / HCF_PROT_TIME_DIV)
2127
2128
2129/************************************************************************************************************/
2130/******************************************* . . . . . . . . . *********************************************/
2131/************************************************************************************************************/
2132
2133/* MSF_COMPONENT_ID is used to define the CFG_IDENTITY_STRCT in HCF.C
2134* CFG_IDENTITY_STRCT is defined in HCF.C purely based on convenience arguments.
2135* The HCF can not have the knowledge to determine the ComponentId field of the Identity record (aka as
2136* Version Record), therefore the MSF part of the Drivers must supply this value via the System Constant
2137* MSF_COMPONENT_ID.
2138* There is a set of values predefined in MDD.H (format COMP_ID_.....)
2139*
2140* Note that taking MSF_COMPONENT_ID as a default value for DUI_COMPAT_VAR is purely an implementation
2141* convenience, the numerical values of these two quantities have none functional relationship whatsoever.
2142*/
2143
2144#if defined MSF_COMPONENT_ID
2145
2146#if ! defined DUI_COMPAT_VAR
2147#define DUI_COMPAT_VAR MSF_COMPONENT_ID
2148#endif // DUI_COMPAT_VAR
2149
2150#if ! defined DUI_COMPAT_BOT //;?this way utilities can lower as well raise the bottom
2151#define DUI_COMPAT_BOT 8
2152#endif // DUI_COMPAT_BOT
2153
2154#if ! defined DUI_COMPAT_TOP //;?this way utilities can lower as well raise the top
2155#define DUI_COMPAT_TOP 8
2156#endif // DUI_COMPAT_TOP
2157
2158#endif // MSF_COMPONENT_ID
2159
2160#if (HCF_TYPE) & HCF_TYPE_HII5
2161
2162#if ! defined HCF_HSI_VAR_5
2163#define HCF_HSI_VAR_5
2164#endif // HCF_HSI_VAR_5
2165
2166#if ! defined HCF_APF_VAR_4
2167#define HCF_APF_VAR_4
2168#endif // HCF_APF_VAR_4
2169
2170#if (HCF_TYPE) & HCF_TYPE_WARP
2171#if ! defined HCF_STA_VAR_4
2172#define HCF_STA_VAR_4
2173#endif // HCF_STA_VAR_4
2174#else
2175#if ! defined HCF_STA_VAR_2
2176#define HCF_STA_VAR_2
2177#endif // HCF_STA_VAR_2
2178#endif
2179
2180#if defined HCF_HSI_VAR_4
2181err: HSI variants 4 correspond with HII;
2182#endif // HCF_HSI_VAR_4
2183
2184#else
2185
2186#if ! defined HCF_HSI_VAR_4
2187#define HCF_HSI_VAR_4 //Hermes-II all types (for the time being!)
2188#endif // HCF_HSI_VAR_4
2189
2190#if ! defined HCF_APF_VAR_2
2191#define HCF_APF_VAR_2
2192#endif // HCF_APF_VAR_2
2193
2194#if ! defined HCF_STA_VAR_2
2195#define HCF_STA_VAR_2
2196#endif // HCF_STA_VAR_2
2197
2198#endif // HCF_TYPE_HII5
2199
2200#if ! defined HCF_PRI_VAR_3
2201#define HCF_PRI_VAR_3
2202#endif // HCF_PRI_VAR_3
2203
2204#if defined HCF_HSI_VAR_1 || defined HCF_HSI_VAR_2 || defined HCF_HSI_VAR_3
2205err: HSI variants 1, 2 and 3 correspond with H-I only;
2206#endif // HCF_HSI_VAR_1, HCF_HSI_VAR_2, HCF_HSI_VAR_3
2207
2208#if defined HCF_PRI_VAR_1 || defined HCF_PRI_VAR_2
2209err: primary variants 1 and 2 correspond with H-I only;
2210#endif // HCF_PRI_VAR_1 / HCF_PRI_VAR_2
2211
2212
2213/************************************************************************************************************/
2214/******************************************* . . . . . . . . . *********************************************/
2215/************************************************************************************************************/
2216
2217
2218/* The BASED customization macro is used to resolves the SS!=DS conflict for the Interrupt Service logic in
2219 * DOS Drivers. Due to the cumbersomeness of mixing C and assembler local BASED variables still end up in the
2220 * wrong segment. The workaround is that the HCF uses only global BASED variables or IFB-based variables.
2221 * The "BASED" construction (supposedly) only amounts to something in the small memory model.
2222 *
2223 * Note that the whole BASED rigmarole is needlessly complicated because both the Microsoft Compiler and
2224 * Linker are unnecessary restrictive in what far pointer manipulation they allow
2225 */
2226
2227#if ! defined BASED
2228#define BASED
2229#endif // BASED
2230
2231#if ! defined EXTERN_C
2232#ifdef __cplusplus
2233#define EXTERN_C extern "C"
2234#else
2235#define EXTERN_C
2236#endif // __cplusplus
2237#endif // EXTERN_C
2238
2239#if ! defined NULL
2240#define NULL ((void *) 0)
2241#endif // NULL
2242
2243#if ! defined TEXT
2244#define TEXT(x) x
2245#endif // TEXT
2246
2247#if !defined _TCHAR_DEFINED
2248#define TCHAR char
2249#endif // _TCHAR_DEFINED
2250
2251/************************************************************************************************************/
2252/*********************** C O N F L I C T D E T E C T I O N & R E S O L U T I O N ************************/
2253/************************************************************************************************************/
2254#if defined HCF_LITTLE_ENDIAN
2255err: HCF_LITTLE_ENDIAN is obsolete;
2256#endif // HCF_LITTLE_ENDIAN
2257
2258#if defined HCF_INT_OFF
2259err: HCF_INT_OFF is obsolete;
2260#endif //HCF_INT_OFF
2261
2262#if HCF_ALIGN != 1 && HCF_ALIGN != 2 && HCF_ALIGN != 4 && HCF_ALIGN != 8
2263err: invalid value for HCF_ALIGN;
2264#endif // HCF_ALIGN
2265
2266#if (HCF_ASSERT) & ~( HCF_ASSERT_PRINTF | HCF_ASSERT_SW_SUP | HCF_ASSERT_MB | HCF_ASSERT_RT_MSF_RTN | \
2267 HCF_ASSERT_LNK_MSF_RTN )
2268err: invalid value for HCF_ASSERT;
2269#endif // HCF_ASSERT
2270
2271#if (HCF_ASSERT) & HCF_ASSERT_MB && ! ( (HCF_EXT) & HCF_EXT_MB ) //detect potential conflict
2272err: these macros are not used consistently;
2273#endif // HCF_ASSERT_MB / HCF_EXT_MB
2274
2275#if HCF_BIG_ENDIAN != 0 && HCF_BIG_ENDIAN != 1
2276err: invalid value for HCF_BIG_ENDIAN;
2277#endif // HCF_BIG_ENDIAN
2278
2279#if HCF_DL_ONLY != 0 && HCF_DL_ONLY != 1
2280err: invalid value for HCF_DL_ONLY;
2281#endif // HCF_DL_ONLY
2282
2283#if HCF_DMA != 0 && HCF_DMA != 1
2284err: invalid value for HCF_DMA;
2285#endif // HCF_DMA
2286
2287#if (HCF_ENCAP) & ~( HCF_ENC | HCF_ENC_SUP )
2288err: invalid value for HCF_ENCAP;
2289#endif // HCF_ENCAP
2290
2291#if (HCF_EXT) & ~( HCF_EXT_INFO_LOG | HCF_EXT_INT_TX_EX | HCF_EXT_TALLIES_FW | HCF_EXT_TALLIES_HCF | \
2292 HCF_EXT_NIC_ACCESS | HCF_EXT_MB | HCF_EXT_INT_TICK | \
2293 HCF_EXT_IFB_STRCT | HCF_EXT_DESC_STRCT | HCF_EXT_TX_CONT )
2294err: invalid value for HCF_EXT;
2295#endif // HCF_EXT
2296
2297#if HCF_INT_ON != 0 && HCF_INT_ON != 1
2298err: invalid value for HCF_INT_ON;
2299#endif // HCF_INT_ON
2300
2301#if (HCF_IO) & ~( HCF_IO_MEM | HCF_IO_32BITS )
2302err: invalid value for HCF_IO;
2303#endif // HCF_IO
2304
2305#if HCF_LEGACY != 0 && HCF_LEGACY != 1
2306err: invalid value for HCF_LEGACY;
2307#endif // HCF_LEGACY
2308
2309#if HCF_MAX_LTV < 16 || HCF_MAX_LTV > 2304
2310err: invalid value for HCF_MAX_LTV;
2311#endif // HCF_MAX_LTV
2312
2313#if HCF_PROT_TIME != 0 && ( HCF_PROT_TIME < 19 || 256 < HCF_PROT_TIME )
2314err: below minimum .08 second required by Hermes or possibly above hcf_32 capacity;
2315#endif // HCF_PROT_TIME
2316
2317#if (HCF_SLEEP) & ~( HCF_CDS | HCF_DDS )
2318err: invalid value for HCF_SLEEP;
2319#endif // HCF_SLEEP
2320
2321#if (HCF_SLEEP) && ! (HCF_INT_ON)
2322err: these macros are not used consistently;
2323#endif // HCF_SLEEP / HCF_INT_ON
2324
2325#if (HCF_SLEEP) && ! ( (HCF_EXT) & HCF_EXT_INT_TICK )
2326//;? err: these macros are not used consistently;
2327#endif // HCF_SLEEP / HCF_EXT_INT_TICK
2328
2329#if (HCF_TALLIES) & ~( HCF_TALLIES_HCF | HCF_TALLIES_NIC | HCF_TALLIES_RESET ) || \
2330 (HCF_TALLIES) == HCF_TALLIES_RESET
2331err: invalid value for HCF_TALLIES;
2332#endif // HCF_TALLIES
2333
2334#if (HCF_TYPE) & ~(HCF_TYPE_WPA | HCF_TYPE_USB | HCF_TYPE_PRELOADED | HCF_TYPE_HII5 | HCF_TYPE_WARP | \
2335 HCF_TYPE_CCX /* | HCF_TYPE_TX_DELAY */ )
2336err: invalid value for HCF_TYPE;
2337#endif //HCF_TYPE
2338
2339#if (HCF_TYPE) & HCF_TYPE_WARP && (HCF_TYPE) & HCF_TYPE_WPA
2340err: at most 1 of these macros should be defined;
2341#endif //HCF_TYPE_WARP / HCF_TYPE_WPA
2342
2343#endif //HCFCFG_H
2344