source: svn/newcon3bcm2_21bu/magnum/portinginterface/pwm/7552/bpwm.c @ 76

Last change on this file since 76 was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
  • Property svn:executable set to *
File size: 33.8 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2003-2011, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile: bpwm.c $
11 * $brcm_Revision: Hydra_Software_Devel/21 $
12 * $brcm_Date: 3/14/11 2:33p $
13 *
14 * Module Description:
15 *
16 * Revision History:
17 *
18 * $brcm_Log: /magnum/portinginterface/pwm/7038/bpwm.c $
19 *
20 * Hydra_Software_Devel/21   3/14/11 2:33p jhaberf
21 * SW35330-13: replaced 35330 support with 35233 support
22 *
23 * Hydra_Software_Devel/20   11/5/10 7:47p jhaberf
24 * SW35125-1: Added 35125 DTV chip support
25 *
26 * Hydra_Software_Devel/19   5/17/10 3:00p brianlee
27 * SW35230-239: Added new APIs to select open drain/totem pole output.
28 * Also fixed a previous bug with setting totem pole output.
29 *
30 * Hydra_Software_Devel/18   4/26/10 11:20a brianlee
31 * SW35230-195: Added support for multiple PWM cores.  Also added new APIs
32 * to set/get output polarity.
33 *
34 * Hydra_Software_Devel/17   12/18/09 6:39p brianlee
35 * SW35230-23: Added new code for 35230 APIs (removed stubs).
36 *
37 * Hydra_Software_Devel/16   11/24/09 5:39p brianlee
38 * SW35230-23: Added new APIs for 35230 (stubs).
39 *
40 * Hydra_Software_Devel/15   9/4/09 2:34p pntruong
41 * SW3548-2456: Fixed uninitialized variable that crashes on exit.
42 *
43 * Hydra_Software_Devel/15   9/4/09 2:33p pntruong
44 * SW3548-2456: Fixed uninitialized variable that crashes on exit.
45 *
46 * Hydra_Software_Devel/14   8/5/09 10:00a erickson
47 * PR57259: fix BPWM_RampOnInterval critical section
48 *
49 * Hydra_Software_Devel/13   8/4/09 1:27p erickson
50 * PR57259: add BPWM_RampOnInterval and related settings
51 *
52 * Hydra_Software_Devel/12   3/9/09 4:39p jkim
53 * PR48665: clean up the code flaged by Coverity
54 *
55 * Hydra_Software_Devel/11   6/16/08 1:45p farshidf
56 * PR43650: PR43650: need to use bchp defines mask
57 *
58 * Hydra_Software_Devel/PR43650/1   6/16/08 11:49a dyzhang
59 * PR43650: need to use bchp defines mask
60 *
61 * Hydra_Software_Devel/10   2/8/07 12:24a pntruong
62 * PR27084: Remove linux warnings.
63 *
64 * Hydra_Software_Devel/9   1/15/07 6:02p farshidf
65 * PR27084: change FreqModeType to BPWM_FreqModeType
66 *
67 * Hydra_Software_Devel/8   1/15/07 11:09a farshidf
68 * PR27084: add PWM Freq  and contant modes. Add also the On and Period
69 * intervals functions
70 *
71 * Hydra_Software_Devel/7   5/26/04 8:45a dlwin
72 * PR 11189: Merging to Main Branch
73 *
74 * Hydra_Software_Devel/Refsw_Devel_7038_B0/1   4/30/04 2:30p brianlee
75 * PR10857: Version for 7038 B0.
76 *
77 * Hydra_Software_Devel/6   3/26/04 4:32p brianlee
78 * PR8971: Remove BDBG_ASSERT() for malloc failure.
79 *
80 * Hydra_Software_Devel/5   11/4/03 6:53p brianlee
81 * Get rid of enter/leave macros.
82 *
83 * Hydra_Software_Devel/4   10/20/03 6:04p brianlee
84 * Turn open drain off for bcm97038.  Also fixed problem with programming
85 * of open drain setting.
86 *
87 * Hydra_Software_Devel/3   9/24/03 11:59a brianlee
88 * Changed the names of header files.
89 *
90 * Hydra_Software_Devel/2   9/19/03 1:49p brianlee
91 * Fixed warnings from Midas build.
92 *
93 * Hydra_Software_Devel/1   9/17/03 9:53a brianlee
94 * Initial version.
95 *
96 ***************************************************************************/
97#include "bstd.h"
98#include "bpwm.h"
99#include "bchp_irq0.h"
100#include "bchp_pwm.h"
101#if (MAX_PWM_CHANNELS > 2)
102#include "bchp_pwmb.h"
103#endif
104#if (MAX_PWM_CHANNELS > 4)
105#include "bchp_pwmc.h"
106#endif
107#if (MAX_PWM_CHANNELS > 6)
108#include "bchp_pwmd.h"
109#endif
110#if (MAX_PWM_CHANNELS > 8)
111#include "bchp_pwme.h"
112#endif
113
114
115BDBG_MODULE(bpwm);
116
117#define DEV_MAGIC_ID            ((BERR_PWM_ID<<16) | 0xFACE)
118
119#define BPWM_CHK_RETCODE( rc, func )        \
120do {                                        \
121        if( (rc = BERR_TRACE(func)) != BERR_SUCCESS ) \
122        {                                       \
123                goto done;                          \
124        }                                       \
125} while(0)
126
127
128#define EVEN_CHANNEL(x) ((x & 0x01) == 0)
129
130/*******************************************************************************
131*
132*   Private Module Handles
133*
134*******************************************************************************/
135
136typedef struct BPWM_P_Handle
137{
138        uint32_t        magicId;                    /* Used to check if structure is corrupt */
139        BCHP_Handle     hChip;
140        BREG_Handle     hRegister;
141        unsigned int    maxChnNo;
142        BPWM_ChannelHandle hPwmChn[MAX_PWM_CHANNELS];
143        BPWM_Settings   settings;
144} BPWM_P_Handle;
145
146typedef struct BPWM_P_ChannelHandle
147{
148        uint32_t            magicId;                    /* Used to check if structure is corrupt */
149        BPWM_Handle         hPwm;
150        uint32_t            chnNo;
151    uint32_t            coreOffset;                                     /* added to support multiple PWM cores */
152        BPWM_ChannelSettings settings;
153        struct {
154                unsigned OnInterval;
155                BINT_CallbackHandle isrCallback, secondaryIsrCallback;
156        } ramp;
157} BPWM_P_ChannelHandle;
158
159static void BPWM_SetOnIntervalRamp_isr(void *context, int param);
160
161/*******************************************************************************
162*
163*   Default Module Settings
164*
165*******************************************************************************/
166static const BPWM_ChannelSettings defPwmChnSettings[MAX_PWM_CHANNELS] =
167{
168        { false, Variable_Freq_Mode, 3000, 0, 0 },
169        { false, Variable_Freq_Mode, 3000, 0, 0 },
170#if (MAX_PWM_CHANNELS == 4)
171        { false, Variable_Freq_Mode, 3000, 0, 0 },
172        { false, Variable_Freq_Mode, 3000, 0, 0 },
173#elif (MAX_PWM_CHANNELS == 10)
174        { false, Variable_Freq_Mode, 3000, 0, 0 },
175        { false, Variable_Freq_Mode, 3000, 0, 0 },
176        { false, Variable_Freq_Mode, 3000, 0, 0 },
177        { false, Variable_Freq_Mode, 3000, 0, 0 },
178        { false, Variable_Freq_Mode, 3000, 0, 0 },
179        { false, Variable_Freq_Mode, 3000, 0, 0 },
180        { false, Variable_Freq_Mode, 3000, 0, 0 },
181        { false, Variable_Freq_Mode, 3000, 0, 0 },
182#endif
183};
184
185static const uint32_t coreOffsetVal[] =
186{
187    0
188#if (MAX_PWM_CHANNELS > 2)
189    , BCHP_PWMB_CTRL - BCHP_PWM_CTRL
190#endif
191#if (MAX_PWM_CHANNELS > 4)
192    , BCHP_PWMC_CTRL - BCHP_PWM_CTRL
193#endif
194#if (MAX_PWM_CHANNELS > 6)
195    , BCHP_PWMD_CTRL - BCHP_PWM_CTRL
196#endif
197#if (MAX_PWM_CHANNELS > 8)
198    , BCHP_PWME_CTRL - BCHP_PWM_CTRL
199#endif
200};
201
202
203/*******************************************************************************
204*
205*   Public Module Functions
206*
207*******************************************************************************/
208BERR_Code BPWM_Open(
209        BPWM_Handle *pPwm,                  /* [output] Returns handle */
210        BCHP_Handle hChip,                  /* Chip handle */
211        BREG_Handle hRegister,              /* Register handle */
212        const BPWM_Settings *pDefSettings   /* Default settings */
213        )
214{
215        BERR_Code retCode = BERR_SUCCESS;
216        BPWM_Handle hDev;
217        unsigned int chnIdx;
218
219        /* Sanity check on the handles we've been given. */
220        BDBG_ASSERT( hChip );
221        BDBG_ASSERT( hRegister );
222
223        /* Alloc memory from the system heap */
224        hDev = (BPWM_Handle) BKNI_Malloc( sizeof( BPWM_P_Handle ) );
225        if( hDev == NULL )
226        {
227                *pPwm = NULL;
228                retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
229                BDBG_ERR(("BPWM_Open: BKNI_malloc() failed\n"));
230                goto done;
231        }
232        BKNI_Memset(hDev, 0, sizeof(*hDev));
233
234        hDev->magicId   = DEV_MAGIC_ID;
235        hDev->hChip     = hChip;
236        hDev->hRegister = hRegister;
237        hDev->maxChnNo  = MAX_PWM_CHANNELS;
238        for( chnIdx = 0; chnIdx < hDev->maxChnNo; chnIdx++ )
239        {
240                hDev->hPwmChn[chnIdx] = NULL;
241        }
242        if (pDefSettings) {
243                hDev->settings = *pDefSettings;
244        }
245
246        *pPwm = hDev;
247
248done:
249        return( retCode );
250}
251
252BERR_Code BPWM_Close(
253        BPWM_Handle hDev                    /* Device handle */
254        )
255{
256        BERR_Code retCode = BERR_SUCCESS;
257
258
259        BDBG_ASSERT( hDev );
260        BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
261
262        BKNI_Free( (void *) hDev );
263
264        return( retCode );
265}
266
267BERR_Code BPWM_GetDefaultSettings(
268        BPWM_Settings *pDefSettings,        /* [output] Returns default setting */
269        BCHP_Handle hChip                   /* Chip handle */
270        )
271{
272        BERR_Code retCode = BERR_SUCCESS;
273
274        BSTD_UNUSED( hChip );
275
276        BKNI_Memset(pDefSettings, 0, sizeof(*pDefSettings));
277
278        return( retCode );
279}
280
281BERR_Code BPWM_GetTotalChannels(
282        BPWM_Handle hDev,                   /* Device handle */
283        unsigned int *totalChannels         /* [output] Returns total number downstream channels supported */
284        )
285{
286        BERR_Code retCode = BERR_SUCCESS;
287
288
289        BDBG_ASSERT( hDev );
290        BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
291
292        *totalChannels = hDev->maxChnNo;
293
294        return( retCode );
295}
296
297BERR_Code BPWM_GetChannelDefaultSettings(
298        BPWM_Handle hDev,                   /* Device handle */
299        unsigned int channelNo,             /* Channel number to default setting for */
300        BPWM_ChannelSettings *pChnDefSettings /* [output] Returns channel default setting */
301        )
302{
303        BERR_Code retCode = BERR_SUCCESS;
304
305        BDBG_ASSERT( hDev );
306        BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
307
308        if (channelNo >= MAX_PWM_CHANNELS)
309        {
310                retCode = BERR_INVALID_PARAMETER;
311        }
312        else
313        {
314                *pChnDefSettings = defPwmChnSettings[channelNo];
315        }
316
317        return( retCode );
318}
319
320
321BERR_Code BPWM_OpenChannel(
322        BPWM_Handle hDev,                   /* Device handle */
323        BPWM_ChannelHandle *phChn,          /* [output] Returns channel handle */
324        unsigned int channelNo,             /* Channel number to open */
325        const BPWM_ChannelSettings *pChnDefSettings /* Channel default setting */
326        )
327{
328        BERR_Code           retCode = BERR_SUCCESS;
329        BPWM_ChannelHandle  hChnDev;
330        uint32_t            lval;
331
332        BDBG_ASSERT( hDev );
333        BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
334
335        if( channelNo < hDev->maxChnNo )
336        {
337                if( hDev->hPwmChn[channelNo] == NULL )
338                {
339                        /* Alloc memory from the system heap */
340                        hChnDev = (BPWM_ChannelHandle) BKNI_Malloc( sizeof( BPWM_P_ChannelHandle ) );
341                        if( hChnDev == NULL )
342                        {
343                                *phChn = NULL;
344                                retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
345                                BDBG_ERR(("BPWM_OpenChannel: BKNI_malloc() failed\n"));
346                                goto done;
347                        }
348
349                        /* Zero out initializations */
350                        BKNI_Memset(hChnDev, 0, sizeof(BPWM_P_ChannelHandle));
351
352                        hChnDev->settings = *pChnDefSettings;
353                        hChnDev->magicId    = DEV_MAGIC_ID;
354                        hChnDev->hPwm       = hDev;
355                        hChnDev->chnNo      = channelNo;
356                        hDev->hPwmChn[channelNo] = hChnDev;
357
358            /*
359             * Offsets are based off of BSCA
360             */
361            hChnDev->coreOffset = coreOffsetVal[channelNo>>1];
362
363                        /* Program the open drain configuration setting */
364                        lval = BREG_Read32(hDev->hRegister, (hChnDev->coreOffset + BCHP_PWM_CTRL));
365                        if (pChnDefSettings->openDrainb == false)
366                        {
367                                lval |= EVEN_CHANNEL(channelNo) ? BCHP_PWM_CTRL_pwm1_opendrainb_MASK : BCHP_PWM_CTRL_pwm2_opendrainb_MASK;
368                                lval &= EVEN_CHANNEL(channelNo) ? ~BCHP_PWM_CTRL_pwm1_oeb_MASK : ~BCHP_PWM_CTRL_pwm2_oeb_MASK;
369                        }
370                        else
371                        {
372                                lval &= EVEN_CHANNEL(channelNo) ? ~BCHP_PWM_CTRL_pwm1_opendrainb_MASK : ~BCHP_PWM_CTRL_pwm2_opendrainb_MASK;
373                                lval &= EVEN_CHANNEL(channelNo) ? ~BCHP_PWM_CTRL_pwm1_oeb_MASK : ~BCHP_PWM_CTRL_pwm2_oeb_MASK;
374                        }
375                        BREG_Write32(hDev->hRegister, (hChnDev->coreOffset + BCHP_PWM_CTRL), lval);
376
377                        /* Program the Freq Mode */
378                        if (pChnDefSettings->FreqMode == Variable_Freq_Mode)
379                        {
380                                BPWM_SetFreqMode(hChnDev, Variable_Freq_Mode);
381                        }
382                        else
383                        {
384                                BPWM_SetFreqMode(hChnDev, Constant_Freq_Mode);
385                        }
386
387                        if (pChnDefSettings->interruptId && hChnDev->hPwm->settings.hInterrupt) {
388                                retCode = BINT_CreateCallback(&hChnDev->ramp.isrCallback, hChnDev->hPwm->settings.hInterrupt, pChnDefSettings->interruptId, BPWM_SetOnIntervalRamp_isr, hChnDev, 0);
389                                if (retCode) {
390                                        retCode = BERR_TRACE(retCode);
391                                        BKNI_Free(hChnDev);
392                                        goto done;
393                                }
394                        }
395
396                        if (pChnDefSettings->secondaryInterruptId && hChnDev->hPwm->settings.hInterrupt) {
397                                retCode = BINT_CreateCallback(&hChnDev->ramp.secondaryIsrCallback, hChnDev->hPwm->settings.hInterrupt, pChnDefSettings->secondaryInterruptId, BPWM_SetOnIntervalRamp_isr, hChnDev, 0);
398                                if (retCode) {
399                                        retCode = BERR_TRACE(retCode);
400                                        BINT_DestroyCallback(hChnDev->ramp.isrCallback);
401                                        BKNI_Free(hChnDev);
402                                        goto done;
403                                }
404                        }
405
406                        *phChn = hChnDev;
407                }
408                else
409                {
410                        retCode = BPWM_ERR_NOTAVAIL_CHN_NO;
411                }
412        }
413        else
414        {
415                retCode = BERR_INVALID_PARAMETER;
416        }
417
418done:
419        return( retCode );
420}
421
422BERR_Code BPWM_CloseChannel(
423        BPWM_ChannelHandle hChn         /* Device channel handle */
424        )
425{
426        BERR_Code retCode = BERR_SUCCESS;
427        BPWM_Handle hDev;
428        unsigned int chnNo;
429
430        BDBG_ASSERT( hChn );
431        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
432
433        if (hChn->ramp.isrCallback) {
434                BINT_DestroyCallback(hChn->ramp.isrCallback);
435        }
436        if (hChn->ramp.secondaryIsrCallback) {
437                BINT_DestroyCallback(hChn->ramp.secondaryIsrCallback);
438        }
439
440        hDev = hChn->hPwm;
441        chnNo = hChn->chnNo;
442        BKNI_Free( hChn );
443        hDev->hPwmChn[chnNo] = NULL;
444
445        return( retCode );
446}
447
448BERR_Code BPWM_GetDevice(
449        BPWM_ChannelHandle hChn,            /* Device channel handle */
450        BPWM_Handle *phDev                  /* [output] Returns Device handle */
451        )
452{
453        BERR_Code retCode = BERR_SUCCESS;
454
455
456        BDBG_ASSERT( hChn );
457        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
458
459        *phDev = hChn->hPwm;
460
461        return( retCode );
462}
463
464
465BERR_Code BPWM_SetControlWord(
466        BPWM_ChannelHandle  hChn,           /* Device channel handle */
467        uint16_t            cWord           /* control word to program */
468        )
469{
470        BERR_Code   retCode = BERR_SUCCESS;
471        uint32_t    lval;
472        BPWM_Handle hDev;
473
474        BDBG_ASSERT( hChn );
475        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
476
477        hDev = hChn->hPwm;
478
479        if (EVEN_CHANNEL(hChn->chnNo))
480        {
481                lval = (uint32_t)(cWord >> 8);
482                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_CWORD_MSB), lval);
483                lval = (uint32_t)(cWord & 0xff);
484                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_CWORD_LSB), lval);
485        }
486        else
487        {
488                lval = (uint32_t)(cWord >> 8);
489                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_CWORD_MSB), lval);
490                lval = (uint32_t)(cWord & 0xff);
491                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_CWORD_LSB), lval);
492        }
493
494        return( retCode );
495}
496
497BERR_Code BPWM_GetControlWord(
498        BPWM_ChannelHandle  hChn,           /* Device channel handle */
499        uint16_t            *cWord          /* control word to program */
500        )
501{
502        BERR_Code   retCode = BERR_SUCCESS;
503        uint32_t    msb, lsb;
504        BPWM_Handle hDev;
505
506        BDBG_ASSERT( hChn );
507        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
508
509        hDev = hChn->hPwm;
510
511        if (EVEN_CHANNEL(hChn->chnNo))
512        {
513                msb = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_CWORD_MSB));
514                lsb = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_CWORD_LSB));
515                *cWord = (uint16_t)((msb << 8) | (lsb & 0xff));
516        }
517        else
518        {
519                msb = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_CWORD_MSB));
520                lsb = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_CWORD_LSB));
521                *cWord = (uint16_t)((msb << 8) | (lsb & 0xff));
522        }
523
524        return( retCode );
525}
526
527BERR_Code BPWM_SetFreqMode(
528        BPWM_ChannelHandle  hChn,                  /* Device channel handle */
529        BPWM_FreqModeType           Frequeny_Mode       /* Frequency mode  to program */
530        )
531{
532        BERR_Code   retCode = BERR_SUCCESS;
533        uint32_t    lval;
534        BPWM_Handle hDev;
535
536        BDBG_ASSERT( hChn );
537        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
538
539        hDev = hChn->hPwm;
540
541        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2));
542           if (Frequeny_Mode == Variable_Freq_Mode)
543        {
544                lval |= EVEN_CHANNEL(hChn->chnNo) ? BCHP_PWM_CTRL2_pwm1_out_select_MASK : BCHP_PWM_CTRL2_pwm2_out_select_MASK;
545                lval &= EVEN_CHANNEL(hChn->chnNo) ? ~BCHP_PWM_CTRL2_pwm1_out_select_MASK : ~BCHP_PWM_CTRL2_pwm2_out_select_MASK;
546        }
547        else
548        {
549                lval &= EVEN_CHANNEL(hChn->chnNo) ? ~BCHP_PWM_CTRL2_pwm1_out_select_MASK : ~BCHP_PWM_CTRL2_pwm2_out_select_MASK;
550                lval |= EVEN_CHANNEL(hChn->chnNo) ? BCHP_PWM_CTRL2_pwm1_out_select_MASK : BCHP_PWM_CTRL2_pwm2_out_select_MASK;
551        }
552        BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2), lval);
553
554        return( retCode );
555}
556
557
558BERR_Code BPWM_GetFreqMode(
559        BPWM_ChannelHandle  hChn,                  /* Device channel handle */
560        BPWM_FreqModeType           *Frequeny_Mode      /* Frequency mode  read */
561        )
562{
563        BERR_Code   retCode = BERR_SUCCESS;
564        uint32_t    lval;
565        BPWM_Handle hDev;
566
567        BDBG_ASSERT( hChn );
568        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
569
570        hDev = hChn->hPwm;
571
572        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2));
573
574        if (EVEN_CHANNEL(hChn->chnNo))
575        {
576
577                if (lval & BCHP_PWM_CTRL2_pwm1_out_select_MASK)
578                        *Frequeny_Mode = Constant_Freq_Mode;
579                else
580                        *Frequeny_Mode = Variable_Freq_Mode;
581        }
582        else
583        {
584                if (lval & BCHP_PWM_CTRL2_pwm2_out_select_MASK)
585                        *Frequeny_Mode = Constant_Freq_Mode;
586                else
587                        *Frequeny_Mode = Variable_Freq_Mode;
588        }
589
590        return( retCode );
591}
592
593static void BPWM_SetOnIntervalRamp_isr(void *context, int param)
594{
595        BPWM_ChannelHandle hChn = context;
596        BPWM_Handle hDev = hChn->hPwm;
597        uint32_t addr;
598        uint32_t currentValue;
599        uint32_t targetValue;
600        uint32_t cnt;
601
602        BSTD_UNUSED(param);
603
604        if (EVEN_CHANNEL(hChn->chnNo)) {
605                addr = BCHP_PWM_PWM1_ON;
606        }
607        else {
608                addr = BCHP_PWM_PWM2_ON;
609        }
610
611        currentValue = BREG_Read32_isr(hDev->hRegister, (hChn->coreOffset + addr));
612        targetValue = hChn->ramp.OnInterval;
613        cnt = hChn->settings.maxChangesPerInterrupt;
614        while (currentValue != targetValue && cnt--)
615        {
616                if (currentValue < targetValue) {
617                        currentValue++;
618                }
619                else {
620                        currentValue--;
621                }
622                BREG_Write32_isr(hDev->hRegister, (hChn->coreOffset + addr), currentValue);
623        }
624        if (currentValue == targetValue) {
625                if (hChn->ramp.isrCallback) {
626                        BINT_DisableCallback_isr(hChn->ramp.isrCallback);
627                }
628                if (hChn->ramp.secondaryIsrCallback) {
629                        BINT_DisableCallback_isr(hChn->ramp.secondaryIsrCallback);
630                }
631        }
632}
633
634BERR_Code BPWM_RampOnInterval( BPWM_ChannelHandle  hChn, uint16_t OnInterval )
635{
636        BERR_Code rc;
637        BKNI_EnterCriticalSection();
638        rc = BPWM_RampOnInterval_isr(hChn, OnInterval);
639        BKNI_LeaveCriticalSection();
640        return rc;
641}
642
643BERR_Code BPWM_RampOnInterval_isr( BPWM_ChannelHandle  hChn, uint16_t OnInterval )
644{
645        BDBG_ASSERT( hChn );
646        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
647
648        if (hChn->settings.maxChangesPerInterrupt == 0 || (!hChn->ramp.isrCallback && !hChn->ramp.secondaryIsrCallback)) {
649                return BERR_TRACE(BERR_INVALID_PARAMETER);
650        }
651
652        hChn->ramp.OnInterval = OnInterval;
653        if (hChn->ramp.isrCallback) {
654                BINT_EnableCallback_isr(hChn->ramp.isrCallback);
655        }
656        if (hChn->ramp.secondaryIsrCallback) {
657                BINT_EnableCallback_isr(hChn->ramp.secondaryIsrCallback);
658        }
659        return 0;
660}
661
662BERR_Code BPWM_SetOnInterval(
663        BPWM_ChannelHandle  hChn,           /* Device channel handle */
664        uint16_t            OnInterval          /* On Interval  to program */
665        )
666{
667        BERR_Code   retCode = BERR_SUCCESS;
668        uint32_t    lval;
669        BPWM_Handle hDev;
670
671        BDBG_ASSERT( hChn );
672        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
673
674        hDev = hChn->hPwm;
675
676        if (EVEN_CHANNEL(hChn->chnNo))
677        {
678                lval = (uint32_t)(OnInterval & BCHP_PWM_PWM1_ON_pwm1_on_MASK);
679                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_ON), lval);
680        }
681        else
682        {
683                lval = (uint32_t)(OnInterval & BCHP_PWM_PWM1_ON_pwm1_on_MASK);
684                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_ON), lval);
685        }
686
687        return( retCode );
688}
689
690
691BERR_Code BPWM_GetOnInterval(
692        BPWM_ChannelHandle  hChn,           /* [in] Device channel handle */
693        uint16_t            *OnInterval         /* [out] On Interval  to read */
694        )
695{
696        BERR_Code   retCode = BERR_SUCCESS;
697        uint32_t    lval;
698        BPWM_Handle hDev;
699
700        BDBG_ASSERT( hChn );
701        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
702
703        hDev = hChn->hPwm;
704
705
706        if (EVEN_CHANNEL(hChn->chnNo))
707        {
708                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_ON));
709                *OnInterval = (uint16_t)(lval & BCHP_PWM_PWM1_ON_pwm1_on_MASK);
710        }
711        else
712        {
713                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_ON));
714                *OnInterval = (uint16_t)(lval & BCHP_PWM_PWM1_ON_pwm1_on_MASK);
715        }
716
717        return( retCode );
718}
719
720
721BERR_Code BPWM_SetPeriodInterval(
722        BPWM_ChannelHandle  hChn,           /* Device channel handle */
723        uint16_t            PeriodInterval          /* Period Interval  to program */
724        )
725{
726        BERR_Code   retCode = BERR_SUCCESS;
727        uint32_t    lval;
728        BPWM_Handle hDev;
729
730        BDBG_ASSERT( hChn );
731        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
732
733        hDev = hChn->hPwm;
734
735        if (EVEN_CHANNEL(hChn->chnNo))
736        {
737                lval = (uint32_t)(PeriodInterval & BCHP_PWM_PWM1_PERIOD_pwm1_period_MASK);
738                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_PERIOD), lval);
739        }
740        else
741        {
742                lval = (uint32_t)(PeriodInterval & BCHP_PWM_PWM1_PERIOD_pwm1_period_MASK);
743                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_PERIOD), lval);
744        }
745
746        return( retCode );
747}
748
749
750BERR_Code BPWM_GetPeriodInterval(
751        BPWM_ChannelHandle  hChn,           /* [in] Device channel handle */
752        uint16_t            *PeriodInterval         /* [out] On Interval  to read */
753        )
754{
755        BERR_Code   retCode = BERR_SUCCESS;
756        uint32_t    lval;
757        BPWM_Handle hDev;
758
759        BDBG_ASSERT( hChn );
760        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
761
762        hDev = hChn->hPwm;
763
764        if (EVEN_CHANNEL(hChn->chnNo))
765        {
766                lval= BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_PERIOD));
767                *PeriodInterval = (uint16_t)(lval & BCHP_PWM_PWM1_PERIOD_pwm1_period_MASK);
768        }
769        else
770        {
771                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_PERIOD));
772                *PeriodInterval = (uint16_t)(lval & BCHP_PWM_PWM1_PERIOD_pwm1_period_MASK);
773        }
774
775        return( retCode );
776}
777
778BERR_Code BPWM_SetOnAndPeriodInterval(
779        BPWM_ChannelHandle  hChn,           /* Device channel handle */
780        uint16_t            OnInterval,         /* OnInterval  to program */
781        uint16_t            PeriodInterval      /* Period Interval  to program */
782        )
783{
784        BERR_Code   retCode = BERR_SUCCESS;
785
786
787        BPWM_SetOnInterval(hChn, OnInterval);
788        BPWM_SetPeriodInterval(hChn, PeriodInterval);
789
790
791        return( retCode );
792}
793
794
795BERR_Code BPWM_GetOnAndPeriodInterval(
796        BPWM_ChannelHandle  hChn,           /* Device channel handle */
797        uint16_t            *OnInterval,            /* OnInterval  to program */
798        uint16_t            *PeriodInterval     /* Period Interval  to program */
799        )
800{
801        BERR_Code   retCode = BERR_SUCCESS;
802
803        BPWM_GetOnInterval(hChn, OnInterval);
804           BPWM_GetPeriodInterval(hChn, PeriodInterval);
805
806
807        return( retCode );
808}
809
810
811BERR_Code BPWM_Start(
812        BPWM_ChannelHandle hChn     /* Device channel handle */
813        )
814{
815        BERR_Code       retCode = BERR_SUCCESS;
816        uint32_t        lval;
817        BPWM_Handle     hDev;
818
819        BDBG_ASSERT( hChn );
820        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
821
822        hDev = hChn->hPwm;
823
824        if (EVEN_CHANNEL(hChn->chnNo))
825        {
826                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL));
827                lval |= BCHP_PWM_CTRL_pwm1_start_MASK;
828                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL), lval);
829        }
830        else
831        {
832                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL));
833                lval |= BCHP_PWM_CTRL_pwm2_start_MASK;
834                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL), lval);
835        }
836
837        return( retCode );
838}
839
840BERR_Code BPWM_Stop(
841        BPWM_ChannelHandle hChn         /* Device channel handle */
842        )
843{
844        BERR_Code       retCode = BERR_SUCCESS;
845        uint32_t        lval;
846        BPWM_Handle     hDev;
847
848        BDBG_ASSERT( hChn );
849        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
850
851        hDev = hChn->hPwm;
852
853        if (EVEN_CHANNEL(hChn->chnNo))
854        {
855                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL));
856                lval &= ~BCHP_PWM_CTRL_pwm1_start_MASK;
857                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL), lval);
858        }
859        else
860        {
861                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL));
862                lval &= ~BCHP_PWM_CTRL_pwm2_start_MASK;
863                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL), lval);
864        }
865
866        return( retCode );
867}
868
869BERR_Code BPWM_SetOpenDrainConfig
870(
871        BPWM_ChannelHandle              hChn,                   /* [in] Device channel handle */
872        BPWM_OpenDrainOutput    type                    /* [in] open drain/totem pole select */
873)
874{
875        BERR_Code       retCode = BERR_SUCCESS;
876        BPWM_Handle     hDev;
877        uint32_t        lval;
878
879        BDBG_ASSERT( hChn );
880        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
881
882        hDev = hChn->hPwm;
883
884        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL));
885        if (type == PwmOutTotemPole)
886        {
887                lval |= EVEN_CHANNEL(hChn->chnNo) ? BCHP_PWM_CTRL_pwm1_opendrainb_MASK : BCHP_PWM_CTRL_pwm2_opendrainb_MASK;
888        }
889        else
890        {
891                lval &= EVEN_CHANNEL(hChn->chnNo) ? ~BCHP_PWM_CTRL_pwm1_opendrainb_MASK : ~BCHP_PWM_CTRL_pwm2_opendrainb_MASK;
892        }
893        BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL), lval);
894
895        return (retCode);
896}
897
898BERR_Code BPWM_GetOpenDrainConfig
899(
900        BPWM_ChannelHandle              hChn,                   /* [in] Device channel handle */
901        BPWM_OpenDrainOutput    *type                   /* [out] open drain/totem pole select */
902)
903{
904        BERR_Code       retCode = BERR_SUCCESS;
905        BPWM_Handle     hDev;
906        uint32_t        lval;
907
908        BDBG_ASSERT( hChn );
909        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
910
911        hDev = hChn->hPwm;
912
913        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL));
914        if (EVEN_CHANNEL(hChn->chnNo))
915        {
916                lval &= BCHP_PWM_CTRL_pwm1_opendrainb_MASK;
917        }
918        else
919        {
920                lval &= BCHP_PWM_CTRL_pwm2_opendrainb_MASK;
921        }
922        *type = ((lval == 0) ? PwmOutOpenDrain : PwmOutTotemPole);
923
924        return (retCode);
925}
926
927#if ((BCHP_CHIP==35230) || (BCHP_CHIP==35125) || (BCHP_CHIP==35233))
928BERR_Code BPWM_SetControlWordSet1 
929(
930        BPWM_ChannelHandle  hChn,           /* [in] Device channel handle */
931        uint16_t            cWord           /* [in] control word to program for register set 1 */
932)
933{
934        BERR_Code   retCode = BERR_SUCCESS;
935        BPWM_Handle hDev;
936
937        BDBG_ASSERT( hChn );
938        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
939
940        hDev = hChn->hPwm;
941
942        if (EVEN_CHANNEL(hChn->chnNo))
943        {
944                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_RSET1_R0), (uint32_t)cWord);
945        }
946        else
947        {
948                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_RSET1_R0), (uint32_t)cWord);
949        }
950
951        return( retCode );
952}
953
954BERR_Code BPWM_GetControlWordSet1 
955(
956        BPWM_ChannelHandle  hChn,           /* [in] Device channel handle */
957        uint16_t            *cWord          /* [out] control word to program for register set 1 */
958)
959{
960        BERR_Code       retCode = BERR_SUCCESS;
961        BPWM_Handle     hDev;
962        uint32_t        lval;
963
964        BDBG_ASSERT( hChn );
965        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
966
967        hDev = hChn->hPwm;
968
969        if (EVEN_CHANNEL(hChn->chnNo))
970        {
971                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_RSET1_R0));
972        }
973        else
974        {
975                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_RSET1_R0));
976        }
977        *cWord = (uint16_t)lval;
978
979        return (retCode);
980}
981
982BERR_Code BPWM_SetOnAndPeriodIntervalSet1
983(
984        BPWM_ChannelHandle  hChn,               /* [in] Device channel handle */
985        uint16_t            OnInterval,         /* [in] OnInterval  to program */
986        uint16_t            PeriodInterval      /* [in] Period Interval  to program */
987)
988{
989        BERR_Code       retCode = BERR_SUCCESS;
990        BPWM_Handle     hDev;
991        uint32_t        lval;
992
993        BDBG_ASSERT( hChn );
994        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
995
996        hDev = hChn->hPwm;
997
998        lval = (((uint32_t)(PeriodInterval)) << BCHP_PWM_PWM1_RSET1_R1_period_SHIFT) | 
999                        ((uint32_t)(OnInterval));
1000        if (EVEN_CHANNEL(hChn->chnNo))
1001        {
1002                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_RSET1_R1), lval);
1003        }
1004        else
1005        {
1006                BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_RSET1_R1), lval);
1007        }
1008
1009        return (retCode);
1010}
1011
1012BERR_Code BPWM_GetOnAndPeriodIntervalSet1
1013(
1014        BPWM_ChannelHandle  hChn,               /* [in] Device channel handle */
1015        uint16_t            *OnInterval,        /* [out] OnInterval  to program */
1016        uint16_t            *PeriodInterval     /* [out] Period Interval  to program */
1017)
1018{
1019        BERR_Code       retCode = BERR_SUCCESS;
1020        BPWM_Handle     hDev;
1021        uint32_t        lval;
1022
1023        BDBG_ASSERT( hChn );
1024        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1025
1026        hDev = hChn->hPwm;
1027
1028        if (EVEN_CHANNEL(hChn->chnNo))
1029        {
1030                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM1_RSET1_R1));
1031        }
1032        else
1033        {
1034                lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_PWM2_RSET1_R1));
1035        }
1036
1037        *OnInterval = (uint16_t)(lval & BCHP_PWM_PWM1_RSET1_R1_on_MASK);
1038        *PeriodInterval = (uint16_t)(lval >> BCHP_PWM_PWM1_RSET1_R1_period_SHIFT);
1039
1040        return (retCode);
1041}
1042
1043BERR_Code BPWM_EnableSyncMode
1044(
1045        BPWM_ChannelHandle      hChn,                           /* [in] Device channel handle */
1046        bool                            enable                          /* [in] sync enable */
1047)
1048{
1049        BERR_Code       retCode = BERR_SUCCESS;
1050        BPWM_Handle     hDev;
1051        uint32_t        lval;
1052
1053        BDBG_ASSERT( hChn );
1054        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1055
1056        hDev = hChn->hPwm;
1057
1058        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2));
1059        if (enable == true)
1060        {
1061                if (EVEN_CHANNEL(hChn->chnNo))
1062                {
1063                        lval |= BCHP_PWM_CTRL2_pwm1_enable_sync_MASK;
1064                }
1065                else
1066                {
1067                        lval |= BCHP_PWM_CTRL2_pwm2_enable_sync_MASK;
1068                }
1069        }
1070        else
1071        {
1072                if (EVEN_CHANNEL(hChn->chnNo))
1073                {
1074                        lval &= ~BCHP_PWM_CTRL2_pwm1_enable_sync_MASK;
1075                }
1076                else
1077                {
1078                        lval &= ~BCHP_PWM_CTRL2_pwm2_enable_sync_MASK;
1079                }
1080        }
1081        BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2), lval);
1082
1083        return (retCode);
1084}
1085
1086BERR_Code BPWM_SetDblBufMode
1087(
1088        BPWM_ChannelHandle      hChn,                           /* [in] Device channel handle */
1089        BPWM_DblBufMode         dblBufMode                      /* [in] double buffer mode type */
1090)
1091{
1092        BERR_Code       retCode = BERR_SUCCESS;
1093        BPWM_Handle     hDev;
1094        uint32_t        lval;
1095
1096        BDBG_ASSERT( hChn );
1097        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1098
1099        hDev = hChn->hPwm;
1100
1101        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL3));
1102        if (EVEN_CHANNEL(hChn->chnNo))
1103        {
1104                lval &= ~BCHP_PWM_CTRL3_pwm1_dbl_buf_mode_MASK;
1105                lval |= (uint32_t)dblBufMode;
1106        }
1107        else
1108        {
1109                lval &= ~BCHP_PWM_CTRL3_pwm2_dbl_buf_mode_MASK;
1110                lval |= ((uint32_t)dblBufMode) << BCHP_PWM_CTRL3_pwm2_dbl_buf_mode_SHIFT;
1111        }
1112
1113        BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL3), lval);
1114
1115        return (retCode);
1116}
1117
1118BERR_Code BPWM_GetDblBufMode
1119(
1120        BPWM_ChannelHandle      hChn,                           /* [in] Device channel handle */
1121        BPWM_DblBufMode         *dblBufMode                     /* [out] double buffer mode type */
1122)
1123{
1124        BERR_Code       retCode = BERR_SUCCESS;
1125        BPWM_Handle     hDev;
1126        uint32_t        lval;
1127
1128        BDBG_ASSERT( hChn );
1129        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1130
1131        hDev = hChn->hPwm;
1132
1133        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL3));
1134        if (EVEN_CHANNEL(hChn->chnNo))
1135        {
1136                *dblBufMode = (BPWM_DblBufMode)(lval & BCHP_PWM_CTRL3_pwm1_dbl_buf_mode_MASK);
1137        }
1138        else
1139        {
1140                *dblBufMode = (BPWM_DblBufMode)((lval & BCHP_PWM_CTRL3_pwm2_dbl_buf_mode_MASK) >> 
1141                                                                                        BCHP_PWM_CTRL3_pwm2_dbl_buf_mode_SHIFT);
1142        }
1143
1144        return (retCode);
1145}
1146
1147BERR_Code BPWM_SetSyncEdge
1148(
1149        BPWM_ChannelHandle      hChn,                           /* [in] Device channel handle */
1150        BPWM_SyncEdgeSel        SyncEdgeSel                     /* [in] edge type */
1151)
1152{
1153        BERR_Code       retCode = BERR_SUCCESS;
1154        BPWM_Handle     hDev;
1155        uint32_t        lval;
1156
1157        BDBG_ASSERT( hChn );
1158        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1159
1160        hDev = hChn->hPwm;
1161
1162        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2));
1163        if (EVEN_CHANNEL(hChn->chnNo))
1164        {
1165                if (SyncEdgeSel == SyncEdgeNeg)
1166                {
1167                        lval &= ~BCHP_PWM_CTRL2_pwm1_sync_edge_sel_MASK;
1168                }
1169                else
1170                {
1171                        lval |= BCHP_PWM_CTRL2_pwm1_sync_edge_sel_MASK;
1172                }
1173        }
1174        else
1175        {
1176                if (SyncEdgeSel == SyncEdgeNeg)
1177                {
1178                        lval &= ~BCHP_PWM_CTRL2_pwm2_sync_edge_sel_MASK;
1179                }
1180                else
1181                {
1182                        lval |= BCHP_PWM_CTRL2_pwm2_sync_edge_sel_MASK;
1183                }
1184        }
1185        BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2), lval);
1186
1187        return (retCode);
1188}
1189
1190BERR_Code BPWM_GetSyncEdge
1191(
1192        BPWM_ChannelHandle      hChn,                           /* [in] Device channel handle */
1193        BPWM_SyncEdgeSel        *SyncEdgeSel            /* [out] edge type */
1194)
1195{
1196        BERR_Code       retCode = BERR_SUCCESS;
1197        BPWM_Handle     hDev;
1198        uint32_t        lval;
1199
1200        BDBG_ASSERT( hChn );
1201        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1202
1203        hDev = hChn->hPwm;
1204
1205        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2));
1206        if (EVEN_CHANNEL(hChn->chnNo))
1207        {
1208                lval &= BCHP_PWM_CTRL2_pwm1_sync_edge_sel_MASK;
1209        }
1210        else
1211        {
1212                lval &= BCHP_PWM_CTRL2_pwm2_sync_edge_sel_MASK;
1213        }
1214       
1215        *SyncEdgeSel = ((lval == 0) ? SyncEdgeNeg : SyncEdgePos);
1216
1217        return (retCode);
1218}
1219
1220BERR_Code BPWM_SetTwoInputSync
1221(
1222        BPWM_ChannelHandle              hChn,                   /* [in] Device channel handle */
1223        BPWM_TwoInputSyncType   type                    /* [in] two-input sync type */
1224)
1225{
1226        BERR_Code       retCode = BERR_SUCCESS;
1227        BPWM_Handle     hDev;
1228        uint32_t        lval;
1229
1230        BDBG_ASSERT( hChn );
1231        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1232
1233        hDev = hChn->hPwm;
1234
1235        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL3));
1236        if (EVEN_CHANNEL(hChn->chnNo))
1237        {
1238                if (type == TwoInputSync_Vsync2)
1239                {
1240                        lval |= BCHP_PWM_CTRL3_pwm1_two_inp_sync_MASK;
1241                }
1242                else
1243                {
1244                        lval &= ~BCHP_PWM_CTRL3_pwm1_two_inp_sync_MASK;
1245                }
1246        }
1247        else
1248        {
1249                if (type == TwoInputSync_Vsync2)
1250                {
1251                        lval |= BCHP_PWM_CTRL3_pwm2_two_inp_sync_MASK;
1252                }
1253                else
1254                {
1255                        lval &= ~BCHP_PWM_CTRL3_pwm2_two_inp_sync_MASK;
1256                }
1257        }
1258        BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL3), lval);
1259
1260        return (retCode);
1261}
1262
1263BERR_Code BPWM_GetTwoInputSync
1264(
1265        BPWM_ChannelHandle              hChn,                   /* [in] Device channel handle */
1266        BPWM_TwoInputSyncType   *type                   /* [out] two-input sync type */
1267)
1268{
1269        BERR_Code       retCode = BERR_SUCCESS;
1270        BPWM_Handle     hDev;
1271        uint32_t        lval;
1272
1273        BDBG_ASSERT( hChn );
1274        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1275
1276        hDev = hChn->hPwm;
1277
1278        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL3));
1279        if (EVEN_CHANNEL(hChn->chnNo))
1280        {
1281                lval &= BCHP_PWM_CTRL3_pwm1_two_inp_sync_MASK;
1282        }
1283        else
1284        {
1285                lval &= BCHP_PWM_CTRL3_pwm2_two_inp_sync_MASK;
1286        }
1287
1288        *type = ((lval == 0) ? TwoInputSync_Vsync : TwoInputSync_Vsync2);
1289
1290        return (retCode);
1291}
1292
1293BERR_Code BPWM_SetOutputPolarity
1294(
1295        BPWM_ChannelHandle      hChn,                           /* [in] Device channel handle */
1296        BPWM_OutPolaritySel     OutPolSel                       /* [in] output polarity */
1297)
1298{
1299        BERR_Code       retCode = BERR_SUCCESS;
1300        BPWM_Handle     hDev;
1301        uint32_t        lval;
1302
1303        BDBG_ASSERT( hChn );
1304        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1305
1306        hDev = hChn->hPwm;
1307
1308        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2));
1309        if (EVEN_CHANNEL(hChn->chnNo))
1310        {
1311                if (OutPolSel == OutPolarityHigh)
1312                {
1313                        lval &= ~BCHP_PWM_CTRL2_pwm1_out_polarity_MASK;
1314                }
1315                else
1316                {
1317                        lval |= BCHP_PWM_CTRL2_pwm1_out_polarity_MASK;
1318                }
1319        }
1320        else
1321        {
1322                if (OutPolSel == OutPolarityHigh)
1323                {
1324                        lval &= ~BCHP_PWM_CTRL2_pwm2_out_polarity_MASK;
1325                }
1326                else
1327                {
1328                        lval |= BCHP_PWM_CTRL2_pwm2_out_polarity_MASK;
1329                }
1330        }
1331        BREG_Write32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2), lval);
1332
1333        return (retCode);
1334}
1335
1336BERR_Code BPWM_GetOutputPolarity
1337(
1338        BPWM_ChannelHandle      hChn,                           /* [in] Device channel handle */
1339        BPWM_OutPolaritySel     *OutPolSel                      /* [out] output polarity */
1340)
1341{
1342        BERR_Code       retCode = BERR_SUCCESS;
1343        BPWM_Handle     hDev;
1344        uint32_t        lval;
1345
1346        BDBG_ASSERT( hChn );
1347        BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1348
1349        hDev = hChn->hPwm;
1350
1351        lval = BREG_Read32(hDev->hRegister, (hChn->coreOffset + BCHP_PWM_CTRL2));
1352        if (EVEN_CHANNEL(hChn->chnNo))
1353        {
1354                lval &= BCHP_PWM_CTRL2_pwm1_out_polarity_MASK;
1355        }
1356        else
1357        {
1358                lval &= BCHP_PWM_CTRL2_pwm2_out_polarity_MASK;
1359        }
1360       
1361        *OutPolSel = ((lval == 0) ? OutPolarityHigh : OutPolarityLow);
1362
1363        return (retCode);
1364}
1365
1366#endif
1367
1368
1369/* End of file */
Note: See TracBrowser for help on using the repository browser.