packages/ti/drv/dfe/src/dfelld/DFE_dduc.c

   1 /********************************************************************
   2  * Copyright (C) 2013 Texas Instruments Incorporated.
   3  *
   4  *  Redistribution and use in source and binary forms, with or without
   5  *  modification, are permitted provided that the following conditions
   6  *  are met:
   7  *
   8  *    Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *
  11  *    Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  *    Neither the name of Texas Instruments Incorporated nor the names of
  17  *    its contributors may be used to endorse or promote products derived
  18  *    from this software without specific prior written permission.
  19  *
  20  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32 */
  33 #include <ti/drv/dfe/dfe_drv.h>
  34 #include <ti/drv/dfe/dfe_osal.h>
  35 #include <ti/drv/dfe/dfe_internal.h>
  36
  37 /**
  38  * @defgroup DFE_LLD_DDUC_FUNCTION DDUC
  39  * @ingroup DFE_LLD_FUNCTION
  40  */
  41
  42 /**
  43  * @brief Program DDUC Mixer NCO Frequency
  44  * @ingroup DFE_LLD_DDUC_FUNCTION
  45  *
  46  * Write new DDUC Mixer NCO to shadow memory, this is only in the static frequency mode. The precision of the frequency is refClock/2^48.
  47  * NOTE, Dfe_issueSyncUpdateDducMixerNCO () should be called later to let hardware copy gains from shadow to working memory.
  48  *
  49  *  @param hDfe [in] DFE device handle
  50  *  @param dducDev      [in] Dduc Id, 0 ~ 3
  51  *  @param refClock     [in] reference sample rate
  52  *  @param freq [in] array of frequency value
  53  *
  54  * @return
  55  *  - #DFE_ERR_NONE, if API complete properly
  56  *  - #DFE_ERR_INVALID_HANDLE, if hDfe is NULL
  57  *  - #DFE_ERR_HW_CTRL, if CSL HwControl() failed
  58  *
  59  * @pre
  60  *  - hDfe should be a valid handle opened by Dfe_open().
  61  *  - DFE PLL and PSCs shall be already up running.
  62  *  - DFE has loaded target config and completed initialize sequence.
  63  *  - Dfe_issueSyncUpdateDducMixerNCO () should be called later to copy gains to working memory.
  64  *
  65  * @post
  66  * - None.
  67  *
  68  * @b Example
  69  *   @verbatim
  70          [to be documented]
  71      @endverbatim
  72  */
  73 DFE_Err Dfe_progDducMixerNCO
  74 (
  75     DFE_Handle hDfe,
  76         uint32_t dducDev,
  77         float refClock,
  78     float freq[12]
  79 )
  80 {
  81         DfeFl_Status status;
  82         uint32_t SyncDelay, cic_ndata, carriers_num;
  83         uint32_t i, ichan, rchan, idx;
  84         int64_t numi64, deni64;
  85         uint64_t freq_eng[12];
  86         double numdbl, dendbl, temp, temp1;
  87         DfeFl_DducCicCfg DducCicCfg;
  88         DfeFl_DducHopFrqwordConfig DducMixFreq;
  89
  90         if(hDfe == NULL)
  91         {
  92                 Dfe_osalLog("hDfe is NULL!");
  93                 return DFE_ERR_INVALID_HANDLE;
  94         }
  95
  96         if(dducDev > 3)
  97         {
  98                 Dfe_osalLog("Invalid parameter dducDev!");
  99                 return DFE_ERR_INVALID_PARAMS;
 100         }
 101
 102         // need to read/write sync_delay (0x12BC) to make sure NCO frequency been updated.
 103         CSL_HW_QUERY( dfeFl_DducGetHwStatus(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_QUERY_SYNC_DELAY, &SyncDelay) );
 104         if(SyncDelay == 0)
 105         {
 106                 Dfe_osalLog("Unsupport: sync delay is zero!");
 107                 return DFE_ERR_DDUC_MIXER_NCO;
 108
 109         }
 110
 111         // need to check cic_ndata (0x126C) to load properly for multiple carriers
 112         CSL_HW_QUERY( dfeFl_DducGetHwStatus(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_QUERY_CIC_CONFIG, &DducCicCfg) );
 113
 114         cic_ndata = (DducCicCfg.cic_ndata+1)>>1;
 115         carriers_num = 12;
 116
 117         if((cic_ndata != 1) && (cic_ndata != 2) && (cic_ndata != 4))
 118         {
 119                 Dfe_osalLog("Invalid cic_ndata!");
 120                 return DFE_ERR_DDUC_MIXER_NCO;
 121         }
 122         else if(carriers_num > cic_ndata*3)
 123         {
 124 //              Dfe_osalLog("Only the first %d freq is used due to limited CIC!", cic_ndata*3);
 125                 carriers_num = cic_ndata*3;
 126         }
 127
 128         // frequency conversion
 129         // freq (in decimal) = 2^48 x Tuning Frequency / Fclk
 130         for(i = 0; i < carriers_num; i++)
 131         {
 132                 numi64 = freq[i]*1000000;
 133                 deni64 = refClock*1000000;
 134                 numdbl = numi64;
 135                 dendbl = deni64;
 136                 temp = numdbl/dendbl;
 137                 temp1 = (temp<0)?temp+1:temp;
 138                 temp1 *= 281474976710656.0;
 139                 freq_eng[i] = temp1 + 0.5;
 140         }
 141
 142         // change mix freq
 143         for(i = 0; i < 12; i++)
 144         {
 145                 DducMixFreq.frqWord[i].low = 0;
 146                 DducMixFreq.frqWord[i].mid = 0;
 147                 DducMixFreq.frqWord[i].high = 0;
 148         }
 149
 150         if(cic_ndata == 1)
 151         {
 152                 // only 3*1 = 3 channels
 153                 for(i = 0; i < carriers_num; i++)
 154                 {
 155                         idx = i*4;
 156                         DducMixFreq.frqWord[idx].low = FREQLOW(freq_eng[i]);
 157                         DducMixFreq.frqWord[idx].mid = FREQMID(freq_eng[i]);
 158                         DducMixFreq.frqWord[idx].high = FREQHIGH(freq_eng[i]);
 159                 }
 160         }
 161         else if(cic_ndata == 2)
 162         {
 163                 // only 3*2 = 6 channels
 164                 for(i = 0; i < carriers_num; i++)
 165                 {
 166                         ichan = i>>1;
 167                         rchan = i-ichan*2;
 168                         idx = ichan*4+1-rchan;
 169                         DducMixFreq.frqWord[idx].low = FREQLOW(freq_eng[i]);
 170                         DducMixFreq.frqWord[idx].mid = FREQMID(freq_eng[i]);
 171                         DducMixFreq.frqWord[idx].high = FREQHIGH(freq_eng[i]);
 172                 }
 173         }
 174         else if(cic_ndata == 4)
 175         {
 176                 // only 3*4 = 12 channels
 177                 for(i = 0; i < carriers_num; i++)
 178                 {
 179                         ichan = i>>2;
 180                         rchan = i-ichan*4;
 181                         idx = ichan*4+3-rchan;
 182                         DducMixFreq.frqWord[idx].low = FREQLOW(freq_eng[i]);
 183                         DducMixFreq.frqWord[idx].mid = FREQMID(freq_eng[i]);
 184                         DducMixFreq.frqWord[idx].high = FREQHIGH(freq_eng[i]);
 185                 }
 186         }
 187
 188         CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_CFG_HOP_FRQWORD, &DducMixFreq) );
 189
 190
 191         return DFE_ERR_NONE;
 192 }
 193
 194 /**
 195  * @brief Issue Sync Update DDUC Mixer NCO Frequency
 196  * @ingroup DFE_LLD_DDUC_FUNCTION
 197  *
 198  * Issue sync to copy DDUC Mixer NCO frequency from shadow to working memory. Dfe_getSyncStatus() should be called later to check if the sync has come.
 199  *
 200  *  @param hDfe [in] DFE device handle
 201  *  @param dducDev      [in] Dduc Id, 0 ~ 3
 202  *  @param ssel [in] sync select to copy gains from shadow to working memory.
 203  *
 204  * @return
 205  *  - #DFE_ERR_NONE, if API complete properly
 206  *  - #DFE_ERR_INVALID_HANDLE, if hDfe is NULL
 207  *  - #DFE_ERR_HW_CTRL, if CSL HwControl() failed
 208  *
 209  * @pre
 210  *  - hDfe should be a valid handle opened by Dfe_open().
 211  *  - DFE PLL and PSCs shall be already up running.
 212  *  - DFE has loaded target config and completed initialize sequence.
 213  *
 214  * @post
 215  * - None.
 216  *
 217  * @b Example
 218  *   @verbatim
 219          [to be documented]
 220      @endverbatim
 221  */
 222 DFE_Err Dfe_issueSyncUpdateDducMixerNCO
 223 (
 224     DFE_Handle hDfe,
 225     uint32_t dducDev,
 226     DfeFl_MiscSyncGenSig ssel
 227 )
 228 {
 229         DfeFl_Status status;
 230         DfeFl_DducMixNcoSsel DducMixNcoSsel;
 231
 232     if(hDfe == NULL)
 233     {
 234         Dfe_osalLog("hDfe is NULL!");
 235         return DFE_ERR_INVALID_HANDLE;
 236     }
 237
 238         if(dducDev > 3)
 239         {
 240                 Dfe_osalLog("Invalid parameter dducDev!");
 241                 return DFE_ERR_INVALID_PARAMS;
 242         }
 243
 244         // set sync
 245         DducMixNcoSsel.iMix = DFE_FL_DDUC_MIX_NCO_ALL;
 246         DducMixNcoSsel.data = ssel;
 247         CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_SET_MIX_NCO_SSEL, &DducMixNcoSsel) );
 248
 249         CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_SET_HOP_SSEL, &ssel) );
 250
 251         // issue sync
 252         return Dfe_issueSync(hDfe, ssel, DFE_FL_MISC_SYNC_NOWAIT);
 253
 254 }
 255
 256 /**
 257  * @brief Program DDUC Mixer Phase
 258  * @ingroup DFE_LLD_DDUC_FUNCTION
 259  *
 260  * Write new DDUC Mixer phase to shadow memory. The precision for the phase is 360/65536 degree.
 261  * NOTE, Dfe_issueSyncUpdateDducMixerPhase () should be called later to let hardware copy gains from shadow to working memory.
 262  *
 263  *  @param hDfe [in] DFE device handle
 264  *  @param dducDev      [in] Dduc Id, 0 ~ 3
 265  *  @param phase        [in] array of new phase, in degree
 266  *
 267  * @return
 268  *  - #DFE_ERR_NONE, if API complete properly
 269  *  - #DFE_ERR_INVALID_HANDLE, if hDfe is NULL
 270  *  - #DFE_ERR_HW_CTRL, if CSL HwControl() failed
 271  *
 272  * @pre
 273  *  - hDfe should be a valid handle opened by Dfe_open().
 274  *  - DFE PLL and PSCs shall be already up running.
 275  *  - DFE has loaded target config and completed initialize sequence.
 276  *  - Dfe_issueSyncUpdateDducMixerPhase () should be called later to copy gains to working memory.
 277  *
 278  * @post
 279  * - None.
 280  *
 281  * @b Example
 282  *   @verbatim
 283          [to be documented]
 284      @endverbatim
 285  */
 286 DFE_Err Dfe_progDducMixerPhase
 287 (
 288     DFE_Handle hDfe,
 289     uint32_t  dducDev,
 290     float  phase[12]
 291 )
 292 {
 293         DfeFl_Status status;
 294         DfeFl_DducMixNcoPhase DducMixPhase;
 295         uint32_t i, temp;
 296
 297         if(hDfe == NULL)
 298     {
 299         Dfe_osalLog("hDfe is NULL!");
 300         return DFE_ERR_INVALID_HANDLE;
 301     }
 302
 303         if(dducDev > 3)
 304         {
 305                 Dfe_osalLog("Invalid parameter dducDev!");
 306                 return DFE_ERR_INVALID_PARAMS;
 307         }
 308
 309         // phase equals 360 degrees * value/65536
 310         for(i = 0; i < 12; i++)
 311         {
 312                 DducMixPhase.iMix = (DfeFl_DducMixNco) i;
 313                 temp = phase[i]/360.0*65536;
 314                 DducMixPhase.data = temp&0xFFFF;
 315                 CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_SET_MIX_PHASE, &DducMixPhase) );
 316         }
 317
 318         return DFE_ERR_NONE;
 319 }
 320
 321 /**
 322  * @brief Issue Sync Update DDUC Mixer Phase
 323  * @ingroup DFE_LLD_DDUC_FUNCTION
 324  *
 325  * Issue sync to copy DDUC Mixer phase from shadow to working memory. Dfe_getSyncStatus() should be called later to check if the sync has come.
 326  *
 327  *  @param hDfe [in] DFE device handle
 328  *  @param dducDev      [in] Dduc Id, 0 ~ 3
 329  *  @param ssel [in] sync select to copy gains from shadow to working memory.
 330  *
 331  * @return
 332  *  - #DFE_ERR_NONE, if API complete properly
 333  *  - #DFE_ERR_INVALID_HANDLE, if hDfe is NULL
 334  *  - #DFE_ERR_HW_CTRL, if CSL HwControl() failed
 335  *
 336  * @pre
 337  *  - hDfe should be a valid handle opened by Dfe_open().
 338  *  - DFE PLL and PSCs shall be already up running.
 339  *  - DFE has loaded target config and completed initialize sequence.
 340  *
 341  * @post
 342  * - None.
 343  *
 344  * @b Example
 345  *   @verbatim
 346          [to be documented]
 347      @endverbatim
 348  */
 349 DFE_Err Dfe_issueSyncUpdateDducMixerPhase
 350 (
 351     DFE_Handle hDfe,
 352     uint32_t dducDev,
 353     DfeFl_MiscSyncGenSig ssel
 354 )
 355 {
 356         DfeFl_Status status;
 357
 358         if(hDfe == NULL)
 359     {
 360         Dfe_osalLog("hDfe is NULL!");
 361         return DFE_ERR_INVALID_HANDLE;
 362     }
 363
 364         if(dducDev > 3)
 365         {
 366                 Dfe_osalLog("Invalid parameter dducDev!");
 367                 return DFE_ERR_INVALID_PARAMS;
 368         }
 369
 370         // set sync
 371         CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_SET_MIX_PHASE_SSEL, &ssel) );
 372
 373         // issue sync
 374         return Dfe_issueSync(hDfe, ssel, DFE_FL_MISC_SYNC_NOWAIT);
 375 }
 376
 377 /**
 378  * @brief Program DDUC Farrow Phase
 379  * @ingroup DFE_LLD_DDUC_FUNCTION
 380  *
 381  * Write new DDUC Farrow phase to shadow memory. The fifo is from 0 ~ 63. The phase range is -0.5 ~ 0.5.
 382  * NOTE, Dfe_issueSyncUpdateDducFarrowPhase () should be called later to let hardware copy gains from shadow to working memory.
 383  *
 384  *  @param hDfe [in] DFE device handle
 385  *  @param dducDev      [in] Dduc Id, 0 ~ 3
 386  *  @param fifo [in] array of fifo
 387  *  @param phase        [in] array of new phase
 388  *
 389  * @return
 390  *  - #DFE_ERR_NONE, if API complete properly
 391  *  - #DFE_ERR_INVALID_HANDLE, if hDfe is NULL
 392  *  - #DFE_ERR_HW_CTRL, if CSL HwControl() failed
 393  *
 394  * @pre
 395  *  - hDfe should be a valid handle opened by Dfe_open().
 396  *  - DFE PLL and PSCs shall be already up running.
 397  *  - DFE has loaded target config and completed initialize sequence.
 398  *  - Dfe_issueSyncUpdateDducFarrowPhase () should be called later to copy gains to working memory.
 399  *
 400  * @post
 401  * - None.
 402  *
 403  * @b Example
 404  *   @verbatim
 405          [to be documented]
 406      @endverbatim
 407  */
 408 DFE_Err Dfe_progDducFarrowPhase
 409 (
 410     DFE_Handle hDfe,
 411     uint32_t  dducDev,
 412     uint32_t fifo[12],
 413     float  phase[12]
 414 )
 415 {
 416         DfeFl_Status status;
 417         DfeFl_DducFrwPhaseConfig DducFrwPhase;
 418         float temp;
 419         uint32_t i, phase_fp;
 420
 421         if(hDfe == NULL)
 422     {
 423         Dfe_osalLog("hDfe is NULL!");
 424         return DFE_ERR_INVALID_HANDLE;
 425     }
 426
 427         if(dducDev > 3)
 428         {
 429                 Dfe_osalLog("Invalid parameter dducDev!");
 430                 return DFE_ERR_INVALID_PARAMS;
 431         }
 432
 433         // change phase
 434         for(i = 0; i < 12; i++)
 435         {
 436                 temp = phase[i]*1048576.0;
 437                 phase_fp = temp;
 438
 439                 DducFrwPhase.phase[i] = (fifo[i]&0x3F)<<20+(phase_fp&0xFFFFF);
 440                 CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_CFG_FRW_PHASE, &DducFrwPhase) );
 441         }
 442
 443         return DFE_ERR_NONE;
 444
 445 }
 446
 447 /**
 448  * @brief Issue Sync Update DDUC Farrow Phase
 449  * @ingroup DFE_LLD_DDUC_FUNCTION
 450  *
 451  * Issue sync to copy DDUC farrow phase from shadow to working memory. Dfe_getSyncStatus() should be called later to check if the sync has come.
 452  *
 453  *  @param hDfe [in] DFE device handle
 454  *  @param dducDev      [in] Dduc Id, 0 ~ 3
 455  *  @param ssel [in] sync select to copy gains from shadow to working memory.
 456  *
 457  * @return
 458  *  - #DFE_ERR_NONE, if API complete properly
 459  *  - #DFE_ERR_INVALID_HANDLE, if hDfe is NULL
 460  *  - #DFE_ERR_HW_CTRL, if CSL HwControl() failed
 461  *
 462  * @pre
 463  *  - hDfe should be a valid handle opened by Dfe_open().
 464  *  - DFE PLL and PSCs shall be already up running.
 465  *  - DFE has loaded target config and completed initialize sequence.
 466  *
 467  * @post
 468  * - None.
 469  *
 470  * @b Example
 471  *   @verbatim
 472          [to be documented]
 473      @endverbatim
 474  */
 475 DFE_Err Dfe_issueSyncUpdateDducFarrowPhase
 476 (
 477     DFE_Handle hDfe,
 478     uint32_t dducDev,
 479     DfeFl_MiscSyncGenSig ssel
 480 )
 481 {
 482         DfeFl_Status status;
 483
 484         if(hDfe == NULL)
 485     {
 486         Dfe_osalLog("hDfe is NULL!");
 487         return DFE_ERR_INVALID_HANDLE;
 488     }
 489
 490         if(dducDev > 3)
 491         {
 492                 Dfe_osalLog("Invalid parameter dducDev!");
 493                 return DFE_ERR_INVALID_PARAMS;
 494         }
 495
 496         // set sync
 497         CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_SET_FRW_PHASE_SSEL, &ssel) );
 498
 499         // issue sync
 500         return Dfe_issueSync(hDfe, ssel, DFE_FL_MISC_SYNC_NOWAIT);
 501 }
 502
 503 /**
 504  * @brief Program Distributor Map
 505  * @ingroup DFE_LLD_DDUC_FUNCTION
 506  *
 507  * Write new DDUC distributor map to shadow memory. Each rxSel and chanSel value is associated with one DDUC channel. The first 4 channels are for mixer0, the second 4 channels are for mixer1 and the last 4 channels are for mixer2.
 508  *
 509  *  @param hDfe [in] DFE device handle
 510  *  @param dducDev      [in] Dduc Id, 0 ~ 3
 511  *  @param rxSel        [in] array of rx selection
 512  *    - 0: from Rx
 513  *    - 1: from feedback
 514  *  @param chanSel      [in] array of chan selection, which channel from selected rx.
 515  *
 516  * @return
 517  *  - #DFE_ERR_NONE, if API complete properly
 518  *  - #DFE_ERR_INVALID_HANDLE, if hDfe is NULL
 519  *  - #DFE_ERR_HW_CTRL, if CSL HwControl() failed
 520  *
 521  * @pre
 522  *  - hDfe should be a valid handle opened by Dfe_open().
 523  *  - DFE PLL and PSCs shall be already up running.
 524  *  - DFE has loaded target config and completed initialize sequence.
 525  *  - Dfe_issueSyncUpdateDducDistMap () should be called later to copy gains to working memory.
 526  *
 527  * @post
 528  * - None.
 529  *
 530  * @b Example
 531  *   @verbatim
 532          [to be documented]
 533      @endverbatim
 534  */
 535 DFE_Err Dfe_progDducDistMap
 536 (
 537     DFE_Handle hDfe,
 538     uint32_t  dducDev,
 539     uint32_t  rxSel[12],
 540     uint32_t  chanSel[12]
 541 )
 542 {
 543         DfeFl_Status status;
 544         uint32_t i, iMix, iChan;
 545         DfeFl_DducMixSel DducMixSel;
 546
 547         if(hDfe == NULL)
 548     {
 549         Dfe_osalLog("hDfe is NULL!");
 550         return DFE_ERR_INVALID_HANDLE;
 551     }
 552
 553         if(dducDev > 3)
 554         {
 555                 Dfe_osalLog("Invalid parameter dducDev!");
 556                 return DFE_ERR_INVALID_PARAMS;
 557         }
 558
 559         for(i = 0; i < 12; i++)
 560         {
 561                 if(rxSel[i]>3 || chanSel[i]>3)
 562                 {
 563                         Dfe_osalLog("Invalid parameter!");
 564                         return DFE_ERR_INVALID_PARAMS;
 565                 }
 566         }
 567
 568         for(i = 0; i < 12; i++)
 569         {
 570                 iMix = i>>2;
 571                 iChan = i-iMix*4;
 572                 DducMixSel.iMix = iMix;
 573                 DducMixSel.iChan = iChan;
 574                 DducMixSel.chan_or_rx = DFE_FL_DDUC_SELECTOR_MIX_RX;
 575                 DducMixSel.data = rxSel[i];
 576                 CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_SET_MIX_SEL, &DducMixSel) );
 577
 578                 DducMixSel.chan_or_rx = DFE_FL_DDUC_SELECTOR_MIX_CHAN;
 579                 DducMixSel.data = chanSel[i];
 580                 CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_SET_MIX_SEL, &DducMixSel) );
 581         }
 582
 583         return DFE_ERR_NONE;
 584 }
 585
 586 /**
 587  * @brief Issue Sync Update Distributor Map
 588  * @ingroup DFE_LLD_DDUC_FUNCTION
 589  *
 590  * Issue sync to copy DDUC distributor map from shadow to working memory. Dfe_getSyncStatus() should be called later to check if the sync has come.
 591  *
 592  *  @param hDfe [in] DFE device handle
 593  *  @param dducDev      [in] Dduc Id, 0 ~ 3
 594  *  @param ssel [in] sync select to copy gains from shadow to working memory.
 595  *
 596  * @return
 597  *  - #DFE_ERR_NONE, if API complete properly
 598  *  - #DFE_ERR_INVALID_HANDLE, if hDfe is NULL
 599  *  - #DFE_ERR_HW_CTRL, if CSL HwControl() failed
 600  *
 601  * @pre
 602  *  - hDfe should be a valid handle opened by Dfe_open().
 603  *  - DFE PLL and PSCs shall be already up running.
 604  *  - DFE has loaded target config and completed initialize sequence.
 605  *
 606  * @post
 607  * - None.
 608  *
 609  * @b Example
 610  *   @verbatim
 611          [to be documented]
 612      @endverbatim
 613  */
 614 DFE_Err Dfe_issueSyncUpdateDducDistMap
 615 (
 616     DFE_Handle hDfe,
 617     uint32_t dducDev,
 618     DfeFl_MiscSyncGenSig ssel
 619 )
 620 {
 621         DfeFl_Status status;
 622
 623         if(hDfe == NULL)
 624     {
 625         Dfe_osalLog("hDfe is NULL!");
 626         return DFE_ERR_INVALID_HANDLE;
 627     }
 628
 629         if(dducDev > 3)
 630         {
 631                 Dfe_osalLog("Invalid parameter dducDev!");
 632                 return DFE_ERR_INVALID_PARAMS;
 633         }
 634
 635         // set sync
 636         CSL_HW_CTRL( dfeFl_DducHwControl(hDfe->hDfeDduc[dducDev], DFE_FL_DDUC_CMD_SET_SELECTOR_SSEL, &ssel) );
 637
 638
 639         // issue sync
 640         return Dfe_issueSync(hDfe, ssel, DFE_FL_MISC_SYNC_NOWAIT);
 641 }