[linux-2.6-block.git] / drivers / s390 / net / qeth_l2_sys.c

/*
 *    Copyright IBM Corp. 2013
 *    Author(s): Eugene Crosser <eugene.crosser@ru.ibm.com>
 */

#include <linux/slab.h>
#include <asm/ebcdic.h>
#include "qeth_l2.h"

#define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \
struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store)

static int qeth_card_hw_is_reachable(struct qeth_card *card)
{
	return (card->state == CARD_STATE_SOFTSETUP) ||
		(card->state == CARD_STATE_UP);
}

static ssize_t qeth_bridge_port_role_state_show(struct device *dev,
				struct device_attribute *attr, char *buf,
				int show_state)
{
	struct qeth_card *card = dev_get_drvdata(dev);
	enum qeth_sbp_states state = QETH_SBP_STATE_INACTIVE;
	int rc = 0;
	char *word;

	if (!card)
		return -EINVAL;

	mutex_lock(&card->conf_mutex);

	if (qeth_card_hw_is_reachable(card) &&
					card->options.sbp.supported_funcs)
		rc = qeth_bridgeport_query_ports(card,
			&card->options.sbp.role, &state);
	if (!rc) {
		if (show_state)
			switch (state) {
			case QETH_SBP_STATE_INACTIVE:
				word = "inactive"; break;
			case QETH_SBP_STATE_STANDBY:
				word = "standby"; break;
			case QETH_SBP_STATE_ACTIVE:
				word = "active"; break;
			default:
				rc = -EIO;
			}
		else
			switch (card->options.sbp.role) {
			case QETH_SBP_ROLE_NONE:
				word = "none"; break;
			case QETH_SBP_ROLE_PRIMARY:
				word = "primary"; break;
			case QETH_SBP_ROLE_SECONDARY:
				word = "secondary"; break;
			default:
				rc = -EIO;
			}
		if (rc)
			QETH_CARD_TEXT_(card, 2, "SBP%02x:%02x",
				card->options.sbp.role, state);
		else
			rc = sprintf(buf, "%s\n", word);
	}

	mutex_unlock(&card->conf_mutex);

	return rc;
}

static ssize_t qeth_bridge_port_role_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	return qeth_bridge_port_role_state_show(dev, attr, buf, 0);
}

static ssize_t qeth_bridge_port_role_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct qeth_card *card = dev_get_drvdata(dev);
	int rc = 0;
	enum qeth_sbp_roles role;

	if (!card)
		return -EINVAL;
	if (sysfs_streq(buf, "primary"))
		role = QETH_SBP_ROLE_PRIMARY;
	else if (sysfs_streq(buf, "secondary"))
		role = QETH_SBP_ROLE_SECONDARY;
	else if (sysfs_streq(buf, "none"))
		role = QETH_SBP_ROLE_NONE;
	else
		return -EINVAL;

	mutex_lock(&card->conf_mutex);

	if (qeth_card_hw_is_reachable(card)) {
		rc = qeth_bridgeport_setrole(card, role);
		if (!rc)
			card->options.sbp.role = role;
	} else
		card->options.sbp.role = role;

	mutex_unlock(&card->conf_mutex);

	return rc ? rc : count;
}

static DEVICE_ATTR(bridge_role, 0644, qeth_bridge_port_role_show,
		   qeth_bridge_port_role_store);

static ssize_t qeth_bridge_port_state_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	return qeth_bridge_port_role_state_show(dev, attr, buf, 1);
}

static DEVICE_ATTR(bridge_state, 0644, qeth_bridge_port_state_show,
		   NULL);

static ssize_t qeth_bridgeport_hostnotification_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct qeth_card *card = dev_get_drvdata(dev);
	int enabled;

	if (!card)
		return -EINVAL;

	mutex_lock(&card->conf_mutex);

	enabled = card->options.sbp.hostnotification;

	mutex_unlock(&card->conf_mutex);

	return sprintf(buf, "%d\n", enabled);
}

static ssize_t qeth_bridgeport_hostnotification_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct qeth_card *card = dev_get_drvdata(dev);
	int rc = 0;
	int enable;

	if (!card)
		return -EINVAL;

	if (sysfs_streq(buf, "0"))
		enable = 0;
	else if (sysfs_streq(buf, "1"))
		enable = 1;
	else
		return -EINVAL;

	mutex_lock(&card->conf_mutex);

	if (qeth_card_hw_is_reachable(card)) {
		rc = qeth_bridgeport_an_set(card, enable);
		if (!rc)
			card->options.sbp.hostnotification = enable;
	} else
		card->options.sbp.hostnotification = enable;

	mutex_unlock(&card->conf_mutex);

	return rc ? rc : count;
}

static DEVICE_ATTR(bridge_hostnotify, 0644,
			qeth_bridgeport_hostnotification_show,
			qeth_bridgeport_hostnotification_store);

static struct attribute *qeth_l2_bridgeport_attrs[] = {
	&dev_attr_bridge_role.attr,
	&dev_attr_bridge_state.attr,
	&dev_attr_bridge_hostnotify.attr,
	NULL,
};

static struct attribute_group qeth_l2_bridgeport_attr_group = {
	.attrs = qeth_l2_bridgeport_attrs,
};

int qeth_l2_create_device_attributes(struct device *dev)
{
	return sysfs_create_group(&dev->kobj, &qeth_l2_bridgeport_attr_group);
}

void qeth_l2_remove_device_attributes(struct device *dev)
{
	sysfs_remove_group(&dev->kobj, &qeth_l2_bridgeport_attr_group);
}

/**
 * qeth_l2_setup_bridgeport_attrs() - set/restore attrs when turning online.
 * @card:			      qeth_card structure pointer
 *
 * Note: this function is called with conf_mutex held by the caller
 */
void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card)
{
	int rc;

	if (!card)
		return;
	if (!card->options.sbp.supported_funcs)
		return;
	if (card->options.sbp.role != QETH_SBP_ROLE_NONE) {
		/* Conditional to avoid spurious error messages */
		qeth_bridgeport_setrole(card, card->options.sbp.role);
		/* Let the callback function refresh the stored role value. */
		qeth_bridgeport_query_ports(card,
			&card->options.sbp.role, NULL);
	}
	if (card->options.sbp.hostnotification) {
		rc = qeth_bridgeport_an_set(card, 1);
		if (rc)
			card->options.sbp.hostnotification = 0;
	} else
		qeth_bridgeport_an_set(card, 0);
}
Commit	Line	Data
b4d72c08 EC	1	/*
	2	* Copyright IBM Corp. 2013
	3	* Author(s): Eugene Crosser <eugene.crosser@ru.ibm.com>
	4	*/
	5
	6	#include <linux/slab.h>
	7	#include <asm/ebcdic.h>
	8	#include "qeth_l2.h"
	9
	10	#define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \
	11	struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store)
	12
	13	static int qeth_card_hw_is_reachable(struct qeth_card *card)
	14	{
	15	return (card->state == CARD_STATE_SOFTSETUP) \|\|
	16	(card->state == CARD_STATE_UP);
	17	}
	18
	19	static ssize_t qeth_bridge_port_role_state_show(struct device *dev,
	20	struct device_attribute attr, char buf,
	21	int show_state)
	22	{
	23	struct qeth_card *card = dev_get_drvdata(dev);
	24	enum qeth_sbp_states state = QETH_SBP_STATE_INACTIVE;
	25	int rc = 0;
	26	char *word;
	27
	28	if (!card)
	29	return -EINVAL;
	30
	31	mutex_lock(&card->conf_mutex);
	32
	33	if (qeth_card_hw_is_reachable(card) &&
	34	card->options.sbp.supported_funcs)
	35	rc = qeth_bridgeport_query_ports(card,
	36	&card->options.sbp.role, &state);
	37	if (!rc) {
	38	if (show_state)
	39	switch (state) {
	40	case QETH_SBP_STATE_INACTIVE:
	41	word = "inactive"; break;
	42	case QETH_SBP_STATE_STANDBY:
	43	word = "standby"; break;
	44	case QETH_SBP_STATE_ACTIVE:
	45	word = "active"; break;
	46	default:
	47	rc = -EIO;
	48	}
	49	else
	50	switch (card->options.sbp.role) {
	51	case QETH_SBP_ROLE_NONE:
	52	word = "none"; break;
	53	case QETH_SBP_ROLE_PRIMARY:
	54	word = "primary"; break;
	55	case QETH_SBP_ROLE_SECONDARY:
	56	word = "secondary"; break;
	57	default:
	58	rc = -EIO;
	59	}
	60	if (rc)
	61	QETH_CARD_TEXT_(card, 2, "SBP%02x:%02x",
	62	card->options.sbp.role, state);
	63	else
	64	rc = sprintf(buf, "%s\n", word);
65	}
66
67	mutex_unlock(&card->conf_mutex);
68
69	return rc;
70	}
71
72	static ssize_t qeth_bridge_port_role_show(struct device *dev,
73	struct device_attribute attr, char buf)
74	{
75	return qeth_bridge_port_role_state_show(dev, attr, buf, 0);
76	}
77
78	static ssize_t qeth_bridge_port_role_store(struct device *dev,
79	struct device_attribute attr, const char buf, size_t count)
80	{
81	struct qeth_card *card = dev_get_drvdata(dev);
82	int rc = 0;
83	enum qeth_sbp_roles role;
84
85	if (!card)
86	return -EINVAL;
87	if (sysfs_streq(buf, "primary"))
88	role = QETH_SBP_ROLE_PRIMARY;
89	else if (sysfs_streq(buf, "secondary"))
90	role = QETH_SBP_ROLE_SECONDARY;
91	else if (sysfs_streq(buf, "none"))
92	role = QETH_SBP_ROLE_NONE;
93	else
94	return -EINVAL;
95
96	mutex_lock(&card->conf_mutex);
97
98	if (qeth_card_hw_is_reachable(card)) {
99	rc = qeth_bridgeport_setrole(card, role);
100	if (!rc)
101	card->options.sbp.role = role;
102	} else
103	card->options.sbp.role = role;
104
105	mutex_unlock(&card->conf_mutex);
106
107	return rc ? rc : count;
108	}
109
110	static DEVICE_ATTR(bridge_role, 0644, qeth_bridge_port_role_show,
111	qeth_bridge_port_role_store);
112
113	static ssize_t qeth_bridge_port_state_show(struct device *dev,
114	struct device_attribute attr, char buf)
115	{
116	return qeth_bridge_port_role_state_show(dev, attr, buf, 1);
117	}
118
119	static DEVICE_ATTR(bridge_state, 0644, qeth_bridge_port_state_show,
120	NULL);
121
9f48b9db EC	122	static ssize_t qeth_bridgeport_hostnotification_show(struct device *dev,
	123	struct device_attribute attr, char buf)
	124	{
	125	struct qeth_card *card = dev_get_drvdata(dev);
	126	int enabled;
	127
	128	if (!card)
	129	return -EINVAL;
	130
	131	mutex_lock(&card->conf_mutex);
	132
	133	enabled = card->options.sbp.hostnotification;
	134
	135	mutex_unlock(&card->conf_mutex);
	136
	137	return sprintf(buf, "%d\n", enabled);
	138	}
	139
	140	static ssize_t qeth_bridgeport_hostnotification_store(struct device *dev,
	141	struct device_attribute attr, const char buf, size_t count)
	142	{
	143	struct qeth_card *card = dev_get_drvdata(dev);
	144	int rc = 0;
	145	int enable;
	146
	147	if (!card)
	148	return -EINVAL;
	149
	150	if (sysfs_streq(buf, "0"))
	151	enable = 0;
	152	else if (sysfs_streq(buf, "1"))
	153	enable = 1;
	154	else
	155	return -EINVAL;
	156
	157	mutex_lock(&card->conf_mutex);
	158
	159	if (qeth_card_hw_is_reachable(card)) {
	160	rc = qeth_bridgeport_an_set(card, enable);
	161	if (!rc)
	162	card->options.sbp.hostnotification = enable;
	163	} else
	164	card->options.sbp.hostnotification = enable;
	165
	166	mutex_unlock(&card->conf_mutex);
	167
	168	return rc ? rc : count;
	169	}
	170
	171	static DEVICE_ATTR(bridge_hostnotify, 0644,
	172	qeth_bridgeport_hostnotification_show,
	173	qeth_bridgeport_hostnotification_store);
	174
b4d72c08 EC	175	static struct attribute *qeth_l2_bridgeport_attrs[] = {
	176	&dev_attr_bridge_role.attr,
	177	&dev_attr_bridge_state.attr,
9f48b9db	178	&dev_attr_bridge_hostnotify.attr,
b4d72c08 EC	179	NULL,
	180	};
	181
	182	static struct attribute_group qeth_l2_bridgeport_attr_group = {
	183	.attrs = qeth_l2_bridgeport_attrs,
	184	};
	185
	186	int qeth_l2_create_device_attributes(struct device *dev)
	187	{
	188	return sysfs_create_group(&dev->kobj, &qeth_l2_bridgeport_attr_group);
	189	}
	190
	191	void qeth_l2_remove_device_attributes(struct device *dev)
	192	{
	193	sysfs_remove_group(&dev->kobj, &qeth_l2_bridgeport_attr_group);
	194	}
	195
	196	/**
	197	* qeth_l2_setup_bridgeport_attrs() - set/restore attrs when turning online.
	198	* @card: qeth_card structure pointer
	199	*
	200	* Note: this function is called with conf_mutex held by the caller
	201	*/
	202	void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card)
	203	{
9f48b9db EC	204	int rc;
9f48b9db EC	205
b4d72c08 EC	206	if (!card)
	207	return;
	208	if (!card->options.sbp.supported_funcs)
	209	return;
	210	if (card->options.sbp.role != QETH_SBP_ROLE_NONE) {
	211	/* Conditional to avoid spurious error messages */
	212	qeth_bridgeport_setrole(card, card->options.sbp.role);
	213	/* Let the callback function refresh the stored role value. */
	214	qeth_bridgeport_query_ports(card,
	215	&card->options.sbp.role, NULL);
	216	}
9f48b9db EC	217	if (card->options.sbp.hostnotification) {
	218	rc = qeth_bridgeport_an_set(card, 1);
	219	if (rc)
	220	card->options.sbp.hostnotification = 0;
	221	} else
	222	qeth_bridgeport_an_set(card, 0);
b4d72c08	223	}