drivers/staging/wlags49_h2/hcfcfg.h

   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  ******************************/
 245 typedef unsigned char                   hcf_8;
 246 typedef unsigned short                  hcf_16;
 247 typedef 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
 492 extern hcf_8  CE_IN_PORT_BYTE(hcf_32 port);
 493 extern void   CE_OUT_PORT_BYTE(hcf_32 port, hcf_8 value);
 494 extern hcf_16 CE_IN_PORT_WORD(hcf_32 port);
 495 extern void   CE_OUT_PORT_WORD(hcf_32 port, hcf_16 value);
 496 extern void   CE_IN_PORT_STRING(hcf_32 port, void *addr, hcf_16 len);
 497 extern 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
 772 extern "C" {
 773 #endif // __cplusplus
 774 extern volatile unsigned char *MacIOaddr;
 775 extern hcf_16 IN_PORT_WORD(hcf_16 port);
 776 extern void   OUT_PORT_WORD(hcf_16 port, hcf_16 value);
 777 extern void   IN_PORT_STRING_16(hcf_16 port, void *addr, hcf_16 len);
 778 extern 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
 996 uint8 read_io_8 (int);
 997 void write_io_8 (int, uint8);
 998 uint16 read_io_16 (int);
 999 void 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"
1109 extern 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)
1144 err: 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
1174 extern FILE* utm_logfile;
1175 hcf_16  ipw( hcf_16 port );
1176 hcf_8   ipb( hcf_16 port );
1177 void    opw( hcf_16 port, hcf_16 value );
1178 void    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"
1246 typedef o_uint8_t  hcf_8;
1247 typedef o_uint16_t hcf_16;
1248 typedef o_uint32_t hcf_32;
1249
1250 /***************************************************************************/
1251
1252
1253 #ifdef _lint
1254 #else
1255 asm 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
1266 asm 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
1402 static 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
1461 extern int far inp( int );
1462 extern void far outp( int, int );
1463 extern int far inpw( int );
1464 extern 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
1509 static 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
1515 static 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. */
1566 unsigned short sysRead16( unsigned short *port );
1567 void 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
1621 static 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
1672 extern unsigned char    sysOrinocoInByte    (unsigned long port);
1673 extern unsigned short   sysOrinocoInWord    (unsigned long port);
1674 extern void             sysOrinocoInString  (unsigned long port, void *addr, unsigned short len);
1675
1676 extern void             sysOrinocoOutByte   (unsigned long port, unsigned char value);
1677 extern void             sysOrinocoOutWord   (unsigned long port, unsigned short value);
1678 extern 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
1696 extern unsigned char    sysOrinocoInByte    (unsigned long port);
1697 extern unsigned short   sysOrinocoInWord    (unsigned long port);
1698 extern void             sysOrinocoInString  (unsigned long port, void *addr, unsigned short len);
1699
1700 extern void             sysOrinocoOutByte   (unsigned long port, unsigned char value);
1701 extern void             sysOrinocoOutWord   (unsigned long port, unsigned short value);
1702 extern void             sysOrinocoOutString (unsigned long port, void *addr, unsigned short len);
1703
1704 #else
1705
1706 err: /* 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
2096 typedef hcf_8  FAR *wci_bufp;                   // segmented 16-bits or flat 32-bits pointer to 8 bits unit
2097 typedef 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
2107 typedef hcf_32 hcf_io;
2108 #else
2109 typedef 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
2181 err: 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
2205 err: 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
2209 err: 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
2255 err: HCF_LITTLE_ENDIAN is obsolete;
2256 #endif //       HCF_LITTLE_ENDIAN
2257
2258 #if defined HCF_INT_OFF
2259 err: 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
2263 err: 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 )
2268 err: 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
2272 err: 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
2276 err: invalid value for HCF_BIG_ENDIAN;
2277 #endif // HCF_BIG_ENDIAN
2278
2279 #if HCF_DL_ONLY != 0 && HCF_DL_ONLY != 1
2280 err: invalid value for HCF_DL_ONLY;
2281 #endif // HCF_DL_ONLY
2282
2283 #if HCF_DMA != 0 && HCF_DMA != 1
2284 err: invalid value for HCF_DMA;
2285 #endif // HCF_DMA
2286
2287 #if (HCF_ENCAP) & ~( HCF_ENC | HCF_ENC_SUP )
2288 err: 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 )
2294 err: invalid value for HCF_EXT;
2295 #endif // HCF_EXT
2296
2297 #if HCF_INT_ON != 0 && HCF_INT_ON != 1
2298 err: invalid value for HCF_INT_ON;
2299 #endif // HCF_INT_ON
2300
2301 #if (HCF_IO) & ~( HCF_IO_MEM | HCF_IO_32BITS )
2302 err: invalid value for HCF_IO;
2303 #endif // HCF_IO
2304
2305 #if HCF_LEGACY != 0 && HCF_LEGACY != 1
2306 err: invalid value for HCF_LEGACY;
2307 #endif // HCF_LEGACY
2308
2309 #if HCF_MAX_LTV < 16 || HCF_MAX_LTV > 2304
2310 err: 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 )
2314 err: 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 )
2318 err: invalid value for HCF_SLEEP;
2319 #endif // HCF_SLEEP
2320
2321 #if (HCF_SLEEP) && ! (HCF_INT_ON)
2322 err: 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
2331 err: 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 */ )
2336 err: invalid value for HCF_TYPE;
2337 #endif //HCF_TYPE
2338
2339 #if (HCF_TYPE) & HCF_TYPE_WARP && (HCF_TYPE) & HCF_TYPE_WPA
2340 err: at most 1 of these macros should be defined;
2341 #endif //HCF_TYPE_WARP / HCF_TYPE_WPA
2342
2343 #endif //HCFCFG_H
2344