sound/soc/codecs/mc1n2/mcdevif.c

   1 /****************************************************************************
   2  *
   3  *              Copyright(c) 2010 Yamaha Corporation. All rights reserved.
   4  *
   5  *              Module          : mcdevif.c
   6  *
   7  *              Description     : MC Driver device interface
   8  *
   9  *              Version         : 1.0.0         2010.09.10
  10  *
  11  ****************************************************************************/
  12
  13
  14 #include "mcdevif.h"
  15 #include "mcservice.h"
  16 #include "mcresctrl.h"
  17 #include "mcmachdep.h"
  18 #if MCDRV_DEBUG_LEVEL
  19 #include "mcdebuglog.h"
  20 #endif
  21
  22
  23
  24 static MCDRV_PACKET*    gpsPacket       = NULL;
  25
  26 /****************************************************************************
  27  *      McDevIf_AllocPacketBuf
  28  *
  29  *      Description:
  30  *                      allocate the buffer for register setting packets.
  31  *      Arguments:
  32  *                      none
  33  *      Return:
  34  *                      MCDRV_SUCCESS
  35  *                      MCDRV_ERROR
  36  *
  37  ****************************************************************************/
  38 SINT32  McDevIf_AllocPacketBuf
  39 (
  40         void
  41 )
  42 {
  43         SINT32  sdRet   = MCDRV_SUCCESS;
  44
  45 #if (MCDRV_DEBUG_LEVEL>=4)
  46         McDebugLog_FuncIn("McDevIf_AllocPacketBuf");
  47 #endif
  48
  49         gpsPacket       = McResCtrl_AllocPacketBuf();
  50         if(gpsPacket == NULL)
  51         {
  52                 sdRet   = MCDRV_ERROR;
  53         }
  54         else
  55         {
  56                 McDevIf_ClearPacket();
  57         }
  58
  59 #if (MCDRV_DEBUG_LEVEL>=4)
  60         McDebugLog_FuncOut("McDevIf_AllocPacketBuf", &sdRet);
  61 #endif
  62
  63         return sdRet;
  64 }
  65
  66 /****************************************************************************
  67  *      McDevIf_ReleasePacketBuf
  68  *
  69  *      Description:
  70  *                      Release the buffer for register setting packets.
  71  *      Arguments:
  72  *                      none
  73  *      Return:
  74  *                      none
  75  *
  76  ****************************************************************************/
  77 void    McDevIf_ReleasePacketBuf
  78 (
  79         void
  80 )
  81 {
  82 #if (MCDRV_DEBUG_LEVEL>=4)
  83         McDebugLog_FuncIn("McDevIf_ReleasePacketBuf");
  84 #endif
  85
  86         McResCtrl_ReleasePacketBuf();
  87
  88 #if (MCDRV_DEBUG_LEVEL>=4)
  89         McDebugLog_FuncOut("McDevIf_ReleasePacketBuf", 0);
  90 #endif
  91 }
  92
  93 /****************************************************************************
  94  *      McDevIf_ClearPacket
  95  *
  96  *      Description:
  97  *                      Clear packets.
  98  *      Arguments:
  99  *                      none
 100  *      Return:
 101  *                      none
 102  *
 103  ****************************************************************************/
 104 void    McDevIf_ClearPacket
 105 (
 106         void
 107 )
 108 {
 109 #if (MCDRV_DEBUG_LEVEL>=4)
 110         SINT32  sdRet;
 111         McDebugLog_FuncIn("McDevIf_ClearPacket");
 112 #endif
 113
 114         if(gpsPacket == NULL)
 115         {
 116                 #if (MCDRV_DEBUG_LEVEL>=4)
 117                         sdRet   = MCDRV_ERROR;
 118                         McDebugLog_FuncOut("McDevIf_ClearPacket", &sdRet);
 119                 #endif
 120                 return;
 121         }
 122
 123         gpsPacket[0].dDesc = MCDRV_PACKET_TYPE_TERMINATE;
 124
 125 #if (MCDRV_DEBUG_LEVEL>=4)
 126         McDebugLog_FuncOut("McDevIf_ClearPacket", 0);
 127 #endif
 128 }
 129
 130 /****************************************************************************
 131  *      McDevIf_AddPacket
 132  *
 133  *      Description:
 134  *                      Add a packet.
 135  *      Arguments:
 136  *                      dDesc           packet info
 137  *                      bData           packet data
 138  *      Return:
 139  *                      none
 140  *
 141  ****************************************************************************/
 142 void    McDevIf_AddPacket
 143 (
 144         UINT32                  dDesc,
 145         UINT8                   bData
 146 )
 147 {
 148         UINT32  i;
 149
 150 #if (MCDRV_DEBUG_LEVEL>=4)
 151         McDebugLog_FuncIn("McDevIf_AddPacket");
 152 #endif
 153
 154         if(gpsPacket == NULL)
 155         {
 156         }
 157         else
 158         {
 159                 for(i = 0; i < MCDRV_MAX_PACKETS; i++)
 160                 {
 161                         if(gpsPacket[i].dDesc == MCDRV_PACKET_TYPE_TERMINATE)
 162                         {
 163                                 break;
 164                         }
 165                 }
 166                 if(i >= MCDRV_MAX_PACKETS)
 167                 {
 168                         McDevIf_ExecutePacket();
 169                         i       = 0;
 170                 }
 171
 172                 gpsPacket[i].dDesc              = dDesc;
 173                 gpsPacket[i].bData              = bData;
 174                 gpsPacket[i+1UL].dDesc  = MCDRV_PACKET_TYPE_TERMINATE;
 175         }
 176
 177 #if (MCDRV_DEBUG_LEVEL>=4)
 178         McDebugLog_FuncOut("McDevIf_AddPacket", 0);
 179 #endif
 180 }
 181
 182 /****************************************************************************
 183  *      McDevIf_AddPacketRepeat
 184  *
 185  *      Description:
 186  *                      Add packets to set data at same register over agian.
 187  *      Arguments:
 188  *                      dDesc                   packet info
 189  *                      pbData                  poointer to packet data
 190  *                      wDataCount              packet data count
 191  *      Return:
 192  *                      none
 193  *
 194  ****************************************************************************/
 195 void    McDevIf_AddPacketRepeat
 196 (
 197         UINT32                  dDesc,
 198         const UINT8*    pbData,
 199         UINT16                  wDataCount
 200 )
 201 {
 202         UINT16  wCount;
 203
 204 #if (MCDRV_DEBUG_LEVEL>=4)
 205         McDebugLog_FuncIn("McDevIf_AddPacketRepeat");
 206 #endif
 207
 208         for(wCount = 0; wCount < wDataCount; wCount++)
 209         {
 210                 McDevIf_AddPacket(dDesc, pbData[wCount]);
 211         }
 212
 213 #if (MCDRV_DEBUG_LEVEL>=4)
 214         McDebugLog_FuncOut("McDevIf_AddPacketRepeat", 0);
 215 #endif
 216 }
 217
 218 /****************************************************************************
 219  *      McDevIf_ExecutePacket
 220  *
 221  *      Description:
 222  *                      Execute sequence for register setting.
 223  *      Arguments:
 224  *                      none
 225  *      Return:
 226  *                      MCDRV_SUCCESS
 227  *                      MCDRV_ERROR_ARGUMENT
 228  *
 229  ****************************************************************************/
 230 SINT32  McDevIf_ExecutePacket
 231 (
 232         void
 233 )
 234 {
 235         SINT32  sdRet;
 236         SINT16  swPacketIndex;
 237         UINT32  dPacketType;
 238         UINT32  dParam1;
 239         UINT32  dParam2;
 240         UINT16  wAddress;
 241         UINT16  wRegType;
 242         MCDRV_UPDATE_MODE       eUpdateMode;
 243
 244 #if (MCDRV_DEBUG_LEVEL>=4)
 245         McDebugLog_FuncIn("McDevIf_ExecutePacket");
 246 #endif
 247
 248         if(gpsPacket == NULL)
 249         {
 250                 sdRet   = MCDRV_ERROR_RESOURCEOVER;
 251         }
 252         else
 253         {
 254                 sdRet   = MCDRV_SUCCESS;
 255
 256                 McResCtrl_InitRegUpdate();
 257                 swPacketIndex = 0;
 258                 while ((MCDRV_PACKET_TYPE_TERMINATE != (gpsPacket[swPacketIndex].dDesc & MCDRV_PACKET_TYPE_MASK)) && (sdRet == MCDRV_SUCCESS))
 259                 {
 260                         dPacketType = gpsPacket[swPacketIndex].dDesc & MCDRV_PACKET_TYPE_MASK;
 261                         switch (dPacketType)
 262                         {
 263                         case MCDRV_PACKET_TYPE_WRITE:
 264                         case MCDRV_PACKET_TYPE_FORCE_WRITE:
 265                                 wRegType = (UINT16)(gpsPacket[swPacketIndex].dDesc & MCDRV_PACKET_REGTYPE_MASK);
 266                                 wAddress = (UINT16)(gpsPacket[swPacketIndex].dDesc & MCDRV_PACKET_ADR_MASK);
 267                                 if (MCDRV_PACKET_TYPE_WRITE == dPacketType)
 268                                 {
 269                                         eUpdateMode = eMCDRV_UPDATE_NORMAL;
 270                                 }
 271                                 else if (MCDRV_PACKET_TYPE_FORCE_WRITE == dPacketType)
 272                                 {
 273                                         eUpdateMode = eMCDRV_UPDATE_FORCE;
 274                                 }
 275                                 else
 276                                 {
 277                                         eUpdateMode = eMCDRV_UPDATE_DUMMY;
 278                                 }
 279                                 McResCtrl_AddRegUpdate(wRegType, wAddress, gpsPacket[swPacketIndex].bData, eUpdateMode);
 280                                 break;
 281
 282                         case MCDRV_PACKET_TYPE_TIMWAIT:
 283                                 McResCtrl_ExecuteRegUpdate();
 284                                 McResCtrl_InitRegUpdate();
 285                                 dParam1 = gpsPacket[swPacketIndex].dDesc & MCDRV_PACKET_TIME_MASK;
 286                                 McSrv_Sleep(dParam1);
 287                                 break;
 288
 289                         case MCDRV_PACKET_TYPE_EVTWAIT:
 290                                 McResCtrl_ExecuteRegUpdate();
 291                                 McResCtrl_InitRegUpdate();
 292                                 dParam1 = gpsPacket[swPacketIndex].dDesc & MCDRV_PACKET_EVT_MASK;
 293                                 dParam2 = gpsPacket[swPacketIndex].dDesc & MCDRV_PACKET_EVTPRM_MASK;
 294                                 sdRet = McResCtrl_WaitEvent(dParam1, dParam2);
 295                                 break;
 296
 297                         default:
 298                                 sdRet   = MCDRV_ERROR;
 299                                 break;
 300                         }
 301
 302                         swPacketIndex++;
 303                 }
 304                 if(sdRet == MCDRV_SUCCESS)
 305                 {
 306                         McResCtrl_ExecuteRegUpdate();
 307                 }
 308                 McDevIf_ClearPacket();
 309         }
 310
 311 #if (MCDRV_DEBUG_LEVEL>=4)
 312         McDebugLog_FuncOut("McDevIf_ExecutePacket", &sdRet);
 313 #endif
 314
 315         return sdRet;
 316 }
 317