sfp.h

Go to the documentation of this file.

/*************************************************************
 * <bsn.cl fy=2014 v=onl>
 *
 *        Copyright 2014, 2015 Big Switch Networks, Inc.
 *
 * Licensed under the Eclipse Public License, Version 1.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 *        http://www.eclipse.org/legal/epl-v10.html
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific
 * language governing permissions and limitations under the
 * License.
 *
 * </bsn.cl>
 *********************************************************/
#ifndef __ONLP_SFP_H__
#define __ONLP_SFP_H__

#include <onlp/onlp_config.h>
#include <onlp/onlp.h>
#include <onlp/oids.h>
#include <AIM/aim_bitmap.h>
#include <AIM/aim_pvs.h>
#include <sff/sff.h>
#include <sff/dom.h>

/* <auto.start.enum(tag:sfp1).define> */
typedef enum onlp_sfp_control_e {
    ONLP_SFP_CONTROL_RESET,
    ONLP_SFP_CONTROL_RESET_STATE,
    ONLP_SFP_CONTROL_RX_LOS,
    ONLP_SFP_CONTROL_TX_FAULT,
    ONLP_SFP_CONTROL_TX_DISABLE,
    ONLP_SFP_CONTROL_TX_DISABLE_CHANNEL,
    ONLP_SFP_CONTROL_LP_MODE,
    ONLP_SFP_CONTROL_POWER_OVERRIDE,
    ONLP_SFP_CONTROL_LAST = ONLP_SFP_CONTROL_POWER_OVERRIDE,
    ONLP_SFP_CONTROL_COUNT,
    ONLP_SFP_CONTROL_INVALID = -1,
} onlp_sfp_control_t;
/* <auto.end.enum(tag:sfp1).define> */

/* <auto.start.enum(tag:sfp2).define> */
typedef enum onlp_sfp_control_flag_e {
    ONLP_SFP_CONTROL_FLAG_RESET = (1 << 0),
    ONLP_SFP_CONTROL_FLAG_RESET_STATE = (1 << 1),
    ONLP_SFP_CONTROL_FLAG_RX_LOS = (1 << 2),
    ONLP_SFP_CONTROL_FLAG_TX_FAULT = (1 << 3),
    ONLP_SFP_CONTROL_FLAG_TX_DISABLE = (1 << 4),
    ONLP_SFP_CONTROL_FLAG_TX_DISABLE_CHANNEL = (1 << 5),
    ONLP_SFP_CONTROL_FLAG_LP_MODE = (1 << 6),
    ONLP_SFP_CONTROL_FLAG_POWER_OVERRIDE = (1 << 7),
} onlp_sfp_control_flag_t;

typedef enum onlp_sfp_type_e {
    ONLP_SFP_TYPE_SFP,
    ONLP_SFP_TYPE_QSFP,
    ONLP_SFP_TYPE_SFP28,
    ONLP_SFP_TYPE_QSFP28,
    ONLP_SFP_TYPE_LAST = ONLP_SFP_TYPE_QSFP28,
    ONLP_SFP_TYPE_COUNT,
    ONLP_SFP_TYPE_INVALID = -1,
} onlp_sfp_type_t;
/* <auto.end.enum(tag:sfp2).define> */



#define ONLP_SFP_BLOCK_DATA_SIZE 256


typedef struct onlp_sfp_info_t {
    onlp_oid_hdr_t hdr;

    onlp_sfp_type_t type;

    uint32_t controls;


    /*
     * The following fields are only relevant
     * if the SFP is present.
     */


    sff_info_t sff;

    sff_dom_info_t dom;

    struct {
        uint8_t a0[ONLP_SFP_BLOCK_DATA_SIZE];

        uint8_t a2[ONLP_SFP_BLOCK_DATA_SIZE];
    } bytes;

} onlp_sfp_info_t;

typedef aim_bitmap256_t onlp_sfp_bitmap_t;


int onlp_sfp_sw_init(void);

int onlp_sfp_hw_init(uint32_t flags);

int onlp_sfp_sw_denit(void);

void onlp_sfp_bitmap_t_init(onlp_sfp_bitmap_t* bmap);

int onlp_sfp_bitmap_get(onlp_sfp_bitmap_t* bmap);

int onlp_sfp_info_get(onlp_oid_t port, onlp_sfp_info_t* info);

int onlp_sfp_info_dom_get(onlp_oid_t port, onlp_sfp_info_t* info);

int onlp_sfp_hdr_get(onlp_oid_t port, onlp_oid_hdr_t* rv);

int onlp_sfp_port_valid(onlp_oid_t port);

int onlp_sfp_type_get(onlp_oid_t port, onlp_sfp_type_t* rtype);

int onlp_sfp_is_present(onlp_oid_t port);

int onlp_sfp_presence_bitmap_get(onlp_sfp_bitmap_t* dst);


int onlp_sfp_rx_los_bitmap_get(onlp_sfp_bitmap_t* dst);

int onlp_sfp_dev_read(onlp_oid_t port, int devaddr, int addr,
                      uint8_t* dst, int count);

int onlp_sfp_dev_alloc_read(onlp_oid_t port,
                            int devaddr, int addr, int count,
                            uint8_t** rv);

int onlp_sfp_dev_write(onlp_oid_t port, int devaddr, int addr,
                       uint8_t* src, int count);

int onlp_sfp_dev_readb(onlp_oid_t port, int devaddr, int addr);

int onlp_sfp_dev_writeb(onlp_oid_t port, int devaddr, int addr,
                        uint8_t value);

int onlp_sfp_dev_readw(onlp_oid_t port, int devaddr, int addr);

int onlp_sfp_dev_writew(onlp_oid_t port, int devaddr, int addr,
                        uint16_t value);



int onlp_sfp_post_insert(onlp_oid_t port, sff_info_t* info);

int onlp_sfp_control_set(onlp_oid_t port, onlp_sfp_control_t control, int value);

int onlp_sfp_control_get(onlp_oid_t port, onlp_sfp_control_t control,
                         int* value);

int onlp_sfp_control_flags_get(onlp_oid_t port, uint32_t* flags);


int onlp_sfp_info_to_user_json(onlp_sfp_info_t* info, cJSON** rv, uint32_t flags);

int onlp_sfp_info_to_json(onlp_sfp_info_t* info, cJSON** rv, uint32_t flags);


int onlp_sfp_info_from_json(cJSON* cj, onlp_sfp_info_t* info);

int onlp_sfp_sw_denit(void);

int onlp_sfp_hw_denit(void);

int onlp_sfp_inventory_show(aim_pvs_t* pvs);

/******************************************************************************
 *
 * Enumeration Support Definitions.
 *
 * Please do not add additional code beyond this point.
 *
 *****************************************************************************/
/* <auto.start.enum(tag:sfp1).supportheader> */
#define ONLP_SFP_CONTROL_STRINGS \
{\
    "RESET", \
    "RESET_STATE", \
    "RX_LOS", \
    "TX_FAULT", \
    "TX_DISABLE", \
    "TX_DISABLE_CHANNEL", \
    "LP_MODE", \
    "POWER_OVERRIDE", \
}

const char* onlp_sfp_control_name(onlp_sfp_control_t e);

int onlp_sfp_control_value(const char* str, onlp_sfp_control_t* e, int substr);

const char* onlp_sfp_control_desc(onlp_sfp_control_t e);

#define ONLP_SFP_CONTROL_VALID(_e) \
    ( (0 <= (_e)) && ((_e) <= ONLP_SFP_CONTROL_POWER_OVERRIDE))

extern aim_map_si_t onlp_sfp_control_map[];
extern aim_map_si_t onlp_sfp_control_desc_map[];
/* <auto.end.enum(tag:sfp1).supportheader> */

/* <auto.start.enum(tag:sfp2).supportheader> */
const char* onlp_sfp_control_flag_name(onlp_sfp_control_flag_t e);

int onlp_sfp_control_flag_value(const char* str, onlp_sfp_control_flag_t* e, int substr);

const char* onlp_sfp_control_flag_desc(onlp_sfp_control_flag_t e);

int onlp_sfp_control_flag_valid(onlp_sfp_control_flag_t e);

#define ONLP_SFP_CONTROL_FLAG_VALID(_e) \
    (onlp_sfp_control_flag_valid((_e)))

extern aim_map_si_t onlp_sfp_control_flag_map[];
extern aim_map_si_t onlp_sfp_control_flag_desc_map[];

#define ONLP_SFP_TYPE_STRINGS \
{\
    "SFP", \
    "QSFP", \
    "SFP28", \
    "QSFP28", \
}

const char* onlp_sfp_type_name(onlp_sfp_type_t e);

int onlp_sfp_type_value(const char* str, onlp_sfp_type_t* e, int substr);

const char* onlp_sfp_type_desc(onlp_sfp_type_t e);

#define ONLP_SFP_TYPE_VALID(_e) \
    ( (0 <= (_e)) && ((_e) <= ONLP_SFP_TYPE_QSFP28))

extern aim_map_si_t onlp_sfp_type_map[];
extern aim_map_si_t onlp_sfp_type_desc_map[];
/* <auto.end.enum(tag:sfp2).supportheader> */

#endif /* __ONLP_SFP_H__ */
/* @} */