sound/pci/asihpi/hpi_internal.h

   1 /******************************************************************************
   2
   3     AudioScience HPI driver
   4     Copyright (C) 1997-2010  AudioScience Inc. <support@audioscience.com>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of version 2 of the GNU General Public License as
   8     published by the Free Software Foundation;
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19 HPI internal definitions
  20
  21 (C) Copyright AudioScience Inc. 1996-2009
  22 ******************************************************************************/
  23
  24 #ifndef _HPI_INTERNAL_H_
  25 #define _HPI_INTERNAL_H_
  26
  27 #include "hpi.h"
  28 /** maximum number of memory regions mapped to an adapter */
  29 #define HPI_MAX_ADAPTER_MEM_SPACES (2)
  30
  31 /* Each OS needs its own hpios.h, or specific define as above */
  32 #include "hpios.h"
  33
  34 /* physical memory allocation */
  35 void hpios_locked_mem_init(void
  36         );
  37 void hpios_locked_mem_free_all(void
  38         );
  39 #define hpios_locked_mem_prepare(a, b, c, d);
  40 #define hpios_locked_mem_unprepare(a)
  41
  42 /** Allocate and map an area of locked memory for bus master DMA operations.
  43
  44 On success, *pLockedMemeHandle is a valid handle, and 0 is returned
  45 On error *pLockedMemHandle marked invalid, non-zero returned.
  46
  47 If this function succeeds, then HpiOs_LockedMem_GetVirtAddr() and
  48 HpiOs_LockedMem_GetPyhsAddr() will always succed on the returned handle.
  49 */
  50 u16 hpios_locked_mem_alloc(struct consistent_dma_area *p_locked_mem_handle,
  51                                                            /**< memory handle */
  52         u32 size, /**< size in bytes to allocate */
  53         struct pci_dev *p_os_reference
  54         /**< OS specific data required for memory allocation */
  55         );
  56
  57 /** Free mapping and memory represented by LockedMemHandle
  58
  59 Frees any resources, then invalidates the handle.
  60 Returns 0 on success, 1 if handle is invalid.
  61
  62 */
  63 u16 hpios_locked_mem_free(struct consistent_dma_area *locked_mem_handle);
  64
  65 /** Get the physical PCI address of memory represented by LockedMemHandle.
  66
  67 If handle is invalid *pPhysicalAddr is set to zero and return 1
  68 */
  69 u16 hpios_locked_mem_get_phys_addr(struct consistent_dma_area
  70         *locked_mem_handle, u32 *p_physical_addr);
  71
  72 /** Get the CPU address of of memory represented by LockedMemHandle.
  73
  74 If handle is NULL *ppvVirtualAddr is set to NULL and return 1
  75 */
  76 u16 hpios_locked_mem_get_virt_addr(struct consistent_dma_area
  77         *locked_mem_handle, void **ppv_virtual_addr);
  78
  79 /** Check that handle is valid
  80 i.e it represents a valid memory area
  81 */
  82 u16 hpios_locked_mem_valid(struct consistent_dma_area *locked_mem_handle);
  83
  84 /* timing/delay */
  85 void hpios_delay_micro_seconds(u32 num_micro_sec);
  86
  87 struct hpi_message;
  88 struct hpi_response;
  89
  90 typedef void hpi_handler_func(struct hpi_message *, struct hpi_response *);
  91
  92 /* If the assert fails, compiler complains
  93    something like size of array `msg' is negative.
  94    Unlike linux BUILD_BUG_ON, this works outside function scope.
  95 */
  96 #define compile_time_assert(cond, msg) \
  97     typedef char ASSERT_##msg[(cond) ? 1 : -1]
  98
  99 /*/////////////////////////////////////////////////////////////////////////// */
 100 /* Private HPI Entity related definitions                                     */
 101
 102 #define STR_SIZE_FIELD_MAX 65535U
 103 #define STR_TYPE_FIELD_MAX 255U
 104 #define STR_ROLE_FIELD_MAX 255U
 105
 106 struct hpi_entity_str {
 107         u16 size;
 108         u8 type;
 109         u8 role;
 110 };
 111
 112 #if defined(_MSC_VER)
 113 #pragma warning(push)
 114 #pragma warning(disable : 4200)
 115 #endif
 116
 117 struct hpi_entity {
 118         struct hpi_entity_str header;
 119 #if ! defined(HPI_OS_DSP_C6000) || (defined(HPI_OS_DSP_C6000) && (__TI_COMPILER_VERSION__ > 6000008))
 120         /* DSP C6000 compiler v6.0.8 and lower
 121            do not support  flexible array member */
 122         u8 value[];
 123 #else
 124         /* NOTE! Using sizeof(struct hpi_entity) will give erroneous results */
 125 #define HPI_INTERNAL_WARN_ABOUT_ENTITY_VALUE
 126         u8 value[1];
 127 #endif
 128 };
 129
 130 #if defined(_MSC_VER)
 131 #pragma warning(pop)
 132 #endif
 133
 134 /******************************************* bus types */
 135 enum HPI_BUSES {
 136         HPI_BUS_ISAPNP = 1,
 137         HPI_BUS_PCI = 2,
 138         HPI_BUS_USB = 3,
 139         HPI_BUS_NET = 4
 140 };
 141
 142 /******************************************* CONTROL ATTRIBUTES ****/
 143 /* (in order of control type ID */
 144
 145 /* This allows for 255 control types, 256 unique attributes each */
 146 #define HPI_CTL_ATTR(ctl, ai) (HPI_CONTROL_##ctl * 0x100 + ai)
 147
 148 /* Get the sub-index of the attribute for a control type */
 149 #define HPI_CTL_ATTR_INDEX(i) (i&0xff)
 150
 151 /* Extract the control from the control attribute */
 152 #define HPI_CTL_ATTR_CONTROL(i) (i>>8)
 153
 154 /* Generic control attributes.  */
 155
 156 /** Enable a control.
 157 0=disable, 1=enable
 158 \note generic to all mixer plugins?
 159 */
 160 #define HPI_GENERIC_ENABLE HPI_CTL_ATTR(GENERIC, 1)
 161
 162 /** Enable event generation for a control.
 163 0=disable, 1=enable
 164 \note generic to all controls that can generate events
 165 */
 166 #define HPI_GENERIC_EVENT_ENABLE HPI_CTL_ATTR(GENERIC, 2)
 167
 168 /* Volume Control attributes */
 169 #define HPI_VOLUME_GAIN                 HPI_CTL_ATTR(VOLUME, 1)
 170 #define HPI_VOLUME_AUTOFADE             HPI_CTL_ATTR(VOLUME, 2)
 171
 172 /** For HPI_ControlQuery() to get the number of channels of a volume control*/
 173 #define HPI_VOLUME_NUM_CHANNELS         HPI_CTL_ATTR(VOLUME, 6)
 174 #define HPI_VOLUME_RANGE                HPI_CTL_ATTR(VOLUME, 10)
 175
 176 /** Level Control attributes */
 177 #define HPI_LEVEL_GAIN                  HPI_CTL_ATTR(LEVEL, 1)
 178 #define HPI_LEVEL_RANGE                 HPI_CTL_ATTR(LEVEL, 10)
 179
 180 /* Meter Control attributes */
 181 /** return RMS signal level */
 182 #define HPI_METER_RMS                   HPI_CTL_ATTR(METER, 1)
 183 /** return peak signal level */
 184 #define HPI_METER_PEAK                  HPI_CTL_ATTR(METER, 2)
 185 /** ballistics for ALL rms meters on adapter */
 186 #define HPI_METER_RMS_BALLISTICS        HPI_CTL_ATTR(METER, 3)
 187 /** ballistics for ALL peak meters on adapter */
 188 #define HPI_METER_PEAK_BALLISTICS       HPI_CTL_ATTR(METER, 4)
 189
 190 /** For HPI_ControlQuery() to get the number of channels of a meter control*/
 191 #define HPI_METER_NUM_CHANNELS          HPI_CTL_ATTR(METER, 5)
 192
 193 /* Multiplexer control attributes */
 194 #define HPI_MULTIPLEXER_SOURCE          HPI_CTL_ATTR(MULTIPLEXER, 1)
 195 #define HPI_MULTIPLEXER_QUERYSOURCE     HPI_CTL_ATTR(MULTIPLEXER, 2)
 196
 197 /** AES/EBU transmitter control attributes */
 198 /** AESEBU or SPDIF */
 199 #define HPI_AESEBUTX_FORMAT             HPI_CTL_ATTR(AESEBUTX, 1)
 200 #define HPI_AESEBUTX_SAMPLERATE         HPI_CTL_ATTR(AESEBUTX, 3)
 201 #define HPI_AESEBUTX_CHANNELSTATUS      HPI_CTL_ATTR(AESEBUTX, 4)
 202 #define HPI_AESEBUTX_USERDATA           HPI_CTL_ATTR(AESEBUTX, 5)
 203
 204 /** AES/EBU receiver control attributes */
 205 #define HPI_AESEBURX_FORMAT             HPI_CTL_ATTR(AESEBURX, 1)
 206 #define HPI_AESEBURX_ERRORSTATUS        HPI_CTL_ATTR(AESEBURX, 2)
 207 #define HPI_AESEBURX_SAMPLERATE         HPI_CTL_ATTR(AESEBURX, 3)
 208 #define HPI_AESEBURX_CHANNELSTATUS      HPI_CTL_ATTR(AESEBURX, 4)
 209 #define HPI_AESEBURX_USERDATA           HPI_CTL_ATTR(AESEBURX, 5)
 210
 211 /** \defgroup tuner_defs Tuners
 212 \{
 213 */
 214 /** \defgroup tuner_attrs Tuner control attributes
 215 \{
 216 */
 217 #define HPI_TUNER_BAND                  HPI_CTL_ATTR(TUNER, 1)
 218 #define HPI_TUNER_FREQ                  HPI_CTL_ATTR(TUNER, 2)
 219 #define HPI_TUNER_LEVEL                 HPI_CTL_ATTR(TUNER, 3)
 220 #define HPI_TUNER_AUDIOMUTE             HPI_CTL_ATTR(TUNER, 4)
 221 /* use TUNER_STATUS instead */
 222 #define HPI_TUNER_VIDEO_STATUS          HPI_CTL_ATTR(TUNER, 5)
 223 #define HPI_TUNER_GAIN                  HPI_CTL_ATTR(TUNER, 6)
 224 #define HPI_TUNER_STATUS                HPI_CTL_ATTR(TUNER, 7)
 225 #define HPI_TUNER_MODE                  HPI_CTL_ATTR(TUNER, 8)
 226 /** RDS data. */
 227 #define HPI_TUNER_RDS                   HPI_CTL_ATTR(TUNER, 9)
 228 /** Audio pre-emphasis. */
 229 #define HPI_TUNER_DEEMPHASIS            HPI_CTL_ATTR(TUNER, 10)
 230 /** HD Radio tuner program control. */
 231 #define HPI_TUNER_PROGRAM               HPI_CTL_ATTR(TUNER, 11)
 232 /** HD Radio tuner digital signal quality. */
 233 #define HPI_TUNER_HDRADIO_SIGNAL_QUALITY        HPI_CTL_ATTR(TUNER, 12)
 234 /** HD Radio SDK firmware version. */
 235 #define HPI_TUNER_HDRADIO_SDK_VERSION   HPI_CTL_ATTR(TUNER, 13)
 236 /** HD Radio DSP firmware version. */
 237 #define HPI_TUNER_HDRADIO_DSP_VERSION   HPI_CTL_ATTR(TUNER, 14)
 238 /** HD Radio signal blend (force analog, or automatic). */
 239 #define HPI_TUNER_HDRADIO_BLEND         HPI_CTL_ATTR(TUNER, 15)
 240
 241 /** \} */
 242
 243 /** \defgroup pads_attrs Tuner PADs control attributes
 244 \{
 245 */
 246 /** The text string containing the station/channel combination. */
 247 #define HPI_PAD_CHANNEL_NAME            HPI_CTL_ATTR(PAD, 1)
 248 /** The text string containing the artist. */
 249 #define HPI_PAD_ARTIST                  HPI_CTL_ATTR(PAD, 2)
 250 /** The text string containing the title. */
 251 #define HPI_PAD_TITLE                   HPI_CTL_ATTR(PAD, 3)
 252 /** The text string containing the comment. */
 253 #define HPI_PAD_COMMENT                 HPI_CTL_ATTR(PAD, 4)
 254 /** The integer containing the PTY code. */
 255 #define HPI_PAD_PROGRAM_TYPE            HPI_CTL_ATTR(PAD, 5)
 256 /** The integer containing the program identification. */
 257 #define HPI_PAD_PROGRAM_ID              HPI_CTL_ATTR(PAD, 6)
 258 /** The integer containing whether traffic information is supported.
 259 Contains either 1 or 0. */
 260 #define HPI_PAD_TA_SUPPORT              HPI_CTL_ATTR(PAD, 7)
 261 /** The integer containing whether traffic announcement is in progress.
 262 Contains either 1 or 0. */
 263 #define HPI_PAD_TA_ACTIVE               HPI_CTL_ATTR(PAD, 8)
 264 /** \} */
 265 /** \} */
 266
 267 /* VOX control attributes */
 268 #define HPI_VOX_THRESHOLD               HPI_CTL_ATTR(VOX, 1)
 269
 270 /*?? channel mode used hpi_multiplexer_source attribute == 1 */
 271 #define HPI_CHANNEL_MODE_MODE HPI_CTL_ATTR(CHANNEL_MODE, 1)
 272
 273 /** \defgroup channel_modes Channel Modes
 274 Used for HPI_ChannelModeSet/Get()
 275 \{
 276 */
 277 /** Left channel out = left channel in, Right channel out = right channel in. */
 278 #define HPI_CHANNEL_MODE_NORMAL                 1
 279 /** Left channel out = right channel in, Right channel out = left channel in. */
 280 #define HPI_CHANNEL_MODE_SWAP                   2
 281 /** Left channel out = left channel in, Right channel out = left channel in. */
 282 #define HPI_CHANNEL_MODE_LEFT_TO_STEREO         3
 283 /** Left channel out = right channel in, Right channel out = right channel in.*/
 284 #define HPI_CHANNEL_MODE_RIGHT_TO_STEREO        4
 285 /** Left channel out = (left channel in + right channel in)/2,
 286     Right channel out = mute. */
 287 #define HPI_CHANNEL_MODE_STEREO_TO_LEFT         5
 288 /** Left channel out = mute,
 289     Right channel out = (right channel in + left channel in)/2. */
 290 #define HPI_CHANNEL_MODE_STEREO_TO_RIGHT        6
 291 #define HPI_CHANNEL_MODE_LAST                   6
 292 /** \} */
 293
 294 /* Bitstream control set attributes */
 295 #define HPI_BITSTREAM_DATA_POLARITY     HPI_CTL_ATTR(BITSTREAM, 1)
 296 #define HPI_BITSTREAM_CLOCK_EDGE        HPI_CTL_ATTR(BITSTREAM, 2)
 297 #define HPI_BITSTREAM_CLOCK_SOURCE      HPI_CTL_ATTR(BITSTREAM, 3)
 298
 299 #define HPI_POLARITY_POSITIVE           0
 300 #define HPI_POLARITY_NEGATIVE           1
 301
 302 /* Bitstream control get attributes */
 303 #define HPI_BITSTREAM_ACTIVITY          1
 304
 305 /* SampleClock control attributes */
 306 #define HPI_SAMPLECLOCK_SOURCE                  HPI_CTL_ATTR(SAMPLECLOCK, 1)
 307 #define HPI_SAMPLECLOCK_SAMPLERATE              HPI_CTL_ATTR(SAMPLECLOCK, 2)
 308 #define HPI_SAMPLECLOCK_SOURCE_INDEX            HPI_CTL_ATTR(SAMPLECLOCK, 3)
 309 #define HPI_SAMPLECLOCK_LOCAL_SAMPLERATE\
 310         HPI_CTL_ATTR(SAMPLECLOCK, 4)
 311 #define HPI_SAMPLECLOCK_AUTO                    HPI_CTL_ATTR(SAMPLECLOCK, 5)
 312 #define HPI_SAMPLECLOCK_LOCAL_LOCK                      HPI_CTL_ATTR(SAMPLECLOCK, 6)
 313
 314 /* Microphone control attributes */
 315 #define HPI_MICROPHONE_PHANTOM_POWER HPI_CTL_ATTR(MICROPHONE, 1)
 316
 317 /** Equalizer control attributes */
 318 /** Used to get number of filters in an EQ. (Can't set) */
 319 #define HPI_EQUALIZER_NUM_FILTERS HPI_CTL_ATTR(EQUALIZER, 1)
 320 /** Set/get the filter by type, freq, Q, gain */
 321 #define HPI_EQUALIZER_FILTER HPI_CTL_ATTR(EQUALIZER, 2)
 322 /** Get the biquad coefficients */
 323 #define HPI_EQUALIZER_COEFFICIENTS HPI_CTL_ATTR(EQUALIZER, 3)
 324
 325 /* Note compander also uses HPI_GENERIC_ENABLE */
 326 #define HPI_COMPANDER_PARAMS     HPI_CTL_ATTR(COMPANDER, 1)
 327 #define HPI_COMPANDER_MAKEUPGAIN HPI_CTL_ATTR(COMPANDER, 2)
 328 #define HPI_COMPANDER_THRESHOLD  HPI_CTL_ATTR(COMPANDER, 3)
 329 #define HPI_COMPANDER_RATIO      HPI_CTL_ATTR(COMPANDER, 4)
 330 #define HPI_COMPANDER_ATTACK     HPI_CTL_ATTR(COMPANDER, 5)
 331 #define HPI_COMPANDER_DECAY      HPI_CTL_ATTR(COMPANDER, 6)
 332
 333 /* Cobranet control attributes. */
 334 #define HPI_COBRANET_SET         HPI_CTL_ATTR(COBRANET, 1)
 335 #define HPI_COBRANET_GET         HPI_CTL_ATTR(COBRANET, 2)
 336 #define HPI_COBRANET_SET_DATA    HPI_CTL_ATTR(COBRANET, 3)
 337 #define HPI_COBRANET_GET_DATA    HPI_CTL_ATTR(COBRANET, 4)
 338 #define HPI_COBRANET_GET_STATUS  HPI_CTL_ATTR(COBRANET, 5)
 339 #define HPI_COBRANET_SEND_PACKET HPI_CTL_ATTR(COBRANET, 6)
 340 #define HPI_COBRANET_GET_PACKET  HPI_CTL_ATTR(COBRANET, 7)
 341
 342 /*------------------------------------------------------------
 343  Cobranet Chip Bridge - copied from HMI.H
 344 ------------------------------------------------------------*/
 345 #define  HPI_COBRANET_HMI_cobra_bridge           0x20000
 346 #define  HPI_COBRANET_HMI_cobra_bridge_tx_pkt_buf \
 347         (HPI_COBRANET_HMI_cobra_bridge + 0x1000)
 348 #define  HPI_COBRANET_HMI_cobra_bridge_rx_pkt_buf \
 349         (HPI_COBRANET_HMI_cobra_bridge + 0x2000)
 350 #define  HPI_COBRANET_HMI_cobra_if_table1         0x110000
 351 #define  HPI_COBRANET_HMI_cobra_if_phy_address \
 352         (HPI_COBRANET_HMI_cobra_if_table1 + 0xd)
 353 #define  HPI_COBRANET_HMI_cobra_protocolIP       0x72000
 354 #define  HPI_COBRANET_HMI_cobra_ip_mon_currentIP \
 355         (HPI_COBRANET_HMI_cobra_protocolIP + 0x0)
 356 #define  HPI_COBRANET_HMI_cobra_ip_mon_staticIP \
 357         (HPI_COBRANET_HMI_cobra_protocolIP + 0x2)
 358 #define  HPI_COBRANET_HMI_cobra_sys              0x100000
 359 #define  HPI_COBRANET_HMI_cobra_sys_desc \
 360                 (HPI_COBRANET_HMI_cobra_sys + 0x0)
 361 #define  HPI_COBRANET_HMI_cobra_sys_objectID \
 362         (HPI_COBRANET_HMI_cobra_sys + 0x100)
 363 #define  HPI_COBRANET_HMI_cobra_sys_contact \
 364         (HPI_COBRANET_HMI_cobra_sys + 0x200)
 365 #define  HPI_COBRANET_HMI_cobra_sys_name \
 366                 (HPI_COBRANET_HMI_cobra_sys + 0x300)
 367 #define  HPI_COBRANET_HMI_cobra_sys_location \
 368         (HPI_COBRANET_HMI_cobra_sys + 0x400)
 369
 370 /*------------------------------------------------------------
 371  Cobranet Chip Status bits
 372 ------------------------------------------------------------*/
 373 #define HPI_COBRANET_HMI_STATUS_RXPACKET 2
 374 #define HPI_COBRANET_HMI_STATUS_TXPACKET 3
 375
 376 /*------------------------------------------------------------
 377  Ethernet header size
 378 ------------------------------------------------------------*/
 379 #define HPI_ETHERNET_HEADER_SIZE (16)
 380
 381 /* These defines are used to fill in protocol information for an Ethernet packet
 382     sent using HMI on CS18102 */
 383 /** ID supplied by Cirrius for ASI packets. */
 384 #define HPI_ETHERNET_PACKET_ID                  0x85
 385 /** Simple packet - no special routing required */
 386 #define HPI_ETHERNET_PACKET_V1                  0x01
 387 /** This packet must make its way to the host across the HPI interface */
 388 #define HPI_ETHERNET_PACKET_HOSTED_VIA_HMI      0x20
 389 /** This packet must make its way to the host across the HPI interface */
 390 #define HPI_ETHERNET_PACKET_HOSTED_VIA_HMI_V1   0x21
 391 /** This packet must make its way to the host across the HPI interface */
 392 #define HPI_ETHERNET_PACKET_HOSTED_VIA_HPI      0x40
 393 /** This packet must make its way to the host across the HPI interface */
 394 #define HPI_ETHERNET_PACKET_HOSTED_VIA_HPI_V1   0x41
 395
 396 #define HPI_ETHERNET_UDP_PORT (44600)   /*!< UDP messaging port */
 397
 398 /** Base network time out is set to 100 milli-seconds. */
 399 #define HPI_ETHERNET_TIMEOUT_MS      (100)
 400
 401 /** \defgroup tonedet_attr Tonedetector attributes
 402 \{
 403 Used by HPI_ToneDetector_Set() and HPI_ToneDetector_Get()
 404 */
 405
 406 /** Set the threshold level of a tonedetector,
 407 Threshold is a -ve number in units of dB/100,
 408 */
 409 #define HPI_TONEDETECTOR_THRESHOLD HPI_CTL_ATTR(TONEDETECTOR, 1)
 410
 411 /** Get the current state of tonedetection
 412 The result is a bitmap of detected tones.  pairs of bits represent the left
 413 and right channels, with left channel in LSB.
 414 The lowest frequency detector state is in the LSB
 415 */
 416 #define HPI_TONEDETECTOR_STATE HPI_CTL_ATTR(TONEDETECTOR, 2)
 417
 418 /** Get the frequency of a tonedetector band.
 419 */
 420 #define HPI_TONEDETECTOR_FREQUENCY HPI_CTL_ATTR(TONEDETECTOR, 3)
 421
 422 /**\}*/
 423
 424 /** \defgroup silencedet_attr SilenceDetector attributes
 425 \{
 426 */
 427
 428 /** Get the current state of tonedetection
 429 The result is a bitmap with 1s for silent channels. Left channel is in LSB
 430 */
 431 #define HPI_SILENCEDETECTOR_STATE \
 432   HPI_CTL_ATTR(SILENCEDETECTOR, 2)
 433
 434 /** Set the threshold level of a SilenceDetector,
 435 Threshold is a -ve number in units of dB/100,
 436 */
 437 #define HPI_SILENCEDETECTOR_THRESHOLD \
 438   HPI_CTL_ATTR(SILENCEDETECTOR, 1)
 439
 440 /** get/set the silence time before the detector triggers
 441 */
 442 #define HPI_SILENCEDETECTOR_DELAY \
 443        HPI_CTL_ATTR(SILENCEDETECTOR, 3)
 444
 445 /**\}*/
 446
 447 /* Locked memory buffer alloc/free phases */
 448 /** use one message to allocate or free physical memory */
 449 #define HPI_BUFFER_CMD_EXTERNAL                 0
 450 /** alloc physical memory */
 451 #define HPI_BUFFER_CMD_INTERNAL_ALLOC           1
 452 /** send physical memory address to adapter */
 453 #define HPI_BUFFER_CMD_INTERNAL_GRANTADAPTER    2
 454 /** notify adapter to stop using physical buffer */
 455 #define HPI_BUFFER_CMD_INTERNAL_REVOKEADAPTER   3
 456 /** free physical buffer */
 457 #define HPI_BUFFER_CMD_INTERNAL_FREE            4
 458
 459 /******************************************* CONTROLX ATTRIBUTES ****/
 460 /* NOTE: All controlx attributes must be unique, unlike control attributes */
 461
 462 /*****************************************************************************/
 463 /*****************************************************************************/
 464 /********               HPI LOW LEVEL MESSAGES                  *******/
 465 /*****************************************************************************/
 466 /*****************************************************************************/
 467 /** Pnp ids */
 468 /** "ASI"  - actual is "ASX" - need to change */
 469 #define HPI_ID_ISAPNP_AUDIOSCIENCE      0x0669
 470 /** PCI vendor ID that AudioScience uses */
 471 #define HPI_PCI_VENDOR_ID_AUDIOSCIENCE  0x175C
 472 /** PCI vendor ID that the DSP56301 has */
 473 #define HPI_PCI_VENDOR_ID_MOTOROLA      0x1057
 474 /** PCI vendor ID that TI uses */
 475 #define HPI_PCI_VENDOR_ID_TI            0x104C
 476
 477 #define HPI_PCI_DEV_ID_PCI2040          0xAC60
 478 /** TI's C6205 PCI interface has this ID */
 479 #define HPI_PCI_DEV_ID_DSP6205          0xA106
 480
 481 #define HPI_USB_VENDOR_ID_AUDIOSCIENCE  0x1257
 482 #define HPI_USB_W2K_TAG                 0x57495341      /* "ASIW"       */
 483 #define HPI_USB_LINUX_TAG               0x4C495341      /* "ASIL"       */
 484
 485 /** First 2 hex digits define the adapter family */
 486 #define HPI_ADAPTER_FAMILY_MASK         0xff00
 487 #define HPI_MODULE_FAMILY_MASK          0xfff0
 488
 489 #define HPI_ADAPTER_FAMILY_ASI(f)   (f & HPI_ADAPTER_FAMILY_MASK)
 490 #define HPI_MODULE_FAMILY_ASI(f)   (f & HPI_MODULE_FAMILY_MASK)
 491 #define HPI_ADAPTER_ASI(f)   (f)
 492
 493 /******************************************* message types */
 494 #define HPI_TYPE_MESSAGE                        1
 495 #define HPI_TYPE_RESPONSE                       2
 496 #define HPI_TYPE_DATA                           3
 497 #define HPI_TYPE_SSX2BYPASS_MESSAGE             4
 498
 499 /******************************************* object types */
 500 #define HPI_OBJ_SUBSYSTEM                       1
 501 #define HPI_OBJ_ADAPTER                         2
 502 #define HPI_OBJ_OSTREAM                         3
 503 #define HPI_OBJ_ISTREAM                         4
 504 #define HPI_OBJ_MIXER                           5
 505 #define HPI_OBJ_NODE                            6
 506 #define HPI_OBJ_CONTROL                         7
 507 #define HPI_OBJ_NVMEMORY                        8
 508 #define HPI_OBJ_GPIO                            9
 509 #define HPI_OBJ_WATCHDOG                        10
 510 #define HPI_OBJ_CLOCK                           11
 511 #define HPI_OBJ_PROFILE                         12
 512 #define HPI_OBJ_CONTROLEX                       13
 513 #define HPI_OBJ_ASYNCEVENT                      14
 514
 515 #define HPI_OBJ_MAXINDEX                        14
 516
 517 /******************************************* methods/functions */
 518
 519 #define HPI_OBJ_FUNCTION_SPACING        0x100
 520 #define HPI_MAKE_INDEX(obj, index) (obj * HPI_OBJ_FUNCTION_SPACING + index)
 521 #define HPI_EXTRACT_INDEX(fn) (fn & 0xff)
 522
 523 /* SUB-SYSTEM */
 524 #define HPI_SUBSYS_OPEN                 HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 1)
 525 #define HPI_SUBSYS_GET_VERSION          HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 2)
 526 #define HPI_SUBSYS_GET_INFO             HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 3)
 527 #define HPI_SUBSYS_FIND_ADAPTERS        HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 4)
 528 #define HPI_SUBSYS_CREATE_ADAPTER       HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 5)
 529 #define HPI_SUBSYS_CLOSE                HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 6)
 530 #define HPI_SUBSYS_DELETE_ADAPTER       HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 7)
 531 #define HPI_SUBSYS_DRIVER_LOAD          HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 8)
 532 #define HPI_SUBSYS_DRIVER_UNLOAD        HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 9)
 533 #define HPI_SUBSYS_READ_PORT_8          HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 10)
 534 #define HPI_SUBSYS_WRITE_PORT_8         HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 11)
 535 #define HPI_SUBSYS_GET_NUM_ADAPTERS     HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 12)
 536 #define HPI_SUBSYS_GET_ADAPTER          HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 13)
 537 #define HPI_SUBSYS_SET_NETWORK_INTERFACE HPI_MAKE_INDEX(HPI_OBJ_SUBSYSTEM, 14)
 538 #define HPI_SUBSYS_FUNCTION_COUNT 14
 539 /* ADAPTER */
 540 #define HPI_ADAPTER_OPEN                HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 1)
 541 #define HPI_ADAPTER_CLOSE               HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 2)
 542 #define HPI_ADAPTER_GET_INFO            HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 3)
 543 #define HPI_ADAPTER_GET_ASSERT          HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 4)
 544 #define HPI_ADAPTER_TEST_ASSERT         HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 5)
 545 #define HPI_ADAPTER_SET_MODE            HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 6)
 546 #define HPI_ADAPTER_GET_MODE            HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 7)
 547 #define HPI_ADAPTER_ENABLE_CAPABILITY   HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 8)
 548 #define HPI_ADAPTER_SELFTEST            HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 9)
 549 #define HPI_ADAPTER_FIND_OBJECT         HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 10)
 550 #define HPI_ADAPTER_QUERY_FLASH         HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 11)
 551 #define HPI_ADAPTER_START_FLASH         HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 12)
 552 #define HPI_ADAPTER_PROGRAM_FLASH       HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 13)
 553 #define HPI_ADAPTER_SET_PROPERTY        HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 14)
 554 #define HPI_ADAPTER_GET_PROPERTY        HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 15)
 555 #define HPI_ADAPTER_ENUM_PROPERTY       HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 16)
 556 #define HPI_ADAPTER_MODULE_INFO         HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 17)
 557 #define HPI_ADAPTER_DEBUG_READ          HPI_MAKE_INDEX(HPI_OBJ_ADAPTER, 18)
 558 #define HPI_ADAPTER_FUNCTION_COUNT 18
 559 /* OUTPUT STREAM */
 560 #define HPI_OSTREAM_OPEN                HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 1)
 561 #define HPI_OSTREAM_CLOSE               HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 2)
 562 #define HPI_OSTREAM_WRITE               HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 3)
 563 #define HPI_OSTREAM_START               HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 4)
 564 #define HPI_OSTREAM_STOP                HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 5)
 565 #define HPI_OSTREAM_RESET               HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 6)
 566 #define HPI_OSTREAM_GET_INFO            HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 7)
 567 #define HPI_OSTREAM_QUERY_FORMAT        HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 8)
 568 #define HPI_OSTREAM_DATA                HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 9)
 569 #define HPI_OSTREAM_SET_VELOCITY        HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 10)
 570 #define HPI_OSTREAM_SET_PUNCHINOUT      HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 11)
 571 #define HPI_OSTREAM_SINEGEN             HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 12)
 572 #define HPI_OSTREAM_ANC_RESET           HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 13)
 573 #define HPI_OSTREAM_ANC_GET_INFO        HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 14)
 574 #define HPI_OSTREAM_ANC_READ            HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 15)
 575 #define HPI_OSTREAM_SET_TIMESCALE       HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 16)
 576 #define HPI_OSTREAM_SET_FORMAT          HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 17)
 577 #define HPI_OSTREAM_HOSTBUFFER_ALLOC    HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 18)
 578 #define HPI_OSTREAM_HOSTBUFFER_FREE     HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 19)
 579 #define HPI_OSTREAM_GROUP_ADD           HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 20)
 580 #define HPI_OSTREAM_GROUP_GETMAP        HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 21)
 581 #define HPI_OSTREAM_GROUP_RESET         HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 22)
 582 #define HPI_OSTREAM_HOSTBUFFER_GET_INFO HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 23)
 583 #define HPI_OSTREAM_WAIT_START          HPI_MAKE_INDEX(HPI_OBJ_OSTREAM, 24)
 584 #define HPI_OSTREAM_FUNCTION_COUNT              24
 585 /* INPUT STREAM */
 586 #define HPI_ISTREAM_OPEN                HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 1)
 587 #define HPI_ISTREAM_CLOSE               HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 2)
 588 #define HPI_ISTREAM_SET_FORMAT          HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 3)
 589 #define HPI_ISTREAM_READ                HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 4)
 590 #define HPI_ISTREAM_START               HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 5)
 591 #define HPI_ISTREAM_STOP                HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 6)
 592 #define HPI_ISTREAM_RESET               HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 7)
 593 #define HPI_ISTREAM_GET_INFO            HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 8)
 594 #define HPI_ISTREAM_QUERY_FORMAT        HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 9)
 595 #define HPI_ISTREAM_ANC_RESET           HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 10)
 596 #define HPI_ISTREAM_ANC_GET_INFO        HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 11)
 597 #define HPI_ISTREAM_ANC_WRITE           HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 12)
 598 #define HPI_ISTREAM_HOSTBUFFER_ALLOC    HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 13)
 599 #define HPI_ISTREAM_HOSTBUFFER_FREE     HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 14)
 600 #define HPI_ISTREAM_GROUP_ADD           HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 15)
 601 #define HPI_ISTREAM_GROUP_GETMAP        HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 16)
 602 #define HPI_ISTREAM_GROUP_RESET         HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 17)
 603 #define HPI_ISTREAM_HOSTBUFFER_GET_INFO HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 18)
 604 #define HPI_ISTREAM_WAIT_START          HPI_MAKE_INDEX(HPI_OBJ_ISTREAM, 19)
 605 #define HPI_ISTREAM_FUNCTION_COUNT              19
 606 /* MIXER */
 607 /* NOTE:
 608    GET_NODE_INFO, SET_CONNECTION, GET_CONNECTIONS are not currently used */
 609 #define HPI_MIXER_OPEN                  HPI_MAKE_INDEX(HPI_OBJ_MIXER, 1)
 610 #define HPI_MIXER_CLOSE                 HPI_MAKE_INDEX(HPI_OBJ_MIXER, 2)
 611 #define HPI_MIXER_GET_INFO              HPI_MAKE_INDEX(HPI_OBJ_MIXER, 3)
 612 #define HPI_MIXER_GET_NODE_INFO         HPI_MAKE_INDEX(HPI_OBJ_MIXER, 4)
 613 #define HPI_MIXER_GET_CONTROL           HPI_MAKE_INDEX(HPI_OBJ_MIXER, 5)
 614 #define HPI_MIXER_SET_CONNECTION        HPI_MAKE_INDEX(HPI_OBJ_MIXER, 6)
 615 #define HPI_MIXER_GET_CONNECTIONS       HPI_MAKE_INDEX(HPI_OBJ_MIXER, 7)
 616 #define HPI_MIXER_GET_CONTROL_BY_INDEX  HPI_MAKE_INDEX(HPI_OBJ_MIXER, 8)
 617 #define HPI_MIXER_GET_CONTROL_ARRAY_BY_INDEX  HPI_MAKE_INDEX(HPI_OBJ_MIXER, 9)
 618 #define HPI_MIXER_GET_CONTROL_MULTIPLE_VALUES HPI_MAKE_INDEX(HPI_OBJ_MIXER, 10)
 619 #define HPI_MIXER_STORE                 HPI_MAKE_INDEX(HPI_OBJ_MIXER, 11)
 620 #define HPI_MIXER_FUNCTION_COUNT        11
 621 /* MIXER CONTROLS */
 622 #define HPI_CONTROL_GET_INFO            HPI_MAKE_INDEX(HPI_OBJ_CONTROL, 1)
 623 #define HPI_CONTROL_GET_STATE           HPI_MAKE_INDEX(HPI_OBJ_CONTROL, 2)
 624 #define HPI_CONTROL_SET_STATE           HPI_MAKE_INDEX(HPI_OBJ_CONTROL, 3)
 625 #define HPI_CONTROL_FUNCTION_COUNT 3
 626 /* NONVOL MEMORY */
 627 #define HPI_NVMEMORY_OPEN               HPI_MAKE_INDEX(HPI_OBJ_NVMEMORY, 1)
 628 #define HPI_NVMEMORY_READ_BYTE          HPI_MAKE_INDEX(HPI_OBJ_NVMEMORY, 2)
 629 #define HPI_NVMEMORY_WRITE_BYTE         HPI_MAKE_INDEX(HPI_OBJ_NVMEMORY, 3)
 630 #define HPI_NVMEMORY_FUNCTION_COUNT 3
 631 /* GPIO */
 632 #define HPI_GPIO_OPEN                   HPI_MAKE_INDEX(HPI_OBJ_GPIO, 1)
 633 #define HPI_GPIO_READ_BIT               HPI_MAKE_INDEX(HPI_OBJ_GPIO, 2)
 634 #define HPI_GPIO_WRITE_BIT              HPI_MAKE_INDEX(HPI_OBJ_GPIO, 3)
 635 #define HPI_GPIO_READ_ALL               HPI_MAKE_INDEX(HPI_OBJ_GPIO, 4)
 636 #define HPI_GPIO_WRITE_STATUS           HPI_MAKE_INDEX(HPI_OBJ_GPIO, 5)
 637 #define HPI_GPIO_FUNCTION_COUNT 5
 638 /* ASYNC EVENT */
 639 #define HPI_ASYNCEVENT_OPEN             HPI_MAKE_INDEX(HPI_OBJ_ASYNCEVENT, 1)
 640 #define HPI_ASYNCEVENT_CLOSE            HPI_MAKE_INDEX(HPI_OBJ_ASYNCEVENT, 2)
 641 #define HPI_ASYNCEVENT_WAIT             HPI_MAKE_INDEX(HPI_OBJ_ASYNCEVENT, 3)
 642 #define HPI_ASYNCEVENT_GETCOUNT         HPI_MAKE_INDEX(HPI_OBJ_ASYNCEVENT, 4)
 643 #define HPI_ASYNCEVENT_GET              HPI_MAKE_INDEX(HPI_OBJ_ASYNCEVENT, 5)
 644 #define HPI_ASYNCEVENT_SENDEVENTS       HPI_MAKE_INDEX(HPI_OBJ_ASYNCEVENT, 6)
 645 #define HPI_ASYNCEVENT_FUNCTION_COUNT 6
 646 /* WATCH-DOG */
 647 #define HPI_WATCHDOG_OPEN               HPI_MAKE_INDEX(HPI_OBJ_WATCHDOG, 1)
 648 #define HPI_WATCHDOG_SET_TIME           HPI_MAKE_INDEX(HPI_OBJ_WATCHDOG, 2)
 649 #define HPI_WATCHDOG_PING               HPI_MAKE_INDEX(HPI_OBJ_WATCHDOG, 3)
 650 /* CLOCK */
 651 #define HPI_CLOCK_OPEN                  HPI_MAKE_INDEX(HPI_OBJ_CLOCK, 1)
 652 #define HPI_CLOCK_SET_TIME              HPI_MAKE_INDEX(HPI_OBJ_CLOCK, 2)
 653 #define HPI_CLOCK_GET_TIME              HPI_MAKE_INDEX(HPI_OBJ_CLOCK, 3)
 654 /* PROFILE */
 655 #define HPI_PROFILE_OPEN_ALL            HPI_MAKE_INDEX(HPI_OBJ_PROFILE, 1)
 656 #define HPI_PROFILE_START_ALL           HPI_MAKE_INDEX(HPI_OBJ_PROFILE, 2)
 657 #define HPI_PROFILE_STOP_ALL            HPI_MAKE_INDEX(HPI_OBJ_PROFILE, 3)
 658 #define HPI_PROFILE_GET                 HPI_MAKE_INDEX(HPI_OBJ_PROFILE, 4)
 659 #define HPI_PROFILE_GET_IDLECOUNT       HPI_MAKE_INDEX(HPI_OBJ_PROFILE, 5)
 660 #define HPI_PROFILE_GET_NAME            HPI_MAKE_INDEX(HPI_OBJ_PROFILE, 6)
 661 #define HPI_PROFILE_GET_UTILIZATION     HPI_MAKE_INDEX(HPI_OBJ_PROFILE, 7)
 662 #define HPI_PROFILE_FUNCTION_COUNT 7
 663 /* ////////////////////////////////////////////////////////////////////// */
 664 /* PRIVATE ATTRIBUTES */
 665
 666 /* ////////////////////////////////////////////////////////////////////// */
 667 /* STRUCTURES */
 668 #ifndef DISABLE_PRAGMA_PACK1
 669 #pragma pack(push, 1)
 670 #endif
 671
 672 /** PCI bus resource */
 673 struct hpi_pci {
 674         u32 __iomem *ap_mem_base[HPI_MAX_ADAPTER_MEM_SPACES];
 675         struct pci_dev *p_os_data;
 676
 677 #ifndef HPI64BIT                /* keep structure size constant */
 678         u32 padding[HPI_MAX_ADAPTER_MEM_SPACES + 1];
 679 #endif
 680         u16 vendor_id;
 681         u16 device_id;
 682         u16 subsys_vendor_id;
 683         u16 subsys_device_id;
 684         u16 bus_number;
 685         u16 device_number;
 686         u32 interrupt;
 687 };
 688
 689 struct hpi_resource {
 690         union {
 691                 const struct hpi_pci *pci;
 692                 const char *net_if;
 693         } r;
 694 #ifndef HPI64BIT                /* keep structure size constant */
 695         u32 pad_to64;
 696 #endif
 697         u16 bus_type;           /* HPI_BUS_PNPISA, _PCI, _USB etc */
 698         u16 padding;
 699
 700 };
 701
 702 /** Format info used inside struct hpi_message
 703     Not the same as public API struct hpi_format */
 704 struct hpi_msg_format {
 705         u32 sample_rate;
 706                                 /**< 11025, 32000, 44100 ... */
 707         u32 bit_rate;         /**< for MPEG */
 708         u32 attributes;
 709                                 /**< Stereo/JointStereo/Mono */
 710         u16 channels;         /**< 1,2..., (or ancillary mode or idle bit */
 711         u16 format; /**< HPI_FORMAT_PCM16, _MPEG etc. see \ref HPI_FORMATS. */
 712 };
 713
 714 /**  Buffer+format structure.
 715          Must be kept 7 * 32 bits to match public struct hpi_datastruct */
 716 struct hpi_msg_data {
 717         struct hpi_msg_format format;
 718         u8 *pb_data;
 719 #ifndef HPI64BIT
 720         u32 padding;
 721 #endif
 722         u32 data_size;
 723 };
 724
 725 /** struct hpi_datastructure used up to 3.04 driver */
 726 struct hpi_data_legacy32 {
 727         struct hpi_format format;
 728         u32 pb_data;
 729         u32 data_size;
 730 };
 731
 732 #ifdef HPI64BIT
 733 /* Compatibility version of struct hpi_data*/
 734 struct hpi_data_compat32 {
 735         struct hpi_msg_format format;
 736         u32 pb_data;
 737         u32 padding;
 738         u32 data_size;
 739 };
 740 #endif
 741
 742 struct hpi_buffer {
 743   /** placehoder for backward compatability (see dwBufferSize) */
 744         struct hpi_msg_format reserved;
 745         u32 command;    /**< HPI_BUFFER_CMD_xxx*/
 746         u32 pci_address; /**< PCI physical address of buffer for DSP DMA */
 747         u32 buffer_size; /**< must line up with data_size of HPI_DATA*/
 748 };
 749
 750 /*/////////////////////////////////////////////////////////////////////////// */
 751 /* This is used for background buffer bus mastering stream buffers.           */
 752 struct hpi_hostbuffer_status {
 753         u32 samples_processed;
 754         u32 auxiliary_data_available;
 755         u32 stream_state;
 756         /* DSP index in to the host bus master buffer. */
 757         u32 dSP_index;
 758         /* Host index in to the host bus master buffer. */
 759         u32 host_index;
 760         u32 size_in_bytes;
 761 };
 762
 763 struct hpi_streamid {
 764         u16 object_type;
 765                     /**< Type of object, HPI_OBJ_OSTREAM or HPI_OBJ_ISTREAM. */
 766         u16 stream_index; /**< outstream or instream index. */
 767 };
 768
 769 struct hpi_punchinout {
 770         u32 punch_in_sample;
 771         u32 punch_out_sample;
 772 };
 773
 774 struct hpi_subsys_msg {
 775         struct hpi_resource resource;
 776 };
 777
 778 struct hpi_subsys_res {
 779         u32 version;
 780         u32 data;               /* used to return extended version */
 781         u16 num_adapters;       /* number of adapters */
 782         u16 adapter_index;
 783         u16 aw_adapter_list[HPI_MAX_ADAPTERS];
 784 };
 785
 786 struct hpi_adapter_msg {
 787         u32 adapter_mode;       /* adapter mode */
 788         u16 assert_id;          /* assert number for "test assert" call
 789                                    object_index for find object call
 790                                    query_or_set for hpi_adapter_set_mode_ex() */
 791         u16 object_type;        /* for adapter find object call */
 792 };
 793
 794 union hpi_adapterx_msg {
 795         struct hpi_adapter_msg adapter;
 796         struct {
 797                 u32 offset;
 798         } query_flash;
 799         struct {
 800                 u32 offset;
 801                 u32 length;
 802                 u32 key;
 803         } start_flash;
 804         struct {
 805                 u32 checksum;
 806                 u16 sequence;
 807                 u16 length;
 808                 u16 offset; /**< offset from start of msg to data */
 809                 u16 unused;
 810         } program_flash;
 811         struct {
 812                 u16 property;
 813                 u16 parameter1;
 814                 u16 parameter2;
 815         } property_set;
 816         struct {
 817                 u16 index;
 818                 u16 what;
 819                 u16 property_index;
 820         } property_enum;
 821         struct {
 822                 u16 index;
 823         } module_info;
 824         struct {
 825                 u32 dsp_address;
 826                 u32 count_bytes;
 827         } debug_read;
 828 };
 829
 830 struct hpi_adapter_res {
 831         u32 serial_number;
 832         u16 adapter_type;
 833         u16 adapter_index;      /* is this needed? also used for dsp_index */
 834         u16 num_instreams;
 835         u16 num_outstreams;
 836         u16 num_mixers;
 837         u16 version;
 838         u8 sz_adapter_assert[HPI_STRING_LEN];
 839 };
 840
 841 union hpi_adapterx_res {
 842         struct hpi_adapter_res adapter;
 843         struct {
 844                 u32 checksum;
 845                 u32 length;
 846                 u32 version;
 847         } query_flash;
 848         struct {
 849                 u16 sequence;
 850         } program_flash;
 851         struct {
 852                 u16 parameter1;
 853                 u16 parameter2;
 854         } property_get;
 855 };
 856
 857 struct hpi_stream_msg {
 858         union {
 859                 struct hpi_msg_data data;
 860                 struct hpi_data_legacy32 data32;
 861                 u16 velocity;
 862                 struct hpi_punchinout pio;
 863                 u32 time_scale;
 864                 struct hpi_buffer buffer;
 865                 struct hpi_streamid stream;
 866         } u;
 867 };
 868
 869 struct hpi_stream_res {
 870         union {
 871                 struct {
 872                         /* size of hardware buffer */
 873                         u32 buffer_size;
 874                         /* OutStream - data to play,
 875                            InStream - data recorded */
 876                         u32 data_available;
 877                         /* OutStream - samples played,
 878                            InStream - samples recorded */
 879                         u32 samples_transferred;
 880                         /* Adapter - OutStream - data to play,
 881                            InStream - data recorded */
 882                         u32 auxiliary_data_available;
 883                         u16 state;      /* HPI_STATE_PLAYING, _STATE_STOPPED */
 884                         u16 padding;
 885                 } stream_info;
 886                 struct {
 887                         u32 buffer_size;
 888                         u32 data_available;
 889                         u32 samples_transfered;
 890                         u16 state;
 891                         u16 outstream_index;
 892                         u16 instream_index;
 893                         u16 padding;
 894                         u32 auxiliary_data_available;
 895                 } legacy_stream_info;
 896                 struct {
 897                         /* bitmap of grouped OutStreams */
 898                         u32 outstream_group_map;
 899                         /* bitmap of grouped InStreams */
 900                         u32 instream_group_map;
 901                 } group_info;
 902                 struct {
 903                         /* pointer to the buffer */
 904                         u8 *p_buffer;
 905                         /* pointer to the hostbuffer status */
 906                         struct hpi_hostbuffer_status *p_status;
 907                 } hostbuffer_info;
 908         } u;
 909 };
 910
 911 struct hpi_mixer_msg {
 912         u16 control_index;
 913         u16 control_type;       /* = HPI_CONTROL_METER _VOLUME etc */
 914         u16 padding1;           /* maintain alignment of subsequent fields */
 915         u16 node_type1;         /* = HPI_SOURCENODE_LINEIN etc */
 916         u16 node_index1;        /* = 0..N */
 917         u16 node_type2;
 918         u16 node_index2;
 919         u16 padding2;           /* round to 4 bytes */
 920 };
 921
 922 struct hpi_mixer_res {
 923         u16 src_node_type;      /* = HPI_SOURCENODE_LINEIN etc */
 924         u16 src_node_index;     /* = 0..N */
 925         u16 dst_node_type;
 926         u16 dst_node_index;
 927         /* Also controlType for MixerGetControlByIndex */
 928         u16 control_index;
 929         /* may indicate which DSP the control is located on */
 930         u16 dsp_index;
 931 };
 932
 933 union hpi_mixerx_msg {
 934         struct {
 935                 u16 starting_index;
 936                 u16 flags;
 937                 u32 length_in_bytes;    /* length in bytes of p_data */
 938                 u32 p_data;     /* pointer to a data array */
 939         } gcabi;
 940         struct {
 941                 u16 command;
 942                 u16 index;
 943         } store;                /* for HPI_MIXER_STORE message */
 944 };
 945
 946 union hpi_mixerx_res {
 947         struct {
 948                 u32 bytes_returned;     /* size of items returned */
 949                 u32 p_data;     /* pointer to data array */
 950                 u16 more_to_do; /* indicates if there is more to do */
 951         } gcabi;
 952 };
 953
 954 struct hpi_control_msg {
 955         u16 attribute;          /* control attribute or property */
 956         u16 saved_index;
 957         u32 param1;             /* generic parameter 1 */
 958         u32 param2;             /* generic parameter 2 */
 959         short an_log_value[HPI_MAX_CHANNELS];
 960 };
 961
 962 struct hpi_control_union_msg {
 963         u16 attribute;          /* control attribute or property */
 964         u16 saved_index;        /* only used in ctrl save/restore */
 965         union {
 966                 struct {
 967                         u32 param1;     /* generic parameter 1 */
 968                         u32 param2;     /* generic parameter 2 */
 969                         short an_log_value[HPI_MAX_CHANNELS];
 970                 } old;
 971                 union {
 972                         u32 frequency;
 973                         u32 gain;
 974                         u32 band;
 975                         u32 deemphasis;
 976                         u32 program;
 977                         struct {
 978                                 u32 mode;
 979                                 u32 value;
 980                         } mode;
 981                         u32 blend;
 982                 } tuner;
 983         } u;
 984 };
 985
 986 struct hpi_control_res {
 987         /* Could make union. dwParam, anLogValue never used in same response */
 988         u32 param1;
 989         u32 param2;
 990         short an_log_value[HPI_MAX_CHANNELS];
 991 };
 992
 993 union hpi_control_union_res {
 994         struct {
 995                 u32 param1;
 996                 u32 param2;
 997                 short an_log_value[HPI_MAX_CHANNELS];
 998         } old;
 999         union {
1000                 u32 band;
1001                 u32 frequency;
1002                 u32 gain;
1003                 u32 level;
1004                 u32 deemphasis;
1005                 struct {
1006                         u32 data[2];
1007                         u32 bLER;
1008                 } rds;
1009         } tuner;
1010         struct {
1011                 char sz_data[8];
1012                 u32 remaining_chars;
1013         } chars8;
1014         char c_data12[12];
1015 };
1016
1017 /* HPI_CONTROLX_STRUCTURES */
1018
1019 /* Message */
1020
1021 /** Used for all HMI variables where max length <= 8 bytes
1022 */
1023 struct hpi_controlx_msg_cobranet_data {
1024         u32 hmi_address;
1025         u32 byte_count;
1026         u32 data[2];
1027 };
1028
1029 /** Used for string data, and for packet bridge
1030 */
1031 struct hpi_controlx_msg_cobranet_bigdata {
1032         u32 hmi_address;
1033         u32 byte_count;
1034         u8 *pb_data;
1035 #ifndef HPI64BIT
1036         u32 padding;
1037 #endif
1038 };
1039
1040 /** Used for PADS control reading of string fields.
1041 */
1042 struct hpi_controlx_msg_pad_data {
1043         u32 field;
1044         u32 byte_count;
1045         u8 *pb_data;
1046 #ifndef HPI64BIT
1047         u32 padding;
1048 #endif
1049 };
1050
1051 /** Used for generic data
1052 */
1053
1054 struct hpi_controlx_msg_generic {
1055         u32 param1;
1056         u32 param2;
1057 };
1058
1059 struct hpi_controlx_msg {
1060         u16 attribute;          /* control attribute or property */
1061         u16 saved_index;
1062         union {
1063                 struct hpi_controlx_msg_cobranet_data cobranet_data;
1064                 struct hpi_controlx_msg_cobranet_bigdata cobranet_bigdata;
1065                 struct hpi_controlx_msg_generic generic;
1066                 struct hpi_controlx_msg_pad_data pad_data;
1067                 /*struct param_value universal_value; */
1068                 /* nothing extra to send for status read */
1069         } u;
1070 };
1071
1072 /* Response */
1073 /**
1074 */
1075 struct hpi_controlx_res_cobranet_data {
1076         u32 byte_count;
1077         u32 data[2];
1078 };
1079
1080 struct hpi_controlx_res_cobranet_bigdata {
1081         u32 byte_count;
1082 };
1083
1084 struct hpi_controlx_res_cobranet_status {
1085         u32 status;
1086         u32 readable_size;
1087         u32 writeable_size;
1088 };
1089
1090 struct hpi_controlx_res_generic {
1091         u32 param1;
1092         u32 param2;
1093 };
1094
1095 struct hpi_controlx_res {
1096         union {
1097                 struct hpi_controlx_res_cobranet_bigdata cobranet_bigdata;
1098                 struct hpi_controlx_res_cobranet_data cobranet_data;
1099                 struct hpi_controlx_res_cobranet_status cobranet_status;
1100                 struct hpi_controlx_res_generic generic;
1101                 /*struct param_info universal_info; */
1102                 /*struct param_value universal_value; */
1103         } u;
1104 };
1105
1106 struct hpi_nvmemory_msg {
1107         u16 address;
1108         u16 data;
1109 };
1110
1111 struct hpi_nvmemory_res {
1112         u16 size_in_bytes;
1113         u16 data;
1114 };
1115
1116 struct hpi_gpio_msg {
1117         u16 bit_index;
1118         u16 bit_data;
1119 };
1120
1121 struct hpi_gpio_res {
1122         u16 number_input_bits;
1123         u16 number_output_bits;
1124         u16 bit_data[4];
1125 };
1126
1127 struct hpi_async_msg {
1128         u32 events;
1129         u16 maximum_events;
1130         u16 padding;
1131 };
1132
1133 struct hpi_async_res {
1134         union {
1135                 struct {
1136                         u16 count;
1137                 } count;
1138                 struct {
1139                         u32 events;
1140                         u16 number_returned;
1141                         u16 padding;
1142                 } get;
1143                 struct hpi_async_event event;
1144         } u;
1145 };
1146
1147 struct hpi_watchdog_msg {
1148         u32 time_ms;
1149 };
1150
1151 struct hpi_watchdog_res {
1152         u32 time_ms;
1153 };
1154
1155 struct hpi_clock_msg {
1156         u16 hours;
1157         u16 minutes;
1158         u16 seconds;
1159         u16 milli_seconds;
1160 };
1161
1162 struct hpi_clock_res {
1163         u16 size_in_bytes;
1164         u16 hours;
1165         u16 minutes;
1166         u16 seconds;
1167         u16 milli_seconds;
1168         u16 padding;
1169 };
1170
1171 struct hpi_profile_msg {
1172         u16 bin_index;
1173         u16 padding;
1174 };
1175
1176 struct hpi_profile_res_open {
1177         u16 max_profiles;
1178 };
1179
1180 struct hpi_profile_res_time {
1181         u32 micro_seconds;
1182         u32 call_count;
1183         u32 max_micro_seconds;
1184         u32 min_micro_seconds;
1185         u16 seconds;
1186 };
1187
1188 struct hpi_profile_res_name {
1189         u8 sz_name[32];
1190 };
1191
1192 struct hpi_profile_res {
1193         union {
1194                 struct hpi_profile_res_open o;
1195                 struct hpi_profile_res_time t;
1196                 struct hpi_profile_res_name n;
1197         } u;
1198 };
1199
1200 struct hpi_message_header {
1201         u16 size;               /* total size in bytes */
1202         u8 type;                /* HPI_TYPE_MESSAGE  */
1203         u8 version;             /* message version */
1204         u16 object;             /* HPI_OBJ_* */
1205         u16 function;           /* HPI_SUBSYS_xxx, HPI_ADAPTER_xxx */
1206         u16 adapter_index;      /* the adapter index */
1207         u16 obj_index;          /* */
1208 };
1209
1210 struct hpi_message {
1211         /* following fields must match HPI_MESSAGE_HEADER */
1212         u16 size;               /* total size in bytes */
1213         u8 type;                /* HPI_TYPE_MESSAGE  */
1214         u8 version;             /* message version */
1215         u16 object;             /* HPI_OBJ_* */
1216         u16 function;           /* HPI_SUBSYS_xxx, HPI_ADAPTER_xxx */
1217         u16 adapter_index;      /* the adapter index */
1218         u16 obj_index;          /*  */
1219         union {
1220                 struct hpi_subsys_msg s;
1221                 struct hpi_adapter_msg a;
1222                 union hpi_adapterx_msg ax;
1223                 struct hpi_stream_msg d;
1224                 struct hpi_mixer_msg m;
1225                 union hpi_mixerx_msg mx;        /* extended mixer; */
1226                 struct hpi_control_msg c;       /* mixer control; */
1227                 /* identical to struct hpi_control_msg,
1228                    but field naming is improved */
1229                 struct hpi_control_union_msg cu;
1230                 struct hpi_controlx_msg cx;     /* extended mixer control; */
1231                 struct hpi_nvmemory_msg n;
1232                 struct hpi_gpio_msg l;  /* digital i/o */
1233                 struct hpi_watchdog_msg w;
1234                 struct hpi_clock_msg t; /* dsp time */
1235                 struct hpi_profile_msg p;
1236                 struct hpi_async_msg as;
1237                 char fixed_size[32];
1238         } u;
1239 };
1240
1241 #define HPI_MESSAGE_SIZE_BY_OBJECT { \
1242         sizeof(struct hpi_message_header) ,   /* default, no object type 0 */ \
1243         sizeof(struct hpi_message_header) + sizeof(struct hpi_subsys_msg),\
1244         sizeof(struct hpi_message_header) + sizeof(union hpi_adapterx_msg),\
1245         sizeof(struct hpi_message_header) + sizeof(struct hpi_stream_msg),\
1246         sizeof(struct hpi_message_header) + sizeof(struct hpi_stream_msg),\
1247         sizeof(struct hpi_message_header) + sizeof(struct hpi_mixer_msg),\
1248         sizeof(struct hpi_message_header) ,   /* no node message */ \
1249         sizeof(struct hpi_message_header) + sizeof(struct hpi_control_msg),\
1250         sizeof(struct hpi_message_header) + sizeof(struct hpi_nvmemory_msg),\
1251         sizeof(struct hpi_message_header) + sizeof(struct hpi_gpio_msg),\
1252         sizeof(struct hpi_message_header) + sizeof(struct hpi_watchdog_msg),\
1253         sizeof(struct hpi_message_header) + sizeof(struct hpi_clock_msg),\
1254         sizeof(struct hpi_message_header) + sizeof(struct hpi_profile_msg),\
1255         sizeof(struct hpi_message_header) + sizeof(struct hpi_controlx_msg),\
1256         sizeof(struct hpi_message_header) + sizeof(struct hpi_async_msg) \
1257 }
1258
1259 struct hpi_response_header {
1260         u16 size;
1261         u8 type;                /* HPI_TYPE_RESPONSE  */
1262         u8 version;             /* response version */
1263         u16 object;             /* HPI_OBJ_* */
1264         u16 function;           /* HPI_SUBSYS_xxx, HPI_ADAPTER_xxx */
1265         u16 error;              /* HPI_ERROR_xxx */
1266         u16 specific_error;     /* adapter specific error */
1267 };
1268
1269 struct hpi_response {
1270 /* following fields must match HPI_RESPONSE_HEADER */
1271         u16 size;
1272         u8 type;                /* HPI_TYPE_RESPONSE  */
1273         u8 version;             /* response version */
1274         u16 object;             /* HPI_OBJ_* */
1275         u16 function;           /* HPI_SUBSYS_xxx, HPI_ADAPTER_xxx */
1276         u16 error;              /* HPI_ERROR_xxx */
1277         u16 specific_error;     /* adapter specific error */
1278         union {
1279                 struct hpi_subsys_res s;
1280                 struct hpi_adapter_res a;
1281                 union hpi_adapterx_res ax;
1282                 struct hpi_stream_res d;
1283                 struct hpi_mixer_res m;
1284                 union hpi_mixerx_res mx;        /* extended mixer; */
1285                 struct hpi_control_res c;       /* mixer control; */
1286                 /* identical to hpi_control_res, but field naming is improved */
1287                 union hpi_control_union_res cu;
1288                 struct hpi_controlx_res cx;     /* extended mixer control; */
1289                 struct hpi_nvmemory_res n;
1290                 struct hpi_gpio_res l;  /* digital i/o */
1291                 struct hpi_watchdog_res w;
1292                 struct hpi_clock_res t; /* dsp time */
1293                 struct hpi_profile_res p;
1294                 struct hpi_async_res as;
1295                 u8 bytes[52];
1296         } u;
1297 };
1298
1299 #define HPI_RESPONSE_SIZE_BY_OBJECT { \
1300         sizeof(struct hpi_response_header) ,/* default, no object type 0 */ \
1301         sizeof(struct hpi_response_header) + sizeof(struct hpi_subsys_res),\
1302         sizeof(struct hpi_response_header) + sizeof(union  hpi_adapterx_res),\
1303         sizeof(struct hpi_response_header) + sizeof(struct hpi_stream_res),\
1304         sizeof(struct hpi_response_header) + sizeof(struct hpi_stream_res),\
1305         sizeof(struct hpi_response_header) + sizeof(struct hpi_mixer_res),\
1306         sizeof(struct hpi_response_header) , /* no node response */ \
1307         sizeof(struct hpi_response_header) + sizeof(struct hpi_control_res),\
1308         sizeof(struct hpi_response_header) + sizeof(struct hpi_nvmemory_res),\
1309         sizeof(struct hpi_response_header) + sizeof(struct hpi_gpio_res),\
1310         sizeof(struct hpi_response_header) + sizeof(struct hpi_watchdog_res),\
1311         sizeof(struct hpi_response_header) + sizeof(struct hpi_clock_res),\
1312         sizeof(struct hpi_response_header) + sizeof(struct hpi_profile_res),\
1313         sizeof(struct hpi_response_header) + sizeof(struct hpi_controlx_res),\
1314         sizeof(struct hpi_response_header) + sizeof(struct hpi_async_res) \
1315 }
1316
1317 /*********************** version 1 message/response *****************************/
1318 #define HPINET_ETHERNET_DATA_SIZE (1500)
1319 #define HPINET_IP_HDR_SIZE (20)
1320 #define HPINET_IP_DATA_SIZE (HPINET_ETHERNET_DATA_SIZE - HPINET_IP_HDR_SIZE)
1321 #define HPINET_UDP_HDR_SIZE (8)
1322 #define HPINET_UDP_DATA_SIZE (HPINET_IP_DATA_SIZE - HPINET_UDP_HDR_SIZE)
1323 #define HPINET_ASI_HDR_SIZE (2)
1324 #define HPINET_ASI_DATA_SIZE (HPINET_UDP_DATA_SIZE - HPINET_ASI_HDR_SIZE)
1325
1326 #define HPI_MAX_PAYLOAD_SIZE (HPINET_ASI_DATA_SIZE - 2)
1327
1328 /* New style message/response, but still V0 compatible */
1329 struct hpi_msg_adapter_get_info {
1330         struct hpi_message_header h;
1331 };
1332
1333 struct hpi_res_adapter_get_info {
1334         struct hpi_response_header h;   /*v0 */
1335         struct hpi_adapter_res p;
1336 };
1337
1338 /* padding is so these are same size as v0 hpi_message */
1339 struct hpi_msg_adapter_query_flash {
1340         struct hpi_message_header h;
1341         u32 offset;
1342         u8 pad_to_version0_size[sizeof(struct hpi_message) -    /* V0 res */
1343                 sizeof(struct hpi_message_header) - 1 * sizeof(u32)];
1344 };
1345
1346 /* padding is so these are same size as v0 hpi_response */
1347 struct hpi_res_adapter_query_flash {
1348         struct hpi_response_header h;
1349         u32 checksum;
1350         u32 length;
1351         u32 version;
1352         u8 pad_to_version0_size[sizeof(struct hpi_response) -   /* V0 res */
1353                 sizeof(struct hpi_response_header) - 3 * sizeof(u32)];
1354 };
1355
1356 struct hpi_msg_adapter_start_flash {
1357         struct hpi_message_header h;
1358         u32 offset;
1359         u32 length;
1360         u32 key;
1361         u8 pad_to_version0_size[sizeof(struct hpi_message) -    /* V0 res */
1362                 sizeof(struct hpi_message_header) - 3 * sizeof(u32)];
1363 };
1364
1365 struct hpi_res_adapter_start_flash {
1366         struct hpi_response_header h;
1367         u8 pad_to_version0_size[sizeof(struct hpi_response) -   /* V0 res */
1368                 sizeof(struct hpi_response_header)];
1369 };
1370
1371 struct hpi_msg_adapter_program_flash_payload {
1372         u32 checksum;
1373         u16 sequence;
1374         u16 length;
1375         u16 offset; /**< offset from start of msg to data */
1376         u16 unused;
1377         /* ensure sizeof(header + payload) == sizeof(hpi_message_V0)
1378            because old firmware expects data after message of this size */
1379         u8 pad_to_version0_size[sizeof(struct hpi_message) -    /* V0 message */
1380                 sizeof(struct hpi_message_header) - sizeof(u32) -
1381                 4 * sizeof(u16)];
1382 };
1383
1384 struct hpi_msg_adapter_program_flash {
1385         struct hpi_message_header h;
1386         struct hpi_msg_adapter_program_flash_payload p;
1387         u32 data[256];
1388 };
1389
1390 struct hpi_res_adapter_program_flash {
1391         struct hpi_response_header h;
1392         u16 sequence;
1393         u8 pad_to_version0_size[sizeof(struct hpi_response) -   /* V0 res */
1394                 sizeof(struct hpi_response_header) - sizeof(u16)];
1395 };
1396
1397 #if 1
1398 #define hpi_message_header_v1 hpi_message_header
1399 #define hpi_response_header_v1 hpi_response_header
1400 #else
1401 /* V1 headers in Addition to v0 headers */
1402 struct hpi_message_header_v1 {
1403         struct hpi_message_header h0;
1404 /* struct {
1405 } h1; */
1406 };
1407
1408 struct hpi_response_header_v1 {
1409         struct hpi_response_header h0;
1410         struct {
1411                 u16 adapter_index;      /* the adapter index */
1412                 u16 obj_index;  /* object index */
1413         } h1;
1414 };
1415 #endif
1416
1417 /* STRV HPI Packet */
1418 struct hpi_msg_strv {
1419         struct hpi_message_header h;
1420         struct hpi_entity strv;
1421 };
1422
1423 struct hpi_res_strv {
1424         struct hpi_response_header h;
1425         struct hpi_entity strv;
1426 };
1427 #define MIN_STRV_PACKET_SIZE sizeof(struct hpi_res_strv)
1428
1429 struct hpi_msg_payload_v0 {
1430         struct hpi_message_header h;
1431         union {
1432                 struct hpi_subsys_msg s;
1433                 struct hpi_adapter_msg a;
1434                 union hpi_adapterx_msg ax;
1435                 struct hpi_stream_msg d;
1436                 struct hpi_mixer_msg m;
1437                 union hpi_mixerx_msg mx;
1438                 struct hpi_control_msg c;
1439                 struct hpi_control_union_msg cu;
1440                 struct hpi_controlx_msg cx;
1441                 struct hpi_nvmemory_msg n;
1442                 struct hpi_gpio_msg l;
1443                 struct hpi_watchdog_msg w;
1444                 struct hpi_clock_msg t;
1445                 struct hpi_profile_msg p;
1446                 struct hpi_async_msg as;
1447         } u;
1448 };
1449
1450 struct hpi_res_payload_v0 {
1451         struct hpi_response_header h;
1452         union {
1453                 struct hpi_subsys_res s;
1454                 struct hpi_adapter_res a;
1455                 union hpi_adapterx_res ax;
1456                 struct hpi_stream_res d;
1457                 struct hpi_mixer_res m;
1458                 union hpi_mixerx_res mx;
1459                 struct hpi_control_res c;
1460                 union hpi_control_union_res cu;
1461                 struct hpi_controlx_res cx;
1462                 struct hpi_nvmemory_res n;
1463                 struct hpi_gpio_res l;
1464                 struct hpi_watchdog_res w;
1465                 struct hpi_clock_res t;
1466                 struct hpi_profile_res p;
1467                 struct hpi_async_res as;
1468         } u;
1469 };
1470
1471 union hpi_message_buffer_v1 {
1472         struct hpi_message m0;  /* version 0 */
1473         struct hpi_message_header_v1 h;
1474         unsigned char buf[HPI_MAX_PAYLOAD_SIZE];
1475 };
1476
1477 union hpi_response_buffer_v1 {
1478         struct hpi_response r0; /* version 0 */
1479         struct hpi_response_header_v1 h;
1480         unsigned char buf[HPI_MAX_PAYLOAD_SIZE];
1481 };
1482
1483 compile_time_assert((sizeof(union hpi_message_buffer_v1) <=
1484                 HPI_MAX_PAYLOAD_SIZE), message_buffer_ok);
1485 compile_time_assert((sizeof(union hpi_response_buffer_v1) <=
1486                 HPI_MAX_PAYLOAD_SIZE), response_buffer_ok);
1487
1488 /*////////////////////////////////////////////////////////////////////////// */
1489 /* declarations for compact control calls  */
1490 struct hpi_control_defn {
1491         u8 type;
1492         u8 channels;
1493         u8 src_node_type;
1494         u8 src_node_index;
1495         u8 dest_node_type;
1496         u8 dest_node_index;
1497 };
1498
1499 /*////////////////////////////////////////////////////////////////////////// */
1500 /* declarations for control caching (internal to HPI<->DSP interaction)      */
1501
1502 /** A compact representation of (part of) a controls state.
1503 Used for efficient transfer of the control state
1504 between DSP and host or across a network
1505 */
1506 struct hpi_control_cache_info {
1507         /** one of HPI_CONTROL_* */
1508         u8 control_type;
1509         /** The total size of cached information in 32-bit words. */
1510         u8 size_in32bit_words;
1511         /** The original index of the control on the DSP */
1512         u16 control_index;
1513 };
1514
1515 struct hpi_control_cache_single {
1516         struct hpi_control_cache_info i;
1517         union {
1518                 struct {        /* volume */
1519                         short an_log[2];
1520                 } v;
1521                 struct {        /* peak meter */
1522                         short an_log_peak[2];
1523                         short an_logRMS[2];
1524                 } p;
1525                 struct {        /* channel mode */
1526                         u16 mode;
1527                 } m;
1528                 struct {        /* multiplexer */
1529                         u16 source_node_type;
1530                         u16 source_node_index;
1531                 } x;
1532                 struct {        /* level/trim */
1533                         short an_log[2];
1534                 } l;
1535                 struct {        /* tuner - partial caching.
1536                                    some attributes go to the DSP. */
1537                         u32 freq_ink_hz;
1538                         u16 band;
1539                         u16 level;
1540                 } t;
1541                 struct {        /* AESEBU rx status */
1542                         u32 error_status;
1543                         u32 source;
1544                 } aes3rx;
1545                 struct {        /* AESEBU tx */
1546                         u32 format;
1547                 } aes3tx;
1548                 struct {        /* tone detector */
1549                         u16 state;
1550                 } tone;
1551                 struct {        /* silence detector */
1552                         u32 state;
1553                         u32 count;
1554                 } silence;
1555                 struct {        /* sample clock */
1556                         u16 source;
1557                         u16 source_index;
1558                         u32 sample_rate;
1559                 } clk;
1560                 struct {        /* microphone control */
1561                         u16 state;
1562                 } phantom_power;
1563                 struct {        /* generic control */
1564                         u32 dw1;
1565                         u32 dw2;
1566                 } g;
1567         } u;
1568 };
1569
1570 struct hpi_control_cache_pad {
1571         struct hpi_control_cache_info i;
1572         u32 field_valid_flags;
1573         u8 c_channel[8];
1574         u8 c_artist[40];
1575         u8 c_title[40];
1576         u8 c_comment[200];
1577         u32 pTY;
1578         u32 pI;
1579         u32 traffic_supported;
1580         u32 traffic_anouncement;
1581 };
1582
1583 /*/////////////////////////////////////////////////////////////////////////// */
1584 /* declarations for 2^N sized FIFO buffer (internal to HPI<->DSP interaction) */
1585 struct hpi_fifo_buffer {
1586         u32 size;
1587         u32 dSP_index;
1588         u32 host_index;
1589 };
1590
1591 #ifndef DISABLE_PRAGMA_PACK1
1592 #pragma pack(pop)
1593 #endif
1594
1595 /* skip host side function declarations for DSP
1596    compile and documentation extraction */
1597
1598 char hpi_handle_object(const u32 handle);
1599
1600 void hpi_handle_to_indexes(const u32 handle, u16 *pw_adapter_index,
1601         u16 *pw_object_index);
1602
1603 u32 hpi_indexes_to_handle(const char c_object, const u16 adapter_index,
1604         const u16 object_index);
1605
1606 /*////////////////////////////////////////////////////////////////////////// */
1607
1608 /* main HPI entry point */
1609 hpi_handler_func hpi_send_recv;
1610
1611 /* UDP message */
1612 void hpi_send_recvUDP(struct hpi_message *phm, struct hpi_response *phr,
1613         const unsigned int timeout);
1614
1615 /* used in PnP OS/driver */
1616 u16 hpi_subsys_create_adapter(const struct hpi_hsubsys *ph_subsys,
1617         const struct hpi_resource *p_resource, u16 *pw_adapter_index);
1618
1619 u16 hpi_subsys_delete_adapter(const struct hpi_hsubsys *ph_subsys,
1620         u16 adapter_index);
1621
1622 u16 hpi_outstream_host_buffer_get_info(const struct hpi_hsubsys *ph_subsys,
1623         u32 h_outstream, u8 **pp_buffer,
1624         struct hpi_hostbuffer_status **pp_status);
1625
1626 u16 hpi_instream_host_buffer_get_info(const struct hpi_hsubsys *ph_subsys,
1627         u32 h_instream, u8 **pp_buffer,
1628         struct hpi_hostbuffer_status **pp_status);
1629
1630 u16 hpi_adapter_restart(u16 adapter_index);
1631
1632 /*
1633 The following 3 functions were last declared in header files for
1634 driver 3.10. HPI_ControlQuery() used to be the recommended way
1635 of getting a volume range. Declared here for binary asihpi32.dll
1636 compatibility.
1637 */
1638
1639 void hpi_format_to_msg(struct hpi_msg_format *pMF,
1640         const struct hpi_format *pF);
1641 void hpi_stream_response_to_legacy(struct hpi_stream_res *pSR);
1642
1643 /*////////////////////////////////////////////////////////////////////////// */
1644 /* declarations for individual HPI entry points */
1645 hpi_handler_func HPI_1000;
1646 hpi_handler_func HPI_6000;
1647 hpi_handler_func HPI_6205;
1648 hpi_handler_func HPI_COMMON;
1649
1650 #endif                          /* _HPI_INTERNAL_H_ */