/*

  Copyright (c) Kontron. All right reserved

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * Redistribution of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 *

 * Redistribution in binary form must reproduce the above copyright

 * notice, this list of conditions and the following disclaimer in the

 * documentation and/or other materials provided with the distribution.

 *

 * Neither the name of Kontron, or the names of

 * contributors may be used to endorse or promote products derived

 * from this software without specific prior written permission.

 *

 * This software is provided "AS IS," without a warranty of any kind.

 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,

 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A

 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.

 * DELL COMPUTERS ("DELL") AND ITS LICENSORS SHALL NOT BE LIABLE

 * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING

 * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL

 * DELL OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,

 * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR

 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF

 * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,

 * EVEN IF DELL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

 */

#include <ipmitool/ipmi_intf.h>

#include <ipmitool/ipmi_picmg.h>

#include <ipmitool/ipmi_fru.h>		/* for access to link descriptor defines */

#include <ipmitool/ipmi_strings.h>

#include <ipmitool/log.h>

#define PICMG_EXTENSION_ATCA_MAJOR_VERSION  2

#define PICMG_EXTENSION_AMC0_MAJOR_VERSION  4

#define PICMG_EXTENSION_UTCA_MAJOR_VERSION  5

#define PICMG_EKEY_MODE_QUERY          0

#define PICMG_EKEY_MODE_PRINT_ALL      1

#define PICMG_EKEY_MODE_PRINT_ENABLED  2

#define PICMG_EKEY_MODE_PRINT_DISABLED 3

#define PICMG_EKEY_MAX_CHANNEL          16

#define PICMG_EKEY_MAX_FABRIC_CHANNEL   15

#define PICMG_EKEY_MAX_INTERFACE 3

#define PICMG_EKEY_AMC_MAX_CHANNEL  16

#define PICMG_EKEY_AMC_MAX_DEVICE   15 /* 4 bits */

typedef enum picmg_bused_resource_mode {

	PICMG_BUSED_RESOURCE_SUMMARY,

} t_picmg_bused_resource_mode ;

typedef enum picmg_card_type {

	PICMG_CARD_TYPE_CPCI,

	PICMG_CARD_TYPE_ATCA,

	PICMG_CARD_TYPE_AMC,

	PICMG_CARD_TYPE_RESERVED

} t_picmg_card_type ;

/* This is the version of the PICMG Extenstion */

static t_picmg_card_type PicmgCardType = PICMG_CARD_TYPE_RESERVED;

void

ipmi_picmg_help (void)

{

	lprintf(LOG_NOTICE, "PICMG commands:");

	lprintf(LOG_NOTICE, " properties           - get PICMG properties");

	lprintf(LOG_NOTICE, " frucontrol           - FRU control");

	lprintf(LOG_NOTICE, " addrinfo             - get address information");

	lprintf(LOG_NOTICE, " activate             - activate a FRU");

	lprintf(LOG_NOTICE, " deactivate           - deactivate a FRU");

	lprintf(LOG_NOTICE, " policy get           - get the FRU activation policy");

	lprintf(LOG_NOTICE, " policy set           - set the FRU activation policy");

	lprintf(LOG_NOTICE, " portstate get        - get port state");

	lprintf(LOG_NOTICE,

			" portstate getdenied  - get all denied[disabled] port description");

	lprintf(LOG_NOTICE,

			" portstate getgranted - get all granted[enabled] port description");

	lprintf(LOG_NOTICE,

			" portstate getall     - get all port state description");

	lprintf(LOG_NOTICE, " portstate set        - set port state");

	lprintf(LOG_NOTICE, " amcportstate get     - get port state");

	lprintf(LOG_NOTICE, " amcportstate set     - set port state");

	lprintf(LOG_NOTICE, " led prop             - get led properties");

	lprintf(LOG_NOTICE, " led cap              - get led color capabilities");

	lprintf(LOG_NOTICE, " led get              - get led state");

	lprintf(LOG_NOTICE, " led set              - set led state");

	lprintf(LOG_NOTICE, " power get            - get power level info");

	lprintf(LOG_NOTICE, " power set            - set power level");

	lprintf(LOG_NOTICE, " clk get              - get clk state");

	lprintf(LOG_NOTICE,

			" clk getdenied        - get all(up to 16) denied[disabled] clock descriptions");

	lprintf(LOG_NOTICE,

			" clk getgranted       - get all(up to 16) granted[enabled] clock descriptions");

	lprintf(LOG_NOTICE,

			" clk getall           - get all(up to 16) clock descriptions");

	lprintf(LOG_NOTICE, " clk set              - set clk state");

	lprintf(LOG_NOTICE,

			" busres summary       - display brief bused resource status info");

}

struct sAmcAddrMap {

	unsigned char ipmbLAddr;

	char*         amcBayId;

	unsigned char siteNum;

} amcAddrMap[] = {

	{0xFF, "reserved", 0},

	{0x72, "A1"      , 1},

	{0x74, "A2"      , 2},

	{0x76, "A3"      , 3},

	{0x78, "A4"      , 4},

	{0x7A, "B1"      , 5},

	{0x7C, "B2"      , 6},

	{0x7E, "B3"      , 7},

	{0x80, "B4"      , 8},

	{0x82, "reserved", 0},

	{0x84, "reserved", 0},

	{0x86, "reserved", 0},

	{0x88, "reserved", 0},

};

/* is_amc_channel - wrapper to convert user input into integer

 * AMC Channel range seems to be <0..255>, bits [7:0]

 *

 * @argv_ptr: source string to convert from; usually argv

 * @amc_chan_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_amc_channel(const char *argv_ptr, uint8_t *amc_chan_ptr)

{

	if (!argv_ptr || !amc_chan_ptr) {

		lprintf(LOG_ERR, "is_amc_channel(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, amc_chan_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given AMC Channel '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_amc_dev - wrapper to convert user input into integer.

 * AMC Dev ID limits are uknown.

 *

 * @argv_ptr: source string to convert from; usually argv

 * @amc_dev_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_amc_dev(const char *argv_ptr, int32_t *amc_dev_ptr)

{

	if (!argv_ptr || !amc_dev_ptr) {

		lprintf(LOG_ERR, "is_amc_dev(): invalid argument(s).");

		return (-1);

	}

	if (str2int(argv_ptr, amc_dev_ptr) == 0 && *amc_dev_ptr >= 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given PICMG Device '%s' is invalid.",

			argv_ptr);

	return (-1);

}

/* is_amc_intf - wrapper to convert user input into integer.

 * AMC Interface (ID) limits are uknown.

 *

 * @argv_ptr: source string to convert from; usually argv

 * @amc_intf_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_amc_intf(const char *argv_ptr, int32_t *amc_intf_ptr)

{

	if (!argv_ptr || !amc_intf_ptr) {

		lprintf(LOG_ERR, "is_amc_intf(): invalid argument(s).");

		return (-1);

	}

	if (str2int(argv_ptr, amc_intf_ptr) == 0 && *amc_intf_ptr >= 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given PICMG Interface '%s' is invalid.",

			argv_ptr);

	return (-1);

}

/* is_amc_port - wrapper to convert user input into integer.

 * AMC Port limits are uknown.

 *

 * @argv_ptr: source string to convert from; usually argv

 * @amc_port_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_amc_port(const char *argv_ptr, int32_t *amc_port_ptr)

{

	if (!argv_ptr || !amc_port_ptr) {

		lprintf(LOG_ERR, "is_amc_port(): invalid argument(s).");

		return (-1);

	}

	if (str2int(argv_ptr, amc_port_ptr) == 0 && *amc_port_ptr >= 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given PICMG Port '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_clk_acc - wrapper to convert user input into integer.

 * Clock Accuracy limits are uknown[1byte by spec].

 *

 * @argv_ptr: source string to convert from; usually argv

 * @clk_acc_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_clk_acc(const char *argv_ptr, uint8_t *clk_acc_ptr)

{

	if (!argv_ptr || !clk_acc_ptr) {

		lprintf(LOG_ERR, "is_clk_acc(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, clk_acc_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Clock Accuracy '%s' is invalid.",

			argv_ptr);

	return (-1);

}

/* is_clk_family - wrapper to convert user input into integer.

 * Clock Family limits are uknown[1byte by spec].

 *

 * @argv_ptr: source string to convert from; usually argv

 * @clk_family_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_clk_family(const char *argv_ptr, uint8_t *clk_family_ptr)

{

	if (!argv_ptr || !clk_family_ptr) {

		lprintf(LOG_ERR, "is_clk_family(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, clk_family_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Clock Family '%s' is invalid.",

			argv_ptr);

	return (-1);

}

/* is_clk_freq - wrapper to convert user input into integer.

 * Clock Frequency limits are uknown, but specification says

 * 3Bytes + 1B checksum

 *

 * @argv_ptr: source string to convert from; usually argv

 * @clk_freq_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_clk_freq(const char *argv_ptr, uint32_t *clk_freq_ptr)

{

	if (!argv_ptr || !clk_freq_ptr) {

		lprintf(LOG_ERR, "is_clk_freq(): invalid argument(s).");

		return (-1);

	}

	if (str2uint(argv_ptr, clk_freq_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Clock Frequency '%s' is invalid.",

			argv_ptr);

	return (-1);

}

/* is_clk_id - wrapper to convert user input into integer.

 * Clock ID limits are uknown, however it's 1B by specification and I've

 * found two ranges: <1..5> or <0..15>

 *

 * @argv_ptr: source string to convert from; usually argv

 * @clk_id_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_clk_id(const char *argv_ptr, uint8_t *clk_id_ptr)

{

	if (!argv_ptr || !clk_id_ptr) {

		lprintf(LOG_ERR, "is_clk_id(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, clk_id_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Clock ID '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_clk_index - wrapper to convert user input into integer.

 * Clock Index limits are uknown[1B by spec]

 *

 * @argv_ptr: source string to convert from; usually argv

 * @clk_index_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_clk_index(const char *argv_ptr, uint8_t *clk_index_ptr)

{

	if (!argv_ptr || !clk_index_ptr) {

		lprintf(LOG_ERR, "is_clk_index(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, clk_index_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Clock Index '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_clk_resid - wrapper to convert user input into integer.

 * Clock Resource Index(?) limits are uknown, but maximum seems to be 15.

 *

 * @argv_ptr: source string to convert from; usually argv

 * @clk_resid_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_clk_resid(const char *argv_ptr, int8_t *clk_resid_ptr)

{

	if (!argv_ptr || !clk_resid_ptr) {

		lprintf(LOG_ERR, "is_clk_resid(): invalid argument(s).");

		return (-1);

	}

	if (str2char(argv_ptr, clk_resid_ptr) == 0

			&& *clk_resid_ptr > (-1)) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Resource ID '%s' is invalid.",

			clk_resid_ptr);

	return (-1);

}

/* is_clk_setting - wrapper to convert user input into integer.

 * Clock Setting is a 1B bitfield:

 * x [7:4] - reserved

 * x [3] - state - 0/1

 * x [2] - direction - 0/1

 * x [1:0] - PLL ctrl - 00/01/10/11[Reserved]

 *

 * @argv_ptr: source string to convert from; usually argv

 * @clk_setting_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_clk_setting(const char *argv_ptr, uint8_t *clk_setting_ptr)

{

	if (!argv_ptr || !clk_setting_ptr) {

		lprintf(LOG_ERR, "is_clk_setting(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, clk_setting_ptr) == 0) {

		return 0;

	}

	/* FIXME - validate bits 4-7 are 0 ? */

	lprintf(LOG_ERR, "Given Clock Setting '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_enable - wrapper to convert user input into integer.

 * Valid input range for Enable is <0..1>.

 *

 * @argv_ptr: source string to convert from; usually argv

 * @enable_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_enable(const char *argv_ptr, uint8_t *enable_ptr)

{

	if (!argv_ptr || !enable_ptr) {

		lprintf(LOG_ERR, "is_enable(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, enable_ptr) == 0

			&& (*enable_ptr == 0 || *enable_ptr == 1)) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Enable '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_enable - wrapper to convert user input into integer.

 * LED colors: 

 * - valid <1..6>, <0xE..0xF>

 * - reserved [0, 7]

 * - undefined <8..D>

 *

 * @argv_ptr: source string to convert from; usually argv

 * @enable_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_led_color(const char *argv_ptr, uint8_t *led_color_ptr)

{

	if (!argv_ptr || !led_color_ptr) {

		lprintf(LOG_ERR, "is_led_color(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, led_color_ptr) != 0) {

		lprintf(LOG_ERR, "Given LED Color '%s' is invalid.",

				argv_ptr);

		lprintf(LOG_ERR,

				"LED Color must be from ranges: <1..6>, <0xE..0xF>");

		return (-1);

	}

	if ((*led_color_ptr >= 1 && *led_color_ptr <= 6)

			|| (*led_color_ptr >= 0xE && *led_color_ptr <= 0xF)) {

		return 0;

	}

	lprintf(LOG_ERR, "Given LED Color '%s' is out of range.", argv_ptr);

	lprintf(LOG_ERR, "LED Color must be from ranges: <1..6>, <0xE..0xF>");

	return (-1);

}

/* is_led_function - wrapper to convert user input into integer.

 * LED functions, however, might differ by OEM:

 * - 0x00 - off override

 * - <0x01..0xFA> - blinking override

 * - 0xFB - lamp test state

 * - 0xFC - state restored to local ctrl state

 * - <0xFD..0xFE> - reserved

 * - 0xFF - on override

 *

 * @argv_ptr: source string to convert from; usually argv

 * @led_fn_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_led_function(const char *argv_ptr, uint8_t *led_fn_ptr)

{

	if (!argv_ptr || !led_fn_ptr) {

		lprintf(LOG_ERR, "is_led_function(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, led_fn_ptr) == 0

			&& (*led_fn_ptr < 0xFD || *led_fn_ptr > 0xFE)) {

		return 0;

	}

	lprintf(LOG_ERR, "Given LED Function '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_led_id - wrapper to convert user input into integer.

 * LED ID range seems to be <0..255>

 *

 * @argv_ptr: source string to convert from; usually argv

 * @led_id_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_led_id(const char *argv_ptr, uint8_t *led_id_ptr)

{

	if (!argv_ptr || !led_id_ptr) {

		lprintf(LOG_ERR, "is_led_id(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, led_id_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given LED ID '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_link_group - wrapper to convert user input into integer.

 * Link Grouping ID limis are unknown, bits [31:24] by spec.

 *

 * @argv_ptr: source string to convert from; usually argv

 * @link_grp_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_link_group(const char *argv_ptr, uint8_t *link_grp_ptr)

{

	if (!argv_ptr || !link_grp_ptr) {

		lprintf(LOG_ERR, "is_link_group(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, link_grp_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Link Group '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_link_type - wrapper to convert user input into integer.

 * Link Type limits are unknown, bits [19:12]

 *

 * @argv_ptr: source string to convert from; usually argv

 * @link_type_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_link_type(const char *argv_ptr, uint8_t *link_type_ptr)

{

	if (!argv_ptr || !link_type_ptr) {

		lprintf(LOG_ERR, "is_link_type(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, link_type_ptr) == 0) {

		return 0;

	}

	lprintf(LOG_ERR, "Given Link Type '%s' is invalid.", argv_ptr);

	return (-1);

}

/* is_link_type_ext - wrapper to convert user input into integer.

 * Link Type Extension limits are unknown, bits [23:20] => <0..15> ?

 *

 * @argv_ptr: source string to convert from; usually argv

 * @link_type_ext_ptr: pointer where to store result

 * returns: zero on success, other values mean error

 */

int

is_link_type_ext(const char *argv_ptr, uint8_t *link_type_ext_ptr)

{

	if (!argv_ptr || !link_type_ext_ptr) {

		lprintf(LOG_ERR, "is_link_type_ext(): invalid argument(s).");

		return (-1);

	}

	if (str2uchar(argv_ptr, link_type_ext_ptr) != 0

			|| *link_type_ext_ptr > 15) {

		lprintf(LOG_ERR,

				"Given Link Type Extension '%s' is invalid.",

				argv_ptr);

		return (-1);

	}

	return 0;

}

int

ipmi_picmg_getaddr(struct ipmi_intf * intf, int argc, char ** argv)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	unsigned char msg_data[5];

	memset(&req, 0, sizeof(req));

	req.msg.netfn = IPMI_NETFN_PICMG;

	req.msg.cmd = PICMG_GET_ADDRESS_INFO_CMD;

	req.msg.data = msg_data;

	req.msg.data_len = 2;

	msg_data[0] = 0;   /* picmg identifier */

	msg_data[1] = 0;   /* default fru id */

	if(argc > 0) {

		if (is_fru_id(argv[0], &msg_data[1]) != 0) {

			return (-1);

		}

	}

	rsp = intf->sendrecv(intf, &req;;

	if (!rsp) {

		lprintf(LOG_ERR, "Error. No valid response received.");

		return (-1);

	} else if (rsp->ccode) {

		lprintf(LOG_ERR, "Error getting address information CC: 0x%02x",

				rsp->ccode);

		return (-1);

	}

	printf("Hardware Address : 0x%02x\n", rsp->data[1]);

	printf("IPMB-0 Address   : 0x%02x\n", rsp->data[2]);

	printf("FRU ID           : 0x%02x\n", rsp->data[4]);

	printf("Site ID          : 0x%02x\n", rsp->data[5]);

	printf("Site Type        : ");

	switch (rsp->data[6]) {

	case PICMG_ATCA_BOARD:

		printf("ATCA board\n");

		break;

	case PICMG_POWER_ENTRY:

		printf("Power Entry Module\n");

		break;

	case PICMG_SHELF_FRU:

		printf("Shelf FRU\n");

		break;

	case PICMG_DEDICATED_SHMC:

		printf("Dedicated Shelf Manager\n");

		break;

	case PICMG_FAN_TRAY:

		printf("Fan Tray\n");

		break;

	case PICMG_FAN_FILTER_TRAY:

		printf("Fan Filter Tray\n");

		break;

	case PICMG_ALARM:

		printf("Alarm module\n");

		break;

	case PICMG_AMC:

		printf("AMC");

		printf("  -> IPMB-L Address: 0x%02x\n", amcAddrMap[rsp->data[5]].ipmbLAddr);

		break;

	case PICMG_PMC:

		printf("PMC\n");

		break;

	 case PICMG_RTM:

		printf("RTM\n");

		break;

	default:

		if (rsp->data[6] >= 0xc0 && rsp->data[6] <= 0xcf) {

			printf("OEM\n");

		} else {

			printf("unknown\n");

		}

	}

	return 0;

}

int

ipmi_picmg_properties(struct ipmi_intf * intf, int show )

{

	unsigned char PicmgExtMajorVersion;

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	unsigned char msg_data;

	memset(&req, 0, sizeof(req));

	req.msg.netfn    = IPMI_NETFN_PICMG;

	req.msg.cmd      = PICMG_GET_PICMG_PROPERTIES_CMD;

	req.msg.data     = &msg_data;

	req.msg.data_len = 1;

	msg_data = 0;

	rsp = intf->sendrecv(intf, &req;;

	if (!rsp  || rsp->ccode) {

		lprintf(LOG_ERR, "Error getting address information.");

		return -1;

	}

	if( show )

	{

		printf("PICMG identifier	: 0x%02x\n", rsp->data[0]);

		printf("PICMG Ext. Version : %i.%i\n",	 rsp->data[1]&0x0f,

															 (rsp->data[1]&0xf0) >> 4);

		printf("Max FRU Device ID	: 0x%02x\n", rsp->data[2]);

		printf("FRU Device ID		: 0x%02x\n", rsp->data[3]);

	}

   /* We cache the major extension version ...

      to know how to format some commands */

	PicmgExtMajorVersion = rsp->data[1]&0x0f;

	if( PicmgExtMajorVersion == PICMG_CPCI_MAJOR_VERSION  ) { 

		PicmgCardType = PICMG_CARD_TYPE_CPCI;

   }

	else if(  PicmgExtMajorVersion == PICMG_ATCA_MAJOR_VERSION) {

		PicmgCardType = PICMG_CARD_TYPE_ATCA;

   }

	else if(  PicmgExtMajorVersion == PICMG_AMC_MAJOR_VERSION) {

		PicmgCardType = PICMG_CARD_TYPE_AMC;

   }

	return 0;

}

#define PICMG_FRU_DEACTIVATE	(unsigned char) 0x00

#define PICMG_FRU_ACTIVATE	(unsigned char) 0x01

int

ipmi_picmg_fru_activation(struct ipmi_intf * intf, int argc, char ** argv, unsigned char state)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	struct picmg_set_fru_activation_cmd cmd;

	memset(&req, 0, sizeof(req));

	req.msg.netfn    = IPMI_NETFN_PICMG;

	req.msg.cmd      = PICMG_FRU_ACTIVATION_CMD;

	req.msg.data     = (unsigned char*) &cm;;

	req.msg.data_len = 3;

	cmd.picmg_id  = 0;						/* PICMG identifier */

	if (is_fru_id(argv[0], &(cmd.fru_id)) != 0) {

		return (-1);

	}

	cmd.fru_state = state;

	rsp = intf->sendrecv(intf, &req;;

	if (!rsp  || rsp->ccode) {

		lprintf(LOG_ERR, "Error activation/deactivation of FRU.");

		return -1;

	}

	if (rsp->data[0] != 0x00) {

		lprintf(LOG_ERR, "Error activation/deactivation of FRU.");

	}

	return 0;

}

int

ipmi_picmg_fru_activation_policy_get(struct ipmi_intf * intf, int argc, char ** argv)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	unsigned char msg_data[4];

	memset(&req, 0, sizeof(req));

	req.msg.netfn    = IPMI_NETFN_PICMG;

	req.msg.cmd      = PICMG_GET_FRU_POLICY_CMD;

	req.msg.data     = msg_data;

	req.msg.data_len = 2;

	msg_data[0] = 0;								/* PICMG identifier */

	if (is_fru_id(argv[0], &msg_data[1]) != 0) {

		return (-1);

	}

	rsp = intf->sendrecv(intf, &req;;

	if (!rsp) {

		lprintf(LOG_ERR, "No valid response received.");

		return -1;

	}

	if (rsp->ccode) {

		lprintf(LOG_ERR, "FRU activation policy get failed with CC code 0x%02x",

				rsp->ccode);

		return -1;

	}

	printf(" %s\n", ((rsp->data[1] & 0x01) == 0x01) ?

	                           "activation locked" : "activation not locked");

	printf(" %s\n", ((rsp->data[1] & 0x02) == 0x02) ?

	                            "deactivation locked" : "deactivation not locked");

	return 0;

}

int

ipmi_picmg_fru_activation_policy_set(struct ipmi_intf * intf, int argc, char ** argv)

{

	struct ipmi_rs * rsp;

	struct ipmi_rq req;

	unsigned char msg_data[4];

	memset(&req, 0, sizeof(req));

	req.msg.netfn    = IPMI_NETFN_PICMG;

	req.msg.cmd      = PICMG_SET_FRU_POLICY_CMD;

	req.msg.data     = msg_data;

	req.msg.data_len = 4;

	msg_data[0] = 0;								            /* PICMG identifier */

	if (is_fru_id(argv[0], &msg_data[1]) != 0) {

		return (-1);

	}

	if (str2uchar(argv[1], &msg_data[2]) != 0 || msg_data[2] > 3) {

		/* FRU Lock Mask */

		lprintf(LOG_ERR, "Given FRU Lock Mask '%s' is invalid.",

				argv[1]);

		return (-1);

	}

	if (str2uchar(argv[2], &msg_data[3]) != 0 || msg_data[3] > 3) {

		/* FRU Act Policy */

		lprintf(LOG_ERR,

				"Given FRU Activation Policy '%s' is invalid.",

				argv[2]);

		return (-1);

	}

	rsp = intf->sendrecv(intf, &req;;

	if (!rsp) {

		lprintf(LOG_ERR, "No valid response received.");

		return -1;

	}

	if (rsp->ccode) {

		lprintf(LOG_ERR, "FRU activation policy set failed with CC code 0x%02x",

				rsp->ccode);

		return -1;

	}

	return 0;

}

#define PICMG_MAX_LINK_PER_CHANNEL 4

int

ipmi_picmg_portstate_get(struct ipmi_intf * intf, int32_t interface,

		uint8_t channel, int mode)

{

	struct ipmi_rs * rsp = NULL;

	struct ipmi_rq req;

	unsigned char msg_data[4];

	struct fru_picmgext_link_desc* d; /* descriptor pointer for rec. data */

	memset(&req, 0, sizeof(req));

	req.msg.netfn    = IPMI_NETFN_PICMG;

	req.msg.cmd      = PICMG_GET_PORT_STATE_CMD;

	req.msg.data     = msg_data;

	req.msg.data_len = 2;

	msg_data[0] = 0x00;						/* PICMG identifier */

	msg_data[1] = (interface & 0x3)<<6;	/* interface      */

	msg_data[1] |= (channel & 0x3F);	/* channel number */

	rsp = intf->sendrecv(intf, &req;;

	if (!rsp) {

		lprintf(LOG_ERR, "No valid response received.");

		return -1;

	}

	if (rsp->ccode) {

		if( mode == PICMG_EKEY_MODE_QUERY ){

			lprintf(LOG_ERR, "FRU portstate get failed with CC code 0x%02x",

					rsp->ccode);

		}

		return -1;

	}

	if (rsp->data_len >= 6) {

		int index;

		/* add support for more than one link per channel */

		for(index=0;index

			if( rsp->data_len > (1+ (index*5))){

				d = (struct fru_picmgext_link_desc *) &(rsp->data[1 + (index*5)]);

				if

				(

					mode == PICMG_EKEY_MODE_PRINT_ALL

					||

					mode == PICMG_EKEY_MODE_QUERY

					||

					(

						mode == PICMG_EKEY_MODE_PRINT_ENABLED

						&&

						rsp->data[5 + (index*5) ] == 0x01

					)

					||

					(

						mode == PICMG_EKEY_MODE_PRINT_DISABLED

						&&

						rsp->data[5 + (index*5) ] == 0x00

					)

				)

				{

					printf("      Link Grouping ID:     0x%02x\n", d->grouping);

					printf("      Link Type Extension:  0x%02x\n", d->ext);

					printf("      Link Type:            0x%02x  ", d->type);

					if (d->type == 0 || d->type == 0xff)

					{

						printf("Reserved %d\n",d->type);

					}

					else if (d->type >= 0x06 && d->type <= 0xef)

					{

						printf("Reserved\n");

					}

					else if (d->type >= 0xf0 && d->type <= 0xfe)

					{

						printf("OEM GUID Definition\n");

					}

					else

					{

						switch (d->type)

						{

							case FRU_PICMGEXT_LINK_TYPE_BASE:

								printf("PICMG 3.0 Base Interface 10/100/1000\n");

							break;

							case FRU_PICMGEXT_LINK_TYPE_FABRIC_ETHERNET:

								printf("PICMG 3.1 Ethernet Fabric Interface\n");

							break;

							case FRU_PICMGEXT_LINK_TYPE_FABRIC_INFINIBAND:

								printf("PICMG 3.2 Infiniband Fabric Interface\n");

							break;

							case FRU_PICMGEXT_LINK_TYPE_FABRIC_STAR:

								printf("PICMG 3.3 Star Fabric Interface\n");

							break;

							case  FRU_PICMGEXT_LINK_TYPE_PCIE: