1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/**
* @file new_sim_control_discrete.cpp
*
* The file includes a class for discrete control handling:\n
* NewSimulatorControlDiscrete
*
* @author Lars Wetzel <larswetzel@users.sourceforge.net>
* @version 0.1
* @date 2010
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. This
* file and program are licensed under a BSD style license. See
* the Copying file included with the OpenHPI distribution for
* full licensing terms.
*
*/
#include "new_sim_control.h"
#include "new_sim_control_discrete.h"
#include "new_sim_domain.h"
/**
* Constructor
**/
NewSimulatorControlDiscrete::NewSimulatorControlDiscrete( NewSimulatorResource *res,
SaHpiRdrT rdr,
SaHpiCtrlStateDiscreteT state,
SaHpiCtrlModeT mode )
: NewSimulatorControl( res, rdr, mode ) {
memcpy(&m_rec, &rdr.RdrTypeUnion.CtrlRec.TypeUnion.Discrete, sizeof( SaHpiCtrlRecDiscreteT ));
memcpy(&m_state, &state, sizeof( SaHpiCtrlStateDiscreteT ));
}
/**
* Destructor
**/
NewSimulatorControlDiscrete::~NewSimulatorControlDiscrete() {}
/**
* A rdr structure is filled with the data
*
* This method is called by method NewSimulatorRdr::Populate().
*
* @param resource Address of resource structure
* @param rdr Address of rdr structure
*
* @return true
**/
bool NewSimulatorControlDiscrete::CreateRdr( SaHpiRptEntryT &resource, SaHpiRdrT &rdr ) {
if ( NewSimulatorControl::CreateRdr( resource, rdr ) == false )
return false;
memcpy(&rdr.RdrTypeUnion.CtrlRec.TypeUnion.Discrete,
&m_rec, sizeof( SaHpiCtrlRecDiscreteT ));
return true;
}
/**
* HPI function saHpiControlGet()
*
* See also the description of the function inside the specification or header file.
* Copying the internal values (if a read is allowed).
*
* @param mode address to be filled
* @param state address to be filled
*
* @return HPI return code
**/
SaErrorT NewSimulatorControlDiscrete::GetState( SaHpiCtrlModeT &mode, SaHpiCtrlStateT &state ) {
if (m_write_only == SAHPI_TRUE)
return SA_ERR_HPI_INVALID_CMD;
if ( &mode != NULL ) {
mode = m_ctrl_mode;
}
if ( &state != NULL ) {
state.Type = m_type;
memcpy( &state.StateUnion.Discrete, &m_state, sizeof( SaHpiCtrlStateDiscreteT ));
}
return SA_OK;
}
/**
* HPI function saHpiControlSet()
*
* See also the description of the function inside the specification or header file.
* Copying the internal values (if a read is allowed).
*
* @param mode address to be set
* @param state address to be set
*
* @return HPI return code
**/
SaErrorT NewSimulatorControlDiscrete::SetState( const SaHpiCtrlModeT &mode,
const SaHpiCtrlStateT &state ) {
if (&mode == NULL)
return SA_ERR_HPI_INVALID_PARAMS;
if ((m_def_mode.ReadOnly == SAHPI_TRUE) &&
(mode != m_def_mode.Mode))
return SA_ERR_HPI_READ_ONLY;
if (mode == SAHPI_CTRL_MODE_AUTO) {
m_ctrl_mode = mode;
return SA_OK;
}
if (mode != SAHPI_CTRL_MODE_MANUAL)
return SA_ERR_HPI_INVALID_PARAMS;
if (&state == NULL)
return SA_ERR_HPI_INVALID_PARAMS;
if (state.Type != m_type)
return SA_ERR_HPI_INVALID_DATA;
m_state = state.StateUnion.Discrete;
m_ctrl_mode = mode;
return SA_OK;
}
/**
* Dump the control information
*
* @param dump Address of the log
*
**/
void NewSimulatorControlDiscrete::Dump( NewSimulatorLog &dump ) const {
dump << "Discrete control " << m_id_string << ";\n";
dump << "ControlNum " << m_num << ";\n";
dump << "Oem" << m_oem << ";\n";
dump << "State" << m_state << ";\n";
dump << "Mode" << m_ctrl_mode << ";\n";
}
|
