ipmi_sol.h

Go to the documentation of this file.

/*
 * ipmi_sol.h
 *
 * IPMI Serial-over-LAN Client Code
 *
 * Author: Cyclades Australia Pty. Ltd.
 *         Darius Davis <darius.davis@cyclades.com>
 *
 * Copyright 2005 Cyclades Australia Pty. Ltd.
 *
 *  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_SOL_H
#define _IPMI_SOL_H

#ifdef __cplusplus
extern "C" {
#endif

#define IPMI_SOL_BMC_TRANSMIT_QUEUE                0x01
#define IPMI_SOL_BMC_RECEIVE_QUEUE                 0x02
#define IPMI_SOL_MANAGEMENT_CONSOLE_TRANSMIT_QUEUE 0x04
#define IPMI_SOL_MANAGEMENT_CONSOLE_RECEIVE_QUEUE  0x08

#define IPMI_SOL_BMC_QUEUES (IPMI_SOL_BMC_TRANSMIT_QUEUE \
                             | IPMI_SOL_BMC_RECEIVE_QUEUE)

#define IPMI_SOL_MANAGEMENT_CONSOLE_QUEUES \
        (IPMI_SOL_MANAGEMENT_CONSOLE_TRANSMIT_QUEUE \
         | IPMI_SOL_MANAGEMENT_CONSOLE_RECEIVE_QUEUE)

#define IPMI_SOL_ALL_QUEUES (IPMI_SOL_BMC_QUEUES \
                             | IPMI_SOL_MANAGEMENT_CONSOLE_QUEUES)


#define IPMI_SOL_BIT_RATE_DEFAULT               0x00
#define IPMI_SOL_BIT_RATE_9600                  0x06
#define IPMI_SOL_BIT_RATE_19200                 0x07
#define IPMI_SOL_BIT_RATE_38400                 0x08
#define IPMI_SOL_BIT_RATE_57600                 0x09
#define IPMI_SOL_BIT_RATE_115200                0x0a


typedef enum
{
    /* The connection is closed; no data transfer is possible. */
    ipmi_sol_state_closed,

    /* The connection is currently starting up; no data transfer yet. */
    ipmi_sol_state_connecting,

    /* The connection is up and operational. */
    ipmi_sol_state_connected,

    /* The connection is up, but the BMC has reported Character
       Transfer Unavailable.  This means the BMC is flow-controlling
       us. */
    ipmi_sol_state_connected_ctu,

    /* The connection is going down.  No data transfer. */
    ipmi_sol_state_closing
} ipmi_sol_state;


typedef enum
{
    ipmi_sol_serial_alerts_fail = 0,
    ipmi_sol_serial_alerts_deferred = 1,
    ipmi_sol_serial_alerts_succeed = 2
} ipmi_sol_serial_alert_behavior;


typedef struct ipmi_sol_conn_s ipmi_sol_conn_t;


typedef void (*ipmi_sol_connection_state_cb)(ipmi_sol_conn_t *conn,
                                             ipmi_sol_state  state,
                                             int             error,
                                             void            *cb_data);


typedef void (*ipmi_sol_transmit_complete_cb)(ipmi_sol_conn_t *conn,
                                              int             error,
                                              void            *cb_data);


typedef int (*ipmi_sol_data_received_cb)(ipmi_sol_conn_t *conn,
                                         const void      *buf,
                                         size_t          count,
                                         void            *cb_data);


typedef void (*ipmi_sol_flush_complete_cb)(ipmi_sol_conn_t *conn,
                                           int             error,
                                           int         queue_selectors_flushed,
                                           void            *cb_data);


typedef void (*ipmi_sol_break_detected_cb)(ipmi_sol_conn_t *conn,
                                           void            *cb_data);


typedef void (*ipmi_sol_bmc_transmit_overrun_cb)(ipmi_sol_conn_t *conn,
                                                 void            *cb_data);


int ipmi_sol_create(ipmi_con_t      *ipmi,
                    ipmi_sol_conn_t **sol_conn);



/**************************************************************************
 ** IPMI SoL connection configuration
 **/


int ipmi_sol_register_connection_state_callback(ipmi_sol_conn_t *conn,
                                               ipmi_sol_connection_state_cb cb,
                                                void            *cb_data);
int ipmi_sol_deregister_connection_state_callback(ipmi_sol_conn_t *conn,
                                               ipmi_sol_connection_state_cb cb,
                                                  void *cb_data);

int ipmi_sol_register_data_received_callback(ipmi_sol_conn_t *conn,
                                             ipmi_sol_data_received_cb cb,
                                             void            *cb_data);
int ipmi_sol_deregister_data_received_callback(ipmi_sol_conn_t *conn,
                                               ipmi_sol_data_received_cb cb,
                                               void            *cb_data);

int ipmi_sol_register_break_detected_callback(ipmi_sol_conn_t *conn,
                                              ipmi_sol_break_detected_cb cb,
                                              void            *cb_data);
int ipmi_sol_deregister_break_detected_callback(ipmi_sol_conn_t *conn,
                                                ipmi_sol_break_detected_cb cb,
                                                void            *cb_data);

int ipmi_sol_register_bmc_transmit_overrun_callback(ipmi_sol_conn_t *conn,
                                           ipmi_sol_bmc_transmit_overrun_cb cb,
                                                    void            *cb_data);
int ipmi_sol_deregister_bmc_transmit_overrun_callback(ipmi_sol_conn_t *conn,
                                           ipmi_sol_bmc_transmit_overrun_cb cb,
                                                      void           *cb_data);


void ipmi_sol_set_ACK_timeout(ipmi_sol_conn_t *conn, int timeout_usec);

int ipmi_sol_get_ACK_timeout(ipmi_sol_conn_t *conn);


void ipmi_sol_set_ACK_retries(ipmi_sol_conn_t *conn, int retries);

int ipmi_sol_get_ACK_retries(ipmi_sol_conn_t *conn);

int ipmi_sol_set_use_authentication(ipmi_sol_conn_t *conn,
                                    int             use_authentication);

int ipmi_sol_get_use_authentication(ipmi_sol_conn_t *conn);


int ipmi_sol_set_use_encryption(ipmi_sol_conn_t *conn, int use_encryption);

int ipmi_sol_get_use_encryption(ipmi_sol_conn_t *conn);


int ipmi_sol_set_shared_serial_alert_behavior(ipmi_sol_conn_t *conn,
                                      ipmi_sol_serial_alert_behavior behavior);

ipmi_sol_serial_alert_behavior ipmi_sol_get_shared_serial_alert_behavior
                                                      (ipmi_sol_conn_t *conn);


int ipmi_sol_set_deassert_CTS_DCD_DSR_on_connect(ipmi_sol_conn_t *conn,
                                                 int             assert);

int ipmi_sol_get_deassert_CTS_DCD_DSR_on_connect(ipmi_sol_conn_t *conn);


int ipmi_sol_set_bit_rate(ipmi_sol_conn_t *conn, unsigned char rate);


unsigned char ipmi_sol_get_bit_rate(ipmi_sol_conn_t *conn);


int ipmi_sol_open(ipmi_sol_conn_t *conn);


int ipmi_sol_close(ipmi_sol_conn_t *conn);


int ipmi_sol_force_close(ipmi_sol_conn_t *conn);


int ipmi_sol_free(ipmi_sol_conn_t *conn);



/******************************************************************************
 ** IPMI SoL write operations (and sundry operations that cause a transmit)
 **/
 
int ipmi_sol_write(ipmi_sol_conn_t *conn,
                   const void      *buf,
                   int             count,
                   ipmi_sol_transmit_complete_cb cb,
                   void            *cb_data);


int ipmi_sol_release_nack(ipmi_sol_conn_t *conn);


int ipmi_sol_send_break(ipmi_sol_conn_t *conn,
                        ipmi_sol_transmit_complete_cb cb,
                        void            *cb_data);


int ipmi_sol_set_CTS_assertable(ipmi_sol_conn_t *conn,
                                int             asserted,
                                ipmi_sol_transmit_complete_cb cb,
                                void            *cb_data);


int ipmi_sol_set_DCD_DSR_asserted(ipmi_sol_conn_t *conn,
                                  int             asserted,
                                  ipmi_sol_transmit_complete_cb cb,
                                  void            *cb_data);


int ipmi_sol_set_RI_asserted(ipmi_sol_conn_t *conn,
                             int             asserted,
                             ipmi_sol_transmit_complete_cb cb,
                             void            *cb_data);


int ipmi_sol_flush(ipmi_sol_conn_t *conn,
                   int             queue_selectors,
                   ipmi_sol_flush_complete_cb cb,
                   void            *cb_data);

#ifdef __cplusplus
}
#endif

#endif /* _IPMI_SOL_H */

---

© sourcejam.com 2005-2008