[linux-2.6-block.git] / drivers / net / ethernet / mellanox / mlxsw / core_env.c

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2018 Mellanox Technologies. All rights reserved */

#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/sfp.h>

#include "core.h"
#include "core_env.h"
#include "item.h"
#include "reg.h"

static int mlxsw_env_validate_cable_ident(struct mlxsw_core *core, int id,
					  bool *qsfp)
{
	char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE];
	char mcia_pl[MLXSW_REG_MCIA_LEN];
	u8 ident;
	int err;

	mlxsw_reg_mcia_pack(mcia_pl, id, 0, MLXSW_REG_MCIA_PAGE0_LO_OFF, 0, 1,
			    MLXSW_REG_MCIA_I2C_ADDR_LOW);
	err = mlxsw_reg_query(core, MLXSW_REG(mcia), mcia_pl);
	if (err)
		return err;
	mlxsw_reg_mcia_eeprom_memcpy_from(mcia_pl, eeprom_tmp);
	ident = eeprom_tmp[0];
	switch (ident) {
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_SFP:
		*qsfp = false;
		break;
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP: /* fall-through */
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP_PLUS: /* fall-through */
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP28: /* fall-through */
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP_DD:
		*qsfp = true;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int
mlxsw_env_query_module_eeprom(struct mlxsw_core *mlxsw_core, int module,
			      u16 offset, u16 size, void *data,
			      unsigned int *p_read_size)
{
	char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE];
	char mcia_pl[MLXSW_REG_MCIA_LEN];
	u16 i2c_addr;
	u8 page = 0;
	int status;
	int err;

	size = min_t(u16, size, MLXSW_REG_MCIA_EEPROM_SIZE);

	if (offset < MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH &&
	    offset + size > MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH)
		/* Cross pages read, read until offset 256 in low page */
		size = MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH - offset;

	i2c_addr = MLXSW_REG_MCIA_I2C_ADDR_LOW;
	if (offset >= MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH) {
		page = MLXSW_REG_MCIA_PAGE_GET(offset);
		offset -= MLXSW_REG_MCIA_EEPROM_UP_PAGE_LENGTH * page;
		/* When reading upper pages 1, 2 and 3 the offset starts at
		 * 128. Please refer to "QSFP+ Memory Map" figure in SFF-8436
		 * specification for graphical depiction.
		 * MCIA register accepts buffer size <= 48. Page of size 128
		 * should be read by chunks of size 48, 48, 32. Align the size
		 * of the last chunk to avoid reading after the end of the
		 * page.
		 */
		if (offset + size > MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH)
			size = MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH - offset;
	}

	mlxsw_reg_mcia_pack(mcia_pl, module, 0, page, offset, size, i2c_addr);

	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mcia), mcia_pl);
	if (err)
		return err;

	status = mlxsw_reg_mcia_status_get(mcia_pl);
	if (status)
		return -EIO;

	mlxsw_reg_mcia_eeprom_memcpy_from(mcia_pl, eeprom_tmp);
	memcpy(data, eeprom_tmp, size);
	*p_read_size = size;

	return 0;
}

int mlxsw_env_module_temp_thresholds_get(struct mlxsw_core *core, int module,
					 int off, int *temp)
{
	char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE];
	union {
		u8 buf[MLXSW_REG_MCIA_TH_ITEM_SIZE];
		u16 temp;
	} temp_thresh;
	char mcia_pl[MLXSW_REG_MCIA_LEN] = {0};
	char mtmp_pl[MLXSW_REG_MTMP_LEN];
	unsigned int module_temp;
	bool qsfp;
	int err;

	mlxsw_reg_mtmp_pack(mtmp_pl, MLXSW_REG_MTMP_MODULE_INDEX_MIN + module,
			    false, false);
	err = mlxsw_reg_query(core, MLXSW_REG(mtmp), mtmp_pl);
	if (err)
		return err;
	mlxsw_reg_mtmp_unpack(mtmp_pl, &module_temp, NULL, NULL);
	if (!module_temp) {
		*temp = 0;
		return 0;
	}

	/* Read Free Side Device Temperature Thresholds from page 03h
	 * (MSB at lower byte address).
	 * Bytes:
	 * 128-129 - Temp High Alarm (SFP_TEMP_HIGH_ALARM);
	 * 130-131 - Temp Low Alarm (SFP_TEMP_LOW_ALARM);
	 * 132-133 - Temp High Warning (SFP_TEMP_HIGH_WARN);
	 * 134-135 - Temp Low Warning (SFP_TEMP_LOW_WARN);
	 */

	/* Validate module identifier value. */
	err = mlxsw_env_validate_cable_ident(core, module, &qsfp);
	if (err)
		return err;

	if (qsfp)
		mlxsw_reg_mcia_pack(mcia_pl, module, 0,
				    MLXSW_REG_MCIA_TH_PAGE_NUM,
				    MLXSW_REG_MCIA_TH_PAGE_OFF + off,
				    MLXSW_REG_MCIA_TH_ITEM_SIZE,
				    MLXSW_REG_MCIA_I2C_ADDR_LOW);
	else
		mlxsw_reg_mcia_pack(mcia_pl, module, 0,
				    MLXSW_REG_MCIA_PAGE0_LO,
				    off, MLXSW_REG_MCIA_TH_ITEM_SIZE,
				    MLXSW_REG_MCIA_I2C_ADDR_HIGH);

	err = mlxsw_reg_query(core, MLXSW_REG(mcia), mcia_pl);
	if (err)
		return err;

	mlxsw_reg_mcia_eeprom_memcpy_from(mcia_pl, eeprom_tmp);
	memcpy(temp_thresh.buf, eeprom_tmp, MLXSW_REG_MCIA_TH_ITEM_SIZE);
	*temp = temp_thresh.temp * 1000;

	return 0;
}

int mlxsw_env_get_module_info(struct mlxsw_core *mlxsw_core, int module,
			      struct ethtool_modinfo *modinfo)
{
	u8 module_info[MLXSW_REG_MCIA_EEPROM_MODULE_INFO_SIZE];
	u16 offset = MLXSW_REG_MCIA_EEPROM_MODULE_INFO_SIZE;
	u8 module_rev_id, module_id, diag_mon;
	unsigned int read_size;
	int err;

	err = mlxsw_env_query_module_eeprom(mlxsw_core, module, 0, offset,
					    module_info, &read_size);
	if (err)
		return err;

	if (read_size < offset)
		return -EIO;

	module_rev_id = module_info[MLXSW_REG_MCIA_EEPROM_MODULE_INFO_REV_ID];
	module_id = module_info[MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID];

	switch (module_id) {
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP:
		modinfo->type       = ETH_MODULE_SFF_8436;
		modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
		break;
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP_PLUS: /* fall-through */
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP28:
		if (module_id == MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP28 ||
		    module_rev_id >=
		    MLXSW_REG_MCIA_EEPROM_MODULE_INFO_REV_ID_8636) {
			modinfo->type       = ETH_MODULE_SFF_8636;
			modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN;
		} else {
			modinfo->type       = ETH_MODULE_SFF_8436;
			modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
		}
		break;
	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_SFP:
		/* Verify if transceiver provides diagnostic monitoring page */
		err = mlxsw_env_query_module_eeprom(mlxsw_core, module,
						    SFP_DIAGMON, 1, &diag_mon,
						    &read_size);
		if (err)
			return err;

		if (read_size < 1)
			return -EIO;

		modinfo->type       = ETH_MODULE_SFF_8472;
		if (diag_mon)
			modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
		else
			modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN / 2;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}
EXPORT_SYMBOL(mlxsw_env_get_module_info);

int mlxsw_env_get_module_eeprom(struct net_device *netdev,
				struct mlxsw_core *mlxsw_core, int module,
				struct ethtool_eeprom *ee, u8 *data)
{
	int offset = ee->offset;
	unsigned int read_size;
	int i = 0;
	int err;

	if (!ee->len)
		return -EINVAL;

	memset(data, 0, ee->len);

	while (i < ee->len) {
		err = mlxsw_env_query_module_eeprom(mlxsw_core, module, offset,
						    ee->len - i, data + i,
						    &read_size);
		if (err) {
			netdev_err(netdev, "Eeprom query failed\n");
			return err;
		}

		i += read_size;
		offset += read_size;
	}

	return 0;
}
EXPORT_SYMBOL(mlxsw_env_get_module_eeprom);
Commit	Line	Data
d93c19a1 VP	1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
	2	/* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
	3
	4	#include <linux/kernel.h>
	5	#include <linux/err.h>
f1436c80	6	#include <linux/sfp.h>
d93c19a1 VP	7
	8	#include "core.h"
	9	#include "core_env.h"
	10	#include "item.h"
	11	#include "reg.h"
	12
	13	static int mlxsw_env_validate_cable_ident(struct mlxsw_core *core, int id,
	14	bool *qsfp)
	15	{
	16	char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE];
	17	char mcia_pl[MLXSW_REG_MCIA_LEN];
	18	u8 ident;
	19	int err;
	20
	21	mlxsw_reg_mcia_pack(mcia_pl, id, 0, MLXSW_REG_MCIA_PAGE0_LO_OFF, 0, 1,
	22	MLXSW_REG_MCIA_I2C_ADDR_LOW);
	23	err = mlxsw_reg_query(core, MLXSW_REG(mcia), mcia_pl);
	24	if (err)
	25	return err;
	26	mlxsw_reg_mcia_eeprom_memcpy_from(mcia_pl, eeprom_tmp);
	27	ident = eeprom_tmp[0];
	28	switch (ident) {
	29	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_SFP:
	30	*qsfp = false;
	31	break;
	32	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP: /* fall-through */
	33	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP_PLUS: /* fall-through */
	34	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP28: /* fall-through */
	35	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP_DD:
	36	*qsfp = true;
	37	break;
	38	default:
	39	return -EINVAL;
	40	}
	41
	42	return 0;
	43	}
	44
1b1c6c1a VP	45	static int
	46	mlxsw_env_query_module_eeprom(struct mlxsw_core *mlxsw_core, int module,
	47	u16 offset, u16 size, void *data,
	48	unsigned int *p_read_size)
	49	{
	50	char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE];
	51	char mcia_pl[MLXSW_REG_MCIA_LEN];
	52	u16 i2c_addr;
a45bfb5a	53	u8 page = 0;
1b1c6c1a VP	54	int status;
	55	int err;
	56
	57	size = min_t(u16, size, MLXSW_REG_MCIA_EEPROM_SIZE);
	58
	59	if (offset < MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH &&
	60	offset + size > MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH)
	61	/* Cross pages read, read until offset 256 in low page */
	62	size = MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH - offset;
	63
	64	i2c_addr = MLXSW_REG_MCIA_I2C_ADDR_LOW;
	65	if (offset >= MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH) {
a45bfb5a VP	66	page = MLXSW_REG_MCIA_PAGE_GET(offset);
	67	offset -= MLXSW_REG_MCIA_EEPROM_UP_PAGE_LENGTH * page;
	68	/* When reading upper pages 1, 2 and 3 the offset starts at
	69	* 128. Please refer to "QSFP+ Memory Map" figure in SFF-8436
	70	* specification for graphical depiction.
	71	* MCIA register accepts buffer size <= 48. Page of size 128
	72	* should be read by chunks of size 48, 48, 32. Align the size
	73	* of the last chunk to avoid reading after the end of the
	74	* page.
	75	*/
	76	if (offset + size > MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH)
	77	size = MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH - offset;
1b1c6c1a VP	78	}
1b1c6c1a VP	79
a45bfb5a	80	mlxsw_reg_mcia_pack(mcia_pl, module, 0, page, offset, size, i2c_addr);
1b1c6c1a VP	81
	82	err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mcia), mcia_pl);
	83	if (err)
	84	return err;
	85
	86	status = mlxsw_reg_mcia_status_get(mcia_pl);
	87	if (status)
	88	return -EIO;
	89
	90	mlxsw_reg_mcia_eeprom_memcpy_from(mcia_pl, eeprom_tmp);
	91	memcpy(data, eeprom_tmp, size);
	92	*p_read_size = size;
	93
	94	return 0;
	95	}
	96
d93c19a1 VP	97	int mlxsw_env_module_temp_thresholds_get(struct mlxsw_core *core, int module,
	98	int off, int *temp)
	99	{
	100	char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE];
	101	union {
	102	u8 buf[MLXSW_REG_MCIA_TH_ITEM_SIZE];
	103	u16 temp;
	104	} temp_thresh;
	105	char mcia_pl[MLXSW_REG_MCIA_LEN] = {0};
e4e93d6d VP	106	char mtmp_pl[MLXSW_REG_MTMP_LEN];
e4e93d6d VP	107	unsigned int module_temp;
d93c19a1 VP	108	bool qsfp;
	109	int err;
	110
e4e93d6d VP	111	mlxsw_reg_mtmp_pack(mtmp_pl, MLXSW_REG_MTMP_MODULE_INDEX_MIN + module,
	112	false, false);
	113	err = mlxsw_reg_query(core, MLXSW_REG(mtmp), mtmp_pl);
d93c19a1 VP	114	if (err)
d93c19a1 VP	115	return err;
e4e93d6d VP	116	mlxsw_reg_mtmp_unpack(mtmp_pl, &module_temp, NULL, NULL);
e4e93d6d VP	117	if (!module_temp) {
d93c19a1 VP	118	*temp = 0;
d93c19a1 VP	119	return 0;
d93c19a1 VP	120	}
	121
	122	/* Read Free Side Device Temperature Thresholds from page 03h
	123	* (MSB at lower byte address).
	124	* Bytes:
	125	* 128-129 - Temp High Alarm (SFP_TEMP_HIGH_ALARM);
	126	* 130-131 - Temp Low Alarm (SFP_TEMP_LOW_ALARM);
	127	* 132-133 - Temp High Warning (SFP_TEMP_HIGH_WARN);
	128	* 134-135 - Temp Low Warning (SFP_TEMP_LOW_WARN);
	129	*/
	130
	131	/* Validate module identifier value. */
	132	err = mlxsw_env_validate_cable_ident(core, module, &qsfp);
	133	if (err)
	134	return err;
	135
	136	if (qsfp)
	137	mlxsw_reg_mcia_pack(mcia_pl, module, 0,
	138	MLXSW_REG_MCIA_TH_PAGE_NUM,
	139	MLXSW_REG_MCIA_TH_PAGE_OFF + off,
	140	MLXSW_REG_MCIA_TH_ITEM_SIZE,
	141	MLXSW_REG_MCIA_I2C_ADDR_LOW);
	142	else
	143	mlxsw_reg_mcia_pack(mcia_pl, module, 0,
	144	MLXSW_REG_MCIA_PAGE0_LO,
	145	off, MLXSW_REG_MCIA_TH_ITEM_SIZE,
	146	MLXSW_REG_MCIA_I2C_ADDR_HIGH);
	147
	148	err = mlxsw_reg_query(core, MLXSW_REG(mcia), mcia_pl);
	149	if (err)
	150	return err;
	151
	152	mlxsw_reg_mcia_eeprom_memcpy_from(mcia_pl, eeprom_tmp);
	153	memcpy(temp_thresh.buf, eeprom_tmp, MLXSW_REG_MCIA_TH_ITEM_SIZE);
	154	temp = temp_thresh.temp 1000;
	155
	156	return 0;
	157	}
1b1c6c1a VP	158
	159	int mlxsw_env_get_module_info(struct mlxsw_core *mlxsw_core, int module,
	160	struct ethtool_modinfo *modinfo)
	161	{
	162	u8 module_info[MLXSW_REG_MCIA_EEPROM_MODULE_INFO_SIZE];
	163	u16 offset = MLXSW_REG_MCIA_EEPROM_MODULE_INFO_SIZE;
f1436c80	164	u8 module_rev_id, module_id, diag_mon;
1b1c6c1a VP	165	unsigned int read_size;
	166	int err;
	167
	168	err = mlxsw_env_query_module_eeprom(mlxsw_core, module, 0, offset,
	169	module_info, &read_size);
	170	if (err)
	171	return err;
	172
	173	if (read_size < offset)
	174	return -EIO;
	175
	176	module_rev_id = module_info[MLXSW_REG_MCIA_EEPROM_MODULE_INFO_REV_ID];
	177	module_id = module_info[MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID];
	178
	179	switch (module_id) {
	180	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP:
	181	modinfo->type = ETH_MODULE_SFF_8436;
a45bfb5a	182	modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
1b1c6c1a VP	183	break;
	184	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP_PLUS: /* fall-through */
	185	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP28:
	186	if (module_id == MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_QSFP28 \|\|
	187	module_rev_id >=
	188	MLXSW_REG_MCIA_EEPROM_MODULE_INFO_REV_ID_8636) {
	189	modinfo->type = ETH_MODULE_SFF_8636;
a45bfb5a	190	modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN;
1b1c6c1a VP	191	} else {
1b1c6c1a VP	192	modinfo->type = ETH_MODULE_SFF_8436;
a45bfb5a	193	modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
1b1c6c1a VP	194	}
	195	break;
	196	case MLXSW_REG_MCIA_EEPROM_MODULE_INFO_ID_SFP:
f1436c80 VP	197	/* Verify if transceiver provides diagnostic monitoring page */
	198	err = mlxsw_env_query_module_eeprom(mlxsw_core, module,
	199	SFP_DIAGMON, 1, &diag_mon,
	200	&read_size);
	201	if (err)
	202	return err;
	203
	204	if (read_size < 1)
	205	return -EIO;
	206
1b1c6c1a	207	modinfo->type = ETH_MODULE_SFF_8472;
f1436c80 VP	208	if (diag_mon)
	209	modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
	210	else
	211	modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN / 2;
1b1c6c1a VP	212	break;
	213	default:
	214	return -EINVAL;
	215	}
	216
	217	return 0;
	218	}
	219	EXPORT_SYMBOL(mlxsw_env_get_module_info);
	220
	221	int mlxsw_env_get_module_eeprom(struct net_device *netdev,
	222	struct mlxsw_core *mlxsw_core, int module,
	223	struct ethtool_eeprom ee, u8 data)
	224	{
	225	int offset = ee->offset;
	226	unsigned int read_size;
	227	int i = 0;
	228	int err;
	229
	230	if (!ee->len)
	231	return -EINVAL;
	232
	233	memset(data, 0, ee->len);
	234
	235	while (i < ee->len) {
	236	err = mlxsw_env_query_module_eeprom(mlxsw_core, module, offset,
	237	ee->len - i, data + i,
	238	&read_size);
	239	if (err) {
	240	netdev_err(netdev, "Eeprom query failed\n");
	241	return err;
	242	}
	243
	244	i += read_size;
	245	offset += read_size;
	246	}
	247
	248	return 0;
	249	}
	250	EXPORT_SYMBOL(mlxsw_env_get_module_eeprom);