/usr/include/OpenIPMI/internal/ipmi_control.h is in libopenipmi-dev 2.0.18-0ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 | /*
* ipmi_control.h
*
* MontaVista IPMI interface for dealing with controls
*
* Author: MontaVista Software, Inc.
* Corey Minyard <minyard@mvista.com>
* source@mvista.com
*
* Copyright 2002,2003 MontaVista Software Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef _IPMI_CONTROL_H
#define _IPMI_CONTROL_H
#include <OpenIPMI/ipmi_types.h>
#include <OpenIPMI/ipmi_addr.h>
/* The abstract type for controls. */
typedef struct ipmi_control_info_s ipmi_control_info_t;
/* Allocate a repository for holding controls for an MC. */
int ipmi_controls_alloc(ipmi_mc_t *mc, ipmi_control_info_t **new_controls);
/* Destroy a control repository and all the controls in it. */
int ipmi_controls_destroy(ipmi_control_info_t *controls);
/* Must be called with the _ipmi_domain_entity_lock() held. */
int _ipmi_control_get(ipmi_control_t *control);
/* Must be called with no locks held. */
void _ipmi_control_put(ipmi_control_t *control);
/* Return the number of controls in the data structure. */
unsigned int ipmi_controls_get_count(ipmi_control_info_t *controls);
/* Operations and callbacks for control operations. Operations on a
control that can be delayed should be serialized (to avoid user
confusion and for handling multi-part operations properly), thus
each control has an operation queue, only one operation at a time
may be running. If you want to do an operation that requires
sending a message and getting a response, you must put that
operation into the opq. When the handler you registered in the opq
is called, you can actually perform the operation. When your
operation completes (no matter what, you must call it, even if the
operation fails), you must call ipmi_control_opq_done. The control
will be locked properly for your callback. To handle the control
locking for you for command responses, you can send the message
with ipmi_control_send_command, it will return the response when it
comes in to your handler with the control locked. */
typedef void (*ipmi_control_rsp_cb)(ipmi_control_t *control,
int err,
ipmi_msg_t *rsp,
void *cb_data);
typedef struct ipmi_control_op_info_s
{
ipmi_control_id_t __control_id;
ipmi_control_t *__control;
void *__cb_data;
ipmi_control_op_cb __handler;
ipmi_control_rsp_cb __rsp_handler;
ipmi_msg_t *__rsp;
} ipmi_control_op_info_t;
/* Add an operation to the control operation queue. If nothing is in
the operation queue, the handler will be performed immediately. If
something else is currently being operated on, the operation will
be queued until other operations before it have been completed.
Then the handler will be called. */
int ipmi_control_add_opq(ipmi_control_t *control,
ipmi_control_op_cb handler,
ipmi_control_op_info_t *info,
void *cb_data);
/* When an operation is completed (even if it fails), this *MUST* be
called to cause the next operation to run. */
void ipmi_control_opq_done(ipmi_control_t *control);
/* Send an IPMI command to a specific MC. The response handler will
be called with the control locked. */
int ipmi_control_send_command(ipmi_control_t *control,
ipmi_mc_t *mc,
unsigned int lun,
ipmi_msg_t *msg,
ipmi_control_rsp_cb handler,
ipmi_control_op_info_t *info,
void *cb_data);
/* Send an IPMI command to a specific address on the BMC. This way,
if you don't have an MC to represent the address, you can still
send the command. The response handler will be called with the
control locked. */
int ipmi_control_send_command_addr(ipmi_domain_t *domain,
ipmi_control_t *control,
ipmi_addr_t *addr,
unsigned int addr_len,
ipmi_msg_t *msg,
ipmi_control_rsp_cb handler,
ipmi_control_op_info_t *info,
void *cb_data);
/* Set this if the control should be ignored for presence handling. */
void ipmi_control_set_ignore_for_presence(ipmi_control_t *control, int ignore);
int ipmi_control_get_ignore_for_presence(ipmi_control_t *control);
/* Allocate a control, it will not be associated with anything yet. */
int ipmi_control_alloc_nonstandard(ipmi_control_t **new_control);
/* Destroy a control. */
int ipmi_control_destroy(ipmi_control_t *control);
typedef void (*ipmi_control_destroy_cb)(ipmi_control_t *control,
void *cb_data);
/* Add a control for the given MC and put it into the given entity.
Note that control will NOT appear as owned by the MC, the MC is
used for the OS handler and such. The source_mc is used to show
which MC "owns" the creation of the control, and may be NULL if the
control is presumed to come from the "main" SDR repository. */
int ipmi_control_add_nonstandard(
ipmi_mc_t *mc,
ipmi_mc_t *source_mc,
ipmi_control_t *control,
unsigned int num,
ipmi_entity_t *ent,
ipmi_control_destroy_cb destroy_handler,
void *destroy_handler_cb_data);
typedef int (*ipmi_control_set_val_cb)(ipmi_control_t *control,
int *val,
ipmi_control_op_cb handler,
void *cb_data);
typedef int (*ipmi_control_get_val_cb)(ipmi_control_t *control,
ipmi_control_val_cb handler,
void *cb_data);
typedef int (*ipmi_control_set_display_string_cb)(ipmi_control_t *control,
unsigned int start_row,
unsigned int start_column,
char *str,
unsigned int len,
ipmi_control_op_cb handler,
void *cb_data);
typedef int (*ipmi_control_get_display_string_cb)(ipmi_control_t *control,
unsigned int start_row,
unsigned int start_column,
unsigned int len,
ipmi_control_str_cb handler,
void *cb_data);
typedef int (*ipmi_control_identifier_get_val_cb)(
ipmi_control_t *control,
ipmi_control_identifier_val_cb handler,
void *cb_data);
typedef int (*ipmi_control_identifier_set_val_cb)(ipmi_control_t *control,
unsigned char *val,
int length,
ipmi_control_op_cb handler,
void *cb_data);
typedef int (*ipmi_control_set_light_cb)(ipmi_control_t *control,
ipmi_light_setting_t *settings,
ipmi_control_op_cb handler,
void *cb_data);
typedef int (*ipmi_control_get_light_cb)(ipmi_control_t *control,
ipmi_light_settings_cb handler,
void *cb_data);
typedef struct ipmi_control_cbs_s
{
ipmi_control_set_val_cb set_val;
ipmi_control_get_val_cb get_val;
ipmi_control_set_display_string_cb set_display_string;
ipmi_control_get_display_string_cb get_display_string;
ipmi_control_identifier_get_val_cb get_identifier_val;
ipmi_control_identifier_set_val_cb set_identifier_val;
ipmi_control_set_light_cb set_light;
ipmi_control_get_light_cb get_light;
} ipmi_control_cbs_t;
/* For settings-based LEDs. */
int ipmi_control_add_light_color_support(ipmi_control_t *control,
int light_num,
unsigned int color);
int ipmi_control_light_set_has_local_control(ipmi_control_t *control,
int light_num,
int val);
void ipmi_control_identifier_set_max_length(ipmi_control_t *control,
unsigned int val);
void ipmi_control_set_id(ipmi_control_t *control, char *id,
enum ipmi_str_type_e type, int length);
void ipmi_control_set_type(ipmi_control_t *control, int val);
void ipmi_control_set_settable(ipmi_control_t *control, int val);
void ipmi_control_set_readable(ipmi_control_t *control, int val);
void ipmi_control_set_ignore_if_no_entity(ipmi_control_t *control,
int ignore_if_no_entity);
ipmi_domain_t *ipmi_control_get_domain(ipmi_control_t *control);
/* Returns true if this control is a hot-swap indicator, meaning that
is is used to indicate to the operator when it is save to remove a
hot-swappable device. Setting "val" to one enables the control as
a hot-swap power control. The 'val" setting is retured by the get
function. The active_val is the value to use to turn off the
indicator (in active state). The req_act_val is the value to set
when requesting deactivation. The req_deact_val is the value to set
when requesting deactivation. The inactive val is the value to use
when inactive. */
int ipmi_control_is_hot_swap_indicator(ipmi_control_t *control,
int *req_act_val,
int *active_val,
int *req_deact_val,
int *inactive_val);
void ipmi_control_set_hot_swap_indicator(ipmi_control_t *control,
int val,
int req_act_val,
int active_val,
int req_deact_val,
int inactive_val);
/* Get/set the control as a hot-swap power control. This must be set
to 1 to turn the power on and zero to turn it off. */
int ipmi_control_is_hot_swap_power(ipmi_control_t *control);
void ipmi_control_set_hot_swap_power(ipmi_control_t *control, int val);
/* Can this control generate events? */
void ipmi_control_set_has_events(ipmi_control_t *control, int val);
/* Allow OEM code to call the event handlers. Note that if the event
is handled by the handlers, then "*event" will be set to NULL and
*handled will be set to true. If the event is not handled, then
*handled will be set to false and the event value will be
unchanged. This is to help the OEM handlers only deliver the event
once to the user. */
void ipmi_control_call_val_event_handlers(ipmi_control_t *control,
int *valid_vals,
int *vals,
ipmi_event_t **event,
int *handled);
typedef struct ipmi_control_transition_s
{
unsigned int color;
unsigned int time;
} ipmi_control_transition_t;
typedef struct ipmi_control_value_s
{
unsigned int num_transitions;
ipmi_control_transition_t *transitions;
} ipmi_control_value_t;
typedef struct ipmi_control_light_s
{
unsigned int num_values;
ipmi_control_value_t *values;
} ipmi_control_light_t;
void ipmi_control_light_set_lights(ipmi_control_t *control,
unsigned int num_lights,
ipmi_control_light_t *lights);
void ipmi_control_set_num_elements(ipmi_control_t *control, unsigned int val);
int ipmi_control_get_num(ipmi_control_t *control,
int *lun,
int *num);
typedef void (*ipmi_control_cleanup_oem_info_cb)(ipmi_control_t *control,
void *oem_info);
void ipmi_control_set_oem_info(ipmi_control_t *control, void *oem_info,
ipmi_control_cleanup_oem_info_cb cleanup_handler);
void *ipmi_control_get_oem_info(ipmi_control_t *control);
/* Can be used by OEM code to replace some or all of the callbacks for
a control. */
void ipmi_control_get_callbacks(ipmi_control_t *control,
ipmi_control_cbs_t *cbs);
void ipmi_control_set_callbacks(ipmi_control_t *control,
ipmi_control_cbs_t *cbs);
/* Get the MC that the control is in. */
ipmi_mc_t *ipmi_control_get_mc(ipmi_control_t *control);
/* OpenIPMI defines controls f0-ff for its own use, don't use them for your
controls. Here's some controls it defines. */
#define IPMI_CHASSIS_POWER_CONTROL 0xf0
#define IPMI_CHASSIS_RESET_CONTROL 0xf1
/* Do a pointer callback but ignore the sequence number in the MC.
This is primarily for handling incoming events, where the sequence
number doesn't matter. */
int ipmi_control_pointer_noseq_cb(ipmi_control_id_t id,
ipmi_control_ptr_cb handler,
void *cb_data);
#endif /* _IPMI_CONTROL_H */
|