source: svn/trunk/newcon3bcm2_21bu/magnum/syslib/synclib/7552/bsynclib_state_machine.c

Last change on this file was 2, checked in by jglee, 11 years ago

first commit
  • Property svn:executable set to *
File size: 6.4 KB
Line 
1/***************************************************************************
2*     Copyright (c) 2004-2010, 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: bsynclib_state_machine.c $
11* $brcm_Revision: Hydra_Software_Devel/2 $
12* $brcm_Date: 2/12/10 8:46p $
13*
14* Revision History:
15*
16* $brcm_Log: /magnum/syslib/synclib/noarch/bsynclib_state_machine.c $
17*
18* Hydra_Software_Devel/2   2/12/10 8:46p bandrews
19* SW7405-3912: assert all inputs are not null
20*
21* Hydra_Software_Devel/1   3/24/08 3:09p bandrews
22* PR40865: Fixed
23*
24* Hydra_Software_Devel/2   1/3/08 5:17p bandrews
25* PR37951: Updated based on initial feedback
26*
27* Hydra_Software_Devel/1   12/12/07 2:54p bandrews
28* PR37951: Initial check-in
29***************************************************************************/
30
31#include "bstd.h"
32#include "bsynclib_state_machine.h"
33#include "bsynclib_state_machine_priv.h"
34
35BDBG_MODULE(synclib);
36
37/*
38Summary:
39Gets the default settings
40*/
41BERR_Code BSYNClib_StateMachine_GetDefaultSettings(
42        BSYNClib_StateMachine_Settings * psSettings /* [out] */
43)
44{
45        BERR_Code rc = BERR_SUCCESS;
46
47        BDBG_ASSERT(psSettings);
48
49        psSettings->cbStateChange.pfStateChange = NULL;
50        psSettings->cbStateChange.pvParm1 = NULL;
51        psSettings->cbStateChange.iParm2 = 0;
52
53        return rc;
54}
55
56/*
57Summary:
58Opens a state machine handle
59*/
60BERR_Code BSYNClib_StateMachine_Open(
61        const BSYNClib_StateMachine_Settings * psSettings,
62        BSYNClib_StateMachine_Handle * phMachine
63)
64{
65        BERR_Code rc = BERR_SUCCESS;
66        BSYNClib_StateMachine_Handle hMachine;
67
68        BDBG_ASSERT(phMachine);
69
70        hMachine = (BSYNClib_StateMachine_Handle)BKNI_Malloc(sizeof(struct BSYNClib_StateMachine_Impl));
71        if (!hMachine)
72        {
73                rc = BERR_OUT_OF_SYSTEM_MEMORY;
74                goto error;
75        }
76
77        BKNI_Memset(hMachine, 0, sizeof(struct BSYNClib_StateMachine_Impl));
78
79        if (psSettings)
80        {
81                hMachine->sSettings = *psSettings;
82        }
83
84        *phMachine = hMachine;
85
86        goto end;
87
88error:
89
90        *phMachine = NULL;
91
92end:
93        return rc;
94}
95
96/*
97Summary:
98Closes a state machine handle
99*/
100BERR_Code BSYNClib_StateMachine_Close(
101        BSYNClib_StateMachine_Handle hMachine
102)
103{
104        BERR_Code rc = BERR_SUCCESS;
105
106        BDBG_ASSERT(hMachine);
107
108        rc = BSYNClib_StateMachine_SendSignal(hMachine, BSYNClib_StateMachine_Signal_eStop);
109        if (rc) goto error;
110
111        BKNI_Free(hMachine);
112
113        goto end;
114       
115error:
116
117end:
118        return rc;
119}
120
121BERR_Code BSYNClib_StateMachine_SendSignal(
122        BSYNClib_StateMachine_Handle hMachine,
123        BSYNClib_StateMachine_Signal eSignal
124)
125{
126        BERR_Code rc = BERR_SUCCESS;
127
128        BDBG_ASSERT(hMachine);
129
130        switch (hMachine->sData.eState)
131        {
132                case BSYNClib_StateMachine_State_eAcquire:
133                        switch (eSignal)
134                        {
135                                case BSYNClib_StateMachine_Signal_eStart:
136                                        break;
137                                case BSYNClib_StateMachine_Signal_eCheckPassed:
138                                        hMachine->sData.eState = BSYNClib_StateMachine_State_eSync;
139                                        BSYNClib_StateMachine_FireStateChangeCallback(hMachine);
140                                        break;
141                                case BSYNClib_StateMachine_Signal_eCheckFailed:
142                                        break;
143                                case BSYNClib_StateMachine_Signal_eDataChanged:
144                                        break;
145                                case BSYNClib_StateMachine_Signal_eDelayApplied:
146                                        break;
147                                case BSYNClib_StateMachine_Signal_eStop:
148                                        hMachine->sData.eState = BSYNClib_StateMachine_State_eStopped;
149                                        BSYNClib_StateMachine_FireStateChangeCallback(hMachine);
150                                        break;
151                                default:
152                                        break;
153                        }
154                        break;
155                case BSYNClib_StateMachine_State_eSync:
156                        switch (eSignal)
157                        {
158                                case BSYNClib_StateMachine_Signal_eStart:
159                                        break;
160                                case BSYNClib_StateMachine_Signal_eCheckPassed:
161                                        break;
162                                case BSYNClib_StateMachine_Signal_eCheckFailed:
163                                        break;
164                                case BSYNClib_StateMachine_Signal_eDataChanged:
165                                        break;
166                                case BSYNClib_StateMachine_Signal_eDelayApplied:
167                                        hMachine->sData.eState = BSYNClib_StateMachine_State_eTrack;
168                                        BSYNClib_StateMachine_FireStateChangeCallback(hMachine);
169                                        break;
170                                case BSYNClib_StateMachine_Signal_eStop:
171                                        hMachine->sData.eState = BSYNClib_StateMachine_State_eStopped;
172                                        BSYNClib_StateMachine_FireStateChangeCallback(hMachine);
173                                        break;
174                                default:
175                                        break;
176                        }
177                        break;
178                case BSYNClib_StateMachine_State_eTrack:
179                        switch (eSignal)
180                        {
181                                case BSYNClib_StateMachine_Signal_eStart:
182                                        break;
183                                case BSYNClib_StateMachine_Signal_eCheckPassed:
184                                        break;
185                                case BSYNClib_StateMachine_Signal_eCheckFailed:
186                                        hMachine->sData.eState = BSYNClib_StateMachine_State_eAcquire;
187                                        BSYNClib_StateMachine_FireStateChangeCallback(hMachine);
188                                        break;
189                                case BSYNClib_StateMachine_Signal_eDataChanged:
190                                        hMachine->sData.eState = BSYNClib_StateMachine_State_eSync;
191                                        BSYNClib_StateMachine_FireStateChangeCallback(hMachine);
192                                        break;
193                                case BSYNClib_StateMachine_Signal_eDelayApplied:
194                                        break;
195                                case BSYNClib_StateMachine_Signal_eStop:
196                                        hMachine->sData.eState = BSYNClib_StateMachine_State_eStopped;
197                                        BSYNClib_StateMachine_FireStateChangeCallback(hMachine);
198                                        break;
199                                default:
200                                        break;
201                        }
202                        break;
203                case BSYNClib_StateMachine_State_eStopped:
204                        switch (eSignal)
205                        {
206                                case BSYNClib_StateMachine_Signal_eStart:
207                                        hMachine->sData.eState = BSYNClib_StateMachine_State_eAcquire;
208                                        BSYNClib_StateMachine_FireStateChangeCallback(hMachine);
209                                        break;
210                                case BSYNClib_StateMachine_Signal_eCheckPassed:
211                                        break;
212                                case BSYNClib_StateMachine_Signal_eCheckFailed:
213                                        break;
214                                case BSYNClib_StateMachine_Signal_eDataChanged:
215                                        break;
216                                case BSYNClib_StateMachine_Signal_eDelayApplied:
217                                        break;
218                                case BSYNClib_StateMachine_Signal_eStop:
219                                        break;
220                                default:
221                                        break;
222                        }
223                        break;
224                default:
225                        break;
226        }
227
228        hMachine->sStatus.eState = hMachine->sData.eState;
229       
230        return rc;
231}
232
233BERR_Code BSYNClib_StateMachine_FireStateChangeCallback(
234        BSYNClib_StateMachine_Handle hMachine
235)
236{
237        BERR_Code rc = BERR_SUCCESS;
238        BSYNClib_StateMachine_StateChangeCallback * pcbStateChange;
239
240        BDBG_ASSERT(hMachine);
241
242        pcbStateChange = &hMachine->sSettings.cbStateChange;
243
244        if (pcbStateChange->pfStateChange)
245        {
246                rc = pcbStateChange->pfStateChange(pcbStateChange->pvParm1, pcbStateChange->iParm2, hMachine->sData.eState);
247                if (rc) goto error;
248        }
249
250        goto end;
251       
252error:
253
254end:
255        return rc;
256}
257
258/*
259Summary:
260*/
261BERR_Code BSYNClib_StateMachine_GetStatus(
262        const BSYNClib_StateMachine_Handle hMachine,
263        BSYNClib_StateMachine_Status * psStatus
264)
265{
266        BERR_Code rc = BERR_SUCCESS;
267
268        BDBG_ASSERT(hMachine);
269        BDBG_ASSERT(psStatus);
270
271        *psStatus = hMachine->sStatus;
272
273        return rc;
274}
275
Note: See TracBrowser for help on using the repository browser.