release/src-rt-6.x.4708/linux/linux-2.6.36/sound/pci/asihpi/hpimsginit.c

   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  Hardware Programming Interface (HPI) Utility functions.
  20
  21  (C) Copyright AudioScience Inc. 2007
  22 *******************************************************************************/
  23
  24 #include "hpi_internal.h"
  25 #include "hpimsginit.h"
  26
  27 /* The actual message size for each object type */
  28 static u16 msg_size[HPI_OBJ_MAXINDEX + 1] = HPI_MESSAGE_SIZE_BY_OBJECT;
  29 /* The actual response size for each object type */
  30 static u16 res_size[HPI_OBJ_MAXINDEX + 1] = HPI_RESPONSE_SIZE_BY_OBJECT;
  31 /* Flag to enable alternate message type for SSX2 bypass. */
  32 static u16 gwSSX2_bypass;
  33
  34 /** \internal
  35   * Used by ASIO driver to disable SSX2 for a single process
  36   * \param phSubSys Pointer to HPI subsystem handle.
  37   * \param wBypass New bypass setting 0 = off, nonzero = on
  38   * \return Previous bypass setting.
  39   */
  40 u16 hpi_subsys_ssx2_bypass(const struct hpi_hsubsys *ph_subsys, u16 bypass)
  41 {
  42         u16 old_value = gwSSX2_bypass;
  43
  44         gwSSX2_bypass = bypass;
  45
  46         return old_value;
  47 }
  48
  49 /** \internal
  50   * initialize the HPI message structure
  51   */
  52 static void hpi_init_message(struct hpi_message *phm, u16 object,
  53         u16 function)
  54 {
  55         memset(phm, 0, sizeof(*phm));
  56         if ((object > 0) && (object <= HPI_OBJ_MAXINDEX))
  57                 phm->size = msg_size[object];
  58         else
  59                 phm->size = sizeof(*phm);
  60
  61         if (gwSSX2_bypass)
  62                 phm->type = HPI_TYPE_SSX2BYPASS_MESSAGE;
  63         else
  64                 phm->type = HPI_TYPE_MESSAGE;
  65         phm->object = object;
  66         phm->function = function;
  67         phm->version = 0;
  68         /* Expect adapter index to be set by caller */
  69 }
  70
  71 /** \internal
  72   * initialize the HPI response structure
  73   */
  74 void hpi_init_response(struct hpi_response *phr, u16 object, u16 function,
  75         u16 error)
  76 {
  77         memset(phr, 0, sizeof(*phr));
  78         phr->type = HPI_TYPE_RESPONSE;
  79         if ((object > 0) && (object <= HPI_OBJ_MAXINDEX))
  80                 phr->size = res_size[object];
  81         else
  82                 phr->size = sizeof(*phr);
  83         phr->object = object;
  84         phr->function = function;
  85         phr->error = error;
  86         phr->specific_error = 0;
  87         phr->version = 0;
  88 }
  89
  90 void hpi_init_message_response(struct hpi_message *phm,
  91         struct hpi_response *phr, u16 object, u16 function)
  92 {
  93         hpi_init_message(phm, object, function);
  94         /* default error return if the response is
  95            not filled in by the callee */
  96         hpi_init_response(phr, object, function,
  97                 HPI_ERROR_PROCESSING_MESSAGE);
  98 }
  99
 100 static void hpi_init_messageV1(struct hpi_message_header *phm, u16 size,
 101         u16 object, u16 function)
 102 {
 103         memset(phm, 0, sizeof(*phm));
 104         if ((object > 0) && (object <= HPI_OBJ_MAXINDEX)) {
 105                 phm->size = size;
 106                 phm->type = HPI_TYPE_MESSAGE;
 107                 phm->object = object;
 108                 phm->function = function;
 109                 phm->version = 1;
 110                 /* Expect adapter index to be set by caller */
 111         }
 112 }
 113
 114 void hpi_init_responseV1(struct hpi_response_header *phr, u16 size,
 115         u16 object, u16 function)
 116 {
 117         memset(phr, 0, sizeof(*phr));
 118         phr->size = size;
 119         phr->version = 1;
 120         phr->type = HPI_TYPE_RESPONSE;
 121         phr->error = HPI_ERROR_PROCESSING_MESSAGE;
 122 }
 123
 124 void hpi_init_message_responseV1(struct hpi_message_header *phm, u16 msg_size,
 125         struct hpi_response_header *phr, u16 res_size, u16 object,
 126         u16 function)
 127 {
 128         hpi_init_messageV1(phm, msg_size, object, function);
 129         hpi_init_responseV1(phr, res_size, object, function);
 130 }