qeth_l2_main.c 58.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
F
Frank Blaschka 已提交
2
/*
3
 *    Copyright IBM Corp. 2007, 2009
F
Frank Blaschka 已提交
4 5 6 7 8 9
 *    Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
 *		 Frank Pavlic <fpavlic@de.ibm.com>,
 *		 Thomas Spatzier <tspat@de.ibm.com>,
 *		 Frank Blaschka <frank.blaschka@de.ibm.com>
 */

10 11 12
#define KMSG_COMPONENT "qeth"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

F
Frank Blaschka 已提交
13 14 15 16 17
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/kernel.h>
18
#include <linux/slab.h>
F
Frank Blaschka 已提交
19
#include <linux/etherdevice.h>
J
Jiri Pirko 已提交
20
#include <linux/list.h>
21 22
#include <linux/hash.h>
#include <linux/hashtable.h>
23
#include <asm/setup.h>
F
Frank Blaschka 已提交
24
#include "qeth_core.h"
25
#include "qeth_l2.h"
F
Frank Blaschka 已提交
26 27

static int qeth_l2_set_offline(struct ccwgroup_device *);
28 29 30 31 32
static void qeth_bridgeport_query_support(struct qeth_card *card);
static void qeth_bridge_state_change(struct qeth_card *card,
					struct qeth_ipa_cmd *cmd);
static void qeth_bridge_host_event(struct qeth_card *card,
					struct qeth_ipa_cmd *cmd);
33
static void qeth_l2_vnicc_set_defaults(struct qeth_card *card);
H
Hans Wippel 已提交
34
static void qeth_l2_vnicc_init(struct qeth_card *card);
35 36
static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
					  u32 *timeout);
F
Frank Blaschka 已提交
37

38
static int qeth_l2_setdelmac_makerc(struct qeth_card *card, u16 retcode)
F
Frank Blaschka 已提交
39
{
E
Eugene Crosser 已提交
40
	int rc;
F
Frank Blaschka 已提交
41

E
Eugene Crosser 已提交
42
	if (retcode)
43
		QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
E
Eugene Crosser 已提交
44 45 46 47 48
	switch (retcode) {
	case IPA_RC_SUCCESS:
		rc = 0;
		break;
	case IPA_RC_L2_UNSUPPORTED_CMD:
49
		rc = -EOPNOTSUPP;
E
Eugene Crosser 已提交
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
		break;
	case IPA_RC_L2_ADDR_TABLE_FULL:
		rc = -ENOSPC;
		break;
	case IPA_RC_L2_DUP_MAC:
	case IPA_RC_L2_DUP_LAYER3_MAC:
		rc = -EEXIST;
		break;
	case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
	case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
		rc = -EPERM;
		break;
	case IPA_RC_L2_MAC_NOT_FOUND:
		rc = -ENOENT;
		break;
	default:
		rc = -EIO;
		break;
F
Frank Blaschka 已提交
68
	}
E
Eugene Crosser 已提交
69
	return rc;
F
Frank Blaschka 已提交
70 71
}

72 73 74 75 76 77 78 79 80
static int qeth_l2_send_setdelmac_cb(struct qeth_card *card,
				     struct qeth_reply *reply,
				     unsigned long data)
{
	struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;

	return qeth_l2_setdelmac_makerc(card, cmd->hdr.return_code);
}

81 82 83 84 85 86 87 88 89 90
static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
			   enum qeth_ipa_cmds ipacmd)
{
	struct qeth_ipa_cmd *cmd;
	struct qeth_cmd_buffer *iob;

	QETH_CARD_TEXT(card, 2, "L2sdmac");
	iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
	if (!iob)
		return -ENOMEM;
91
	cmd = __ipa_cmd(iob);
92 93
	cmd->data.setdelmac.mac_length = ETH_ALEN;
	ether_addr_copy(cmd->data.setdelmac.mac, mac);
94
	return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelmac_cb, NULL);
95 96 97 98 99 100 101 102 103 104
}

static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac)
{
	int rc;

	QETH_CARD_TEXT(card, 2, "L2Setmac");
	rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC);
	if (rc == 0) {
		dev_info(&card->gdev->dev,
105
			 "MAC address %pM successfully registered\n", mac);
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
	} else {
		switch (rc) {
		case -EEXIST:
			dev_warn(&card->gdev->dev,
				"MAC address %pM already exists\n", mac);
			break;
		case -EPERM:
			dev_warn(&card->gdev->dev,
				"MAC address %pM is not authorized\n", mac);
			break;
		}
	}
	return rc;
}

121
static int qeth_l2_write_mac(struct qeth_card *card, u8 *mac)
F
Frank Blaschka 已提交
122
{
123
	enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
124
					IPA_CMD_SETGMAC : IPA_CMD_SETVMAC;
E
Eugene Crosser 已提交
125
	int rc;
F
Frank Blaschka 已提交
126

127 128
	QETH_CARD_TEXT(card, 2, "L2Wmac");
	rc = qeth_l2_send_setdelmac(card, mac, cmd);
E
Eugene Crosser 已提交
129
	if (rc == -EEXIST)
130 131
		QETH_DBF_MESSAGE(2, "MAC already registered on device %x\n",
				 CARD_DEVID(card));
E
Eugene Crosser 已提交
132
	else if (rc)
133 134
		QETH_DBF_MESSAGE(2, "Failed to register MAC on device %x: %d\n",
				 CARD_DEVID(card), rc);
E
Eugene Crosser 已提交
135
	return rc;
F
Frank Blaschka 已提交
136 137
}

138
static int qeth_l2_remove_mac(struct qeth_card *card, u8 *mac)
F
Frank Blaschka 已提交
139
{
140
	enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
141
					IPA_CMD_DELGMAC : IPA_CMD_DELVMAC;
E
Eugene Crosser 已提交
142 143
	int rc;

144 145
	QETH_CARD_TEXT(card, 2, "L2Rmac");
	rc = qeth_l2_send_setdelmac(card, mac, cmd);
E
Eugene Crosser 已提交
146
	if (rc)
147 148
		QETH_DBF_MESSAGE(2, "Failed to delete MAC on device %u: %d\n",
				 CARD_DEVID(card), rc);
E
Eugene Crosser 已提交
149
	return rc;
F
Frank Blaschka 已提交
150 151
}

152
static void qeth_l2_drain_rx_mode_cache(struct qeth_card *card)
F
Frank Blaschka 已提交
153
{
154 155 156
	struct qeth_mac *mac;
	struct hlist_node *tmp;
	int i;
F
Frank Blaschka 已提交
157

158 159 160
	hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
		hash_del(&mac->hnode);
		kfree(mac);
F
Frank Blaschka 已提交
161 162 163
	}
}

164
static int qeth_l2_get_cast_type(struct sk_buff *skb)
F
Frank Blaschka 已提交
165
{
166 167 168 169
	if (is_broadcast_ether_addr(skb->data))
		return RTN_BROADCAST;
	if (is_multicast_ether_addr(skb->data))
		return RTN_MULTICAST;
170
	return RTN_UNICAST;
F
Frank Blaschka 已提交
171 172
}

173 174 175
static void qeth_l2_fill_header(struct qeth_qdio_out_q *queue,
				struct qeth_hdr *hdr, struct sk_buff *skb,
				int ipv, int cast_type, unsigned int data_len)
F
Frank Blaschka 已提交
176
{
177
	struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
F
Frank Blaschka 已提交
178

179
	hdr->hdr.l2.pkt_length = data_len;
F
Frank Blaschka 已提交
180

181 182 183 184 185 186
	if (skb_is_gso(skb)) {
		hdr->hdr.l2.id = QETH_HEADER_TYPE_L2_TSO;
	} else {
		hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2;
		if (skb->ip_summed == CHECKSUM_PARTIAL) {
			qeth_tx_csum(skb, &hdr->hdr.l2.flags[1], ipv);
187
			QETH_TXQ_STAT_INC(queue, skbs_csum);
188
		}
189 190
	}

F
Frank Blaschka 已提交
191 192 193 194 195 196
	/* set byte byte 3 to casting flags */
	if (cast_type == RTN_MULTICAST)
		hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
	else if (cast_type == RTN_BROADCAST)
		hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
	else
197
		hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
F
Frank Blaschka 已提交
198 199 200 201 202 203 204 205 206 207

	/* VSWITCH relies on the VLAN
	 * information to be present in
	 * the QDIO header */
	if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) {
		hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN;
		hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI);
	}
}

208
static int qeth_l2_setdelvlan_makerc(struct qeth_card *card, u16 retcode)
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
{
	if (retcode)
		QETH_CARD_TEXT_(card, 2, "err%04x", retcode);

	switch (retcode) {
	case IPA_RC_SUCCESS:
		return 0;
	case IPA_RC_L2_INVALID_VLAN_ID:
		return -EINVAL;
	case IPA_RC_L2_DUP_VLAN_ID:
		return -EEXIST;
	case IPA_RC_L2_VLAN_ID_NOT_FOUND:
		return -ENOENT;
	case IPA_RC_L2_VLAN_ID_NOT_ALLOWED:
		return -EPERM;
	default:
		return -EIO;
	}
}

F
Frank Blaschka 已提交
229
static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
230 231
				      struct qeth_reply *reply,
				      unsigned long data)
F
Frank Blaschka 已提交
232
{
233
	struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
F
Frank Blaschka 已提交
234

C
Carsten Otte 已提交
235
	QETH_CARD_TEXT(card, 2, "L2sdvcb");
F
Frank Blaschka 已提交
236
	if (cmd->hdr.return_code) {
237
		QETH_DBF_MESSAGE(2, "Error in processing VLAN %u on device %x: %#x.\n",
238
				 cmd->data.setdelvlan.vlan_id,
239
				 CARD_DEVID(card), cmd->hdr.return_code);
C
Carsten Otte 已提交
240
		QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command);
F
Frank Blaschka 已提交
241
	}
242
	return qeth_l2_setdelvlan_makerc(card, cmd->hdr.return_code);
F
Frank Blaschka 已提交
243 244 245
}

static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
246
				   enum qeth_ipa_cmds ipacmd)
F
Frank Blaschka 已提交
247 248 249 250
{
	struct qeth_ipa_cmd *cmd;
	struct qeth_cmd_buffer *iob;

C
Carsten Otte 已提交
251
	QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd);
F
Frank Blaschka 已提交
252
	iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
253 254
	if (!iob)
		return -ENOMEM;
255
	cmd = __ipa_cmd(iob);
F
Frank Blaschka 已提交
256
	cmd->data.setdelvlan.vlan_id = i;
257
	return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelvlan_cb, NULL);
F
Frank Blaschka 已提交
258 259
}

260 261
static int qeth_l2_vlan_rx_add_vid(struct net_device *dev,
				   __be16 proto, u16 vid)
F
Frank Blaschka 已提交
262
{
263
	struct qeth_card *card = dev->ml_priv;
F
Frank Blaschka 已提交
264

C
Carsten Otte 已提交
265
	QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
U
Ursula Braun 已提交
266
	if (!vid)
267
		return 0;
268

269
	return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
F
Frank Blaschka 已提交
270 271
}

272 273
static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev,
				    __be16 proto, u16 vid)
F
Frank Blaschka 已提交
274
{
275
	struct qeth_card *card = dev->ml_priv;
F
Frank Blaschka 已提交
276

C
Carsten Otte 已提交
277
	QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
278 279
	if (!vid)
		return 0;
280

281
	return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
F
Frank Blaschka 已提交
282 283
}

284
static void qeth_l2_stop_card(struct qeth_card *card)
F
Frank Blaschka 已提交
285
{
286 287
	QETH_DBF_TEXT(SETUP , 2, "stopcard");
	QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
F
Frank Blaschka 已提交
288 289

	qeth_set_allowed_threads(card, 0, 1);
290

291 292 293
	cancel_work_sync(&card->rx_mode_work);
	qeth_l2_drain_rx_mode_cache(card);

F
Frank Blaschka 已提交
294 295 296 297 298 299
	if (card->state == CARD_STATE_SOFTSETUP) {
		qeth_clear_ipacmd_list(card);
		card->state = CARD_STATE_HARDSETUP;
	}
	if (card->state == CARD_STATE_HARDSETUP) {
		qeth_qdio_clear_card(card, 0);
300
		qeth_drain_output_queues(card);
F
Frank Blaschka 已提交
301 302 303 304 305 306 307
		qeth_clear_working_pool_list(card);
		card->state = CARD_STATE_DOWN;
	}
	if (card->state == CARD_STATE_DOWN) {
		qeth_clear_cmd_buffers(&card->read);
		qeth_clear_cmd_buffers(&card->write);
	}
308 309

	flush_workqueue(card->event_wq);
310
	card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
F
Frank Blaschka 已提交
311 312
}

313 314
static int qeth_l2_process_inbound_buffer(struct qeth_card *card,
				int budget, int *done)
F
Frank Blaschka 已提交
315
{
316
	int work_done = 0;
F
Frank Blaschka 已提交
317 318 319 320
	struct sk_buff *skb;
	struct qeth_hdr *hdr;
	unsigned int len;

321
	*done = 0;
S
Stefan Raspl 已提交
322
	WARN_ON_ONCE(!budget);
323 324
	while (budget) {
		skb = qeth_core_get_next_skb(card,
325
			&card->qdio.in_q->bufs[card->rx.b_index],
326 327 328 329
			&card->rx.b_element, &card->rx.e_offset, &hdr);
		if (!skb) {
			*done = 1;
			break;
F
Frank Blaschka 已提交
330 331 332 333
		}
		switch (hdr->hdr.l2.id) {
		case QETH_HEADER_TYPE_LAYER2:
			skb->protocol = eth_type_trans(skb, skb->dev);
334
			qeth_rx_csum(card, skb, hdr->hdr.l2.flags[1]);
335 336
			if (skb->protocol == htons(ETH_P_802_2))
				*((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;
F
Frank Blaschka 已提交
337
			len = skb->len;
338
			napi_gro_receive(&card->napi, skb);
F
Frank Blaschka 已提交
339 340
			break;
		case QETH_HEADER_TYPE_OSN:
341 342 343
			if (card->info.type == QETH_CARD_TYPE_OSN) {
				skb_push(skb, sizeof(struct qeth_hdr));
				skb_copy_to_linear_data(skb, hdr,
F
Frank Blaschka 已提交
344
						sizeof(struct qeth_hdr));
345 346 347 348 349
				len = skb->len;
				card->osn_info.data_cb(skb);
				break;
			}
			/* else unknown */
F
Frank Blaschka 已提交
350 351
		default:
			dev_kfree_skb_any(skb);
C
Carsten Otte 已提交
352
			QETH_CARD_TEXT(card, 3, "inbunkno");
353
			QETH_DBF_HEX(CTRL, 3, hdr, sizeof(*hdr));
F
Frank Blaschka 已提交
354 355
			continue;
		}
356 357
		work_done++;
		budget--;
358 359
		QETH_CARD_STAT_INC(card, rx_packets);
		QETH_CARD_STAT_ADD(card, rx_bytes, len);
F
Frank Blaschka 已提交
360
	}
361 362 363
	return work_done;
}

F
Frank Blaschka 已提交
364 365 366 367
static int qeth_l2_request_initial_mac(struct qeth_card *card)
{
	int rc = 0;

368
	QETH_DBF_TEXT(SETUP, 2, "l2reqmac");
369
	QETH_DBF_TEXT_(SETUP, 2, "doL2%s", CARD_BUS_ID(card));
F
Frank Blaschka 已提交
370

371 372 373 374
	if (MACHINE_IS_VM) {
		rc = qeth_vm_request_mac(card);
		if (!rc)
			goto out;
375 376
		QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n",
				 CARD_DEVID(card), rc);
377 378 379 380
		QETH_DBF_TEXT_(SETUP, 2, "err%04x", rc);
		/* fall back to alternative mechanism: */
	}

381
	if (!IS_OSN(card)) {
F
Frank Blaschka 已提交
382
		rc = qeth_setadpparms_change_macaddr(card);
383
		if (!rc)
384
			goto out;
385 386
		QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n",
				 CARD_DEVID(card), rc);
387 388
		QETH_DBF_TEXT_(SETUP, 2, "1err%04x", rc);
		/* fall back once more: */
F
Frank Blaschka 已提交
389
	}
390 391 392 393 394 395 396

	/* some devices don't support a custom MAC address: */
	if (card->info.type == QETH_CARD_TYPE_OSM ||
	    card->info.type == QETH_CARD_TYPE_OSX)
		return (rc) ? rc : -EADDRNOTAVAIL;
	eth_hw_addr_random(card->dev);

397 398
out:
	QETH_DBF_HEX(SETUP, 2, card->dev->dev_addr, card->dev->addr_len);
F
Frank Blaschka 已提交
399 400 401
	return 0;
}

402 403 404 405 406 407 408 409 410
static void qeth_l2_register_dev_addr(struct qeth_card *card)
{
	if (!is_valid_ether_addr(card->dev->dev_addr))
		qeth_l2_request_initial_mac(card);

	if (!IS_OSN(card) && !qeth_l2_send_setmac(card, card->dev->dev_addr))
		card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED;
}

411 412 413 414
static int qeth_l2_validate_addr(struct net_device *dev)
{
	struct qeth_card *card = dev->ml_priv;

415
	if (card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED)
416 417 418 419 420 421
		return eth_validate_addr(dev);

	QETH_CARD_TEXT(card, 4, "nomacadr");
	return -EPERM;
}

F
Frank Blaschka 已提交
422 423 424
static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
{
	struct sockaddr *addr = p;
425
	struct qeth_card *card = dev->ml_priv;
426
	u8 old_addr[ETH_ALEN];
F
Frank Blaschka 已提交
427 428
	int rc = 0;

C
Carsten Otte 已提交
429
	QETH_CARD_TEXT(card, 3, "setmac");
F
Frank Blaschka 已提交
430

431
	if (IS_OSM(card) || IS_OSX(card)) {
C
Carsten Otte 已提交
432
		QETH_CARD_TEXT(card, 3, "setmcTYP");
F
Frank Blaschka 已提交
433 434
		return -EOPNOTSUPP;
	}
435
	QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN);
436 437 438 439 440 441
	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

	/* don't register the same address twice */
	if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) &&
	    (card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))
442
		return 0;
443 444 445 446

	/* add the new address, switch over, drop the old */
	rc = qeth_l2_send_setmac(card, addr->sa_data);
	if (rc)
447
		return rc;
448 449 450 451 452 453
	ether_addr_copy(old_addr, dev->dev_addr);
	ether_addr_copy(dev->dev_addr, addr->sa_data);

	if (card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED)
		qeth_l2_remove_mac(card, old_addr);
	card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED;
454
	return 0;
F
Frank Blaschka 已提交
455 456
}

457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
static void qeth_promisc_to_bridge(struct qeth_card *card)
{
	struct net_device *dev = card->dev;
	enum qeth_ipa_promisc_modes promisc_mode;
	int role;
	int rc;

	QETH_CARD_TEXT(card, 3, "pmisc2br");

	if (!card->options.sbp.reflect_promisc)
		return;
	promisc_mode = (dev->flags & IFF_PROMISC) ? SET_PROMISC_MODE_ON
						: SET_PROMISC_MODE_OFF;
	if (promisc_mode == card->info.promisc_mode)
		return;

	if (promisc_mode == SET_PROMISC_MODE_ON) {
		if (card->options.sbp.reflect_promisc_primary)
			role = QETH_SBP_ROLE_PRIMARY;
		else
			role = QETH_SBP_ROLE_SECONDARY;
	} else
		role = QETH_SBP_ROLE_NONE;

	rc = qeth_bridgeport_setrole(card, role);
	QETH_DBF_TEXT_(SETUP, 2, "bpm%c%04x",
			(promisc_mode == SET_PROMISC_MODE_ON) ? '+' : '-', rc);
	if (!rc) {
		card->options.sbp.role = role;
		card->info.promisc_mode = promisc_mode;
	}
488 489 490 491 492 493

}
/* New MAC address is added to the hash table and marked to be written on card
 * only if there is not in the hash table storage already
 *
*/
494
static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha)
495
{
J
Julian Wiedmann 已提交
496
	u32 mac_hash = get_unaligned((u32 *)(&ha->addr[2]));
497 498
	struct qeth_mac *mac;

J
Julian Wiedmann 已提交
499
	hash_for_each_possible(card->mac_htable, mac, hnode, mac_hash) {
500
		if (ether_addr_equal_64bits(ha->addr, mac->mac_addr)) {
501
			mac->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
502 503 504 505 506 507 508 509
			return;
		}
	}

	mac = kzalloc(sizeof(struct qeth_mac), GFP_ATOMIC);
	if (!mac)
		return;

510
	ether_addr_copy(mac->mac_addr, ha->addr);
511
	mac->disp_flag = QETH_DISP_ADDR_ADD;
512

J
Julian Wiedmann 已提交
513
	hash_add(card->mac_htable, &mac->hnode, mac_hash);
514 515
}

516
static void qeth_l2_rx_mode_work(struct work_struct *work)
F
Frank Blaschka 已提交
517
{
518 519 520
	struct qeth_card *card = container_of(work, struct qeth_card,
					      rx_mode_work);
	struct net_device *dev = card->dev;
J
Jiri Pirko 已提交
521
	struct netdev_hw_addr *ha;
522 523 524 525
	struct qeth_mac *mac;
	struct hlist_node *tmp;
	int i;
	int rc;
F
Frank Blaschka 已提交
526

C
Carsten Otte 已提交
527
	QETH_CARD_TEXT(card, 3, "setmulti");
528

529
	netif_addr_lock_bh(dev);
530
	netdev_for_each_mc_addr(ha, dev)
531
		qeth_l2_add_mac(card, ha);
532
	netdev_for_each_uc_addr(ha, dev)
533
		qeth_l2_add_mac(card, ha);
534
	netif_addr_unlock_bh(dev);
535 536

	hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
537 538
		switch (mac->disp_flag) {
		case QETH_DISP_ADDR_DELETE:
539
			qeth_l2_remove_mac(card, mac->mac_addr);
540 541
			hash_del(&mac->hnode);
			kfree(mac);
542 543
			break;
		case QETH_DISP_ADDR_ADD:
544
			rc = qeth_l2_write_mac(card, mac->mac_addr);
545 546 547
			if (rc) {
				hash_del(&mac->hnode);
				kfree(mac);
548 549 550 551 552
				break;
			}
			/* fall through */
		default:
			/* for next call to set_rx_mode(): */
553
			mac->disp_flag = QETH_DISP_ADDR_DELETE;
554
		}
555
	}
556

557 558 559 560
	if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
		qeth_setadp_promisc_mode(card);
	else
		qeth_promisc_to_bridge(card);
F
Frank Blaschka 已提交
561 562
}

J
Julian Wiedmann 已提交
563 564 565
static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb,
			    struct qeth_qdio_out_q *queue)
{
566 567 568 569 570 571
	struct qeth_hdr *hdr = (struct qeth_hdr *)skb->data;
	addr_t end = (addr_t)(skb->data + sizeof(*hdr));
	addr_t start = (addr_t)skb->data;
	unsigned int elements = 0;
	unsigned int hd_len = 0;
	int rc;
J
Julian Wiedmann 已提交
572 573 574 575

	if (skb->protocol == htons(ETH_P_IPV6))
		return -EPROTONOSUPPORT;

576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
	if (qeth_get_elements_for_range(start, end) > 1) {
		/* Misaligned HW header, move it to its own buffer element. */
		hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC);
		if (!hdr)
			return -ENOMEM;
		hd_len = sizeof(*hdr);
		skb_copy_from_linear_data(skb, (char *)hdr, hd_len);
		elements++;
	}

	elements += qeth_count_elements(skb, hd_len);
	if (elements > QETH_MAX_BUFFER_ELEMENTS(card)) {
		rc = -E2BIG;
		goto out;
	}

	rc = qeth_do_send_packet(card, queue, skb, hdr, hd_len, hd_len,
				 elements);
out:
	if (rc && hd_len)
		kmem_cache_free(qeth_core_header_cache, hdr);
	return rc;
J
Julian Wiedmann 已提交
598 599 600 601 602 603
}

static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb,
					   struct net_device *dev)
{
	struct qeth_card *card = dev->ml_priv;
604
	u16 txq = skb_get_queue_mapping(skb);
J
Julian Wiedmann 已提交
605 606 607 608
	struct qeth_qdio_out_q *queue;
	int tx_bytes = skb->len;
	int rc;

609
	if (IS_IQD(card))
610 611
		txq = qeth_iqd_translate_txq(dev, txq);
	queue = card->qdio.out_qs[txq];
J
Julian Wiedmann 已提交
612

613
	if (IS_OSN(card))
J
Julian Wiedmann 已提交
614
		rc = qeth_l2_xmit_osn(card, skb, queue);
615
	else
616
		rc = qeth_xmit(card, skb, queue, qeth_get_ip_version(skb),
617
			       qeth_l2_get_cast_type(skb), qeth_l2_fill_header);
J
Julian Wiedmann 已提交
618 619

	if (!rc) {
620 621
		QETH_TXQ_STAT_INC(queue, tx_packets);
		QETH_TXQ_STAT_ADD(queue, tx_bytes, tx_bytes);
J
Julian Wiedmann 已提交
622
		return NETDEV_TX_OK;
623
	}
F
Frank Blaschka 已提交
624

625
	QETH_TXQ_STAT_INC(queue, tx_dropped);
626
	kfree_skb(skb);
F
Frank Blaschka 已提交
627 628 629
	return NETDEV_TX_OK;
}

630 631 632
static u16 qeth_l2_select_queue(struct net_device *dev, struct sk_buff *skb,
				struct net_device *sb_dev)
{
633 634 635 636 637 638 639
	struct qeth_card *card = dev->ml_priv;

	if (IS_IQD(card))
		return qeth_iqd_select_queue(dev, skb,
					     qeth_l2_get_cast_type(skb),
					     sb_dev);
	return qeth_get_priority_queue(card, skb);
640 641
}

642 643 644 645 646
static const struct device_type qeth_l2_devtype = {
	.name = "qeth_layer2",
	.groups = qeth_l2_attr_groups,
};

F
Frank Blaschka 已提交
647 648 649
static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
{
	struct qeth_card *card = dev_get_drvdata(&gdev->dev);
650
	int rc;
F
Frank Blaschka 已提交
651

652 653
	qeth_l2_vnicc_set_defaults(card);

654 655 656 657 658
	if (gdev->dev.type == &qeth_generic_devtype) {
		rc = qeth_l2_create_device_attributes(&gdev->dev);
		if (rc)
			return rc;
	}
659

660
	hash_init(card->mac_htable);
661
	INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work);
F
Frank Blaschka 已提交
662 663 664 665 666 667 668
	return 0;
}

static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
{
	struct qeth_card *card = dev_get_drvdata(&cgdev->dev);

669 670
	if (cgdev->dev.type == &qeth_generic_devtype)
		qeth_l2_remove_device_attributes(&cgdev->dev);
671
	qeth_set_allowed_threads(card, 0, 1);
F
Frank Blaschka 已提交
672 673
	wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);

674
	if (cgdev->state == CCWGROUP_ONLINE)
F
Frank Blaschka 已提交
675
		qeth_l2_set_offline(cgdev);
676 677

	cancel_work_sync(&card->close_dev_work);
678 679
	if (qeth_netdev_is_registered(card->dev))
		unregister_netdev(card->dev);
F
Frank Blaschka 已提交
680 681
}

682 683 684 685 686 687 688
static void qeth_l2_set_rx_mode(struct net_device *dev)
{
	struct qeth_card *card = dev->ml_priv;

	schedule_work(&card->rx_mode_work);
}

F
Frank Blaschka 已提交
689
static const struct net_device_ops qeth_l2_netdev_ops = {
690 691
	.ndo_open		= qeth_open,
	.ndo_stop		= qeth_stop,
692
	.ndo_get_stats64	= qeth_get_stats64,
F
Frank Blaschka 已提交
693
	.ndo_start_xmit		= qeth_l2_hard_start_xmit,
694
	.ndo_features_check	= qeth_features_check,
695
	.ndo_select_queue	= qeth_l2_select_queue,
696
	.ndo_validate_addr	= qeth_l2_validate_addr,
697
	.ndo_set_rx_mode	= qeth_l2_set_rx_mode,
698
	.ndo_do_ioctl		= qeth_do_ioctl,
F
Frank Blaschka 已提交
699 700 701 702
	.ndo_set_mac_address    = qeth_l2_set_mac_address,
	.ndo_vlan_rx_add_vid	= qeth_l2_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid   = qeth_l2_vlan_rx_kill_vid,
	.ndo_tx_timeout	   	= qeth_tx_timeout,
703 704
	.ndo_fix_features	= qeth_fix_features,
	.ndo_set_features	= qeth_set_features
F
Frank Blaschka 已提交
705 706
};

707 708 709 710 711 712 713 714 715
static const struct net_device_ops qeth_osn_netdev_ops = {
	.ndo_open		= qeth_open,
	.ndo_stop		= qeth_stop,
	.ndo_get_stats64	= qeth_get_stats64,
	.ndo_start_xmit		= qeth_l2_hard_start_xmit,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_tx_timeout		= qeth_tx_timeout,
};

J
Julian Wiedmann 已提交
716
static int qeth_l2_setup_netdev(struct qeth_card *card, bool carrier_ok)
F
Frank Blaschka 已提交
717
{
718
	int rc;
F
Frank Blaschka 已提交
719

720 721
	if (IS_OSN(card)) {
		card->dev->netdev_ops = &qeth_osn_netdev_ops;
722
		card->dev->flags |= IFF_NOARP;
723 724 725 726 727 728
		goto add_napi;
	}

	card->dev->needed_headroom = sizeof(struct qeth_hdr);
	card->dev->netdev_ops = &qeth_l2_netdev_ops;
	card->dev->priv_flags |= IFF_UNICAST_FLT;
729

730
	if (IS_OSM(card)) {
731
		card->dev->features |= NETIF_F_VLAN_CHALLENGED;
732 733 734
	} else {
		if (!IS_VM_NIC(card))
			card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
735
		card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
736
	}
737

738
	if (card->info.type == QETH_CARD_TYPE_OSD && !card->info.guestlan) {
739
		card->dev->features |= NETIF_F_SG;
740
		/* OSA 3S and earlier has no RX/TX support */
741
		if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
742
			card->dev->hw_features |= NETIF_F_IP_CSUM;
743 744
			card->dev->vlan_features |= NETIF_F_IP_CSUM;
		}
745
	}
746 747 748 749
	if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
		card->dev->hw_features |= NETIF_F_IPV6_CSUM;
		card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
	}
750 751 752 753 754
	if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) ||
	    qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) {
		card->dev->hw_features |= NETIF_F_RXCSUM;
		card->dev->vlan_features |= NETIF_F_RXCSUM;
	}
755 756 757 758 759 760 761 762 763 764 765 766 767 768
	if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
		card->dev->hw_features |= NETIF_F_TSO;
		card->dev->vlan_features |= NETIF_F_TSO;
	}
	if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
		card->dev->hw_features |= NETIF_F_TSO6;
		card->dev->vlan_features |= NETIF_F_TSO6;
	}

	if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) {
		card->dev->needed_headroom = sizeof(struct qeth_hdr_tso);
		netif_set_gso_max_size(card->dev,
				       PAGE_SIZE * (QDIO_MAX_ELEMENTS_PER_BUFFER - 1));
	}
769

770
add_napi:
771
	netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
772
	rc = register_netdev(card->dev);
J
Julian Wiedmann 已提交
773 774 775
	if (!rc && carrier_ok)
		netif_carrier_on(card->dev);

776 777 778
	if (rc)
		card->dev->netdev_ops = NULL;
	return rc;
F
Frank Blaschka 已提交
779 780
}

781 782 783 784 785 786 787 788
static int qeth_l2_start_ipassists(struct qeth_card *card)
{
	/* configure isolation level */
	if (qeth_set_access_ctrl_online(card, 0))
		return -ENODEV;
	return 0;
}

789 790
static void qeth_l2_trace_features(struct qeth_card *card)
{
H
Hans Wippel 已提交
791 792
	/* Set BridgePort features */
	QETH_CARD_TEXT(card, 2, "featuSBP");
793 794
	QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
		      sizeof(card->options.sbp.supported_funcs));
H
Hans Wippel 已提交
795 796 797 798
	/* VNIC Characteristics features */
	QETH_CARD_TEXT(card, 2, "feaVNICC");
	QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
		      sizeof(card->options.vnicc.sup_chars));
799 800
}

801
static int qeth_l2_set_online(struct ccwgroup_device *gdev)
F
Frank Blaschka 已提交
802 803
{
	struct qeth_card *card = dev_get_drvdata(&gdev->dev);
804
	struct net_device *dev = card->dev;
F
Frank Blaschka 已提交
805
	int rc = 0;
J
Julian Wiedmann 已提交
806
	bool carrier_ok;
F
Frank Blaschka 已提交
807

808
	mutex_lock(&card->discipline_mutex);
809
	mutex_lock(&card->conf_mutex);
810 811
	QETH_DBF_TEXT(SETUP, 2, "setonlin");
	QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
F
Frank Blaschka 已提交
812

J
Julian Wiedmann 已提交
813
	rc = qeth_core_hardsetup_card(card, &carrier_ok);
F
Frank Blaschka 已提交
814
	if (rc) {
815
		QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
816
		rc = -ENODEV;
F
Frank Blaschka 已提交
817 818
		goto out_remove;
	}
819

820 821 822 823 824 825 826
	if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
		if (card->info.hwtrap &&
		    qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
			card->info.hwtrap = 0;
	} else
		card->info.hwtrap = 0;

827 828 829 830 831 832 833
	qeth_bridgeport_query_support(card);
	if (card->options.sbp.supported_funcs)
		dev_info(&card->gdev->dev,
		"The device represents a Bridge Capable Port\n");

	qeth_l2_register_dev_addr(card);

H
Hans Wippel 已提交
834 835 836 837 838 839
	/* for the rx_bcast characteristic, init VNICC after setmac */
	qeth_l2_vnicc_init(card);

	qeth_trace_features(card);
	qeth_l2_trace_features(card);

840 841
	qeth_l2_setup_bridgeport_attrs(card);

F
Frank Blaschka 已提交
842 843 844 845
	card->state = CARD_STATE_HARDSETUP;
	qeth_print_status_message(card);

	/* softsetup */
846
	QETH_DBF_TEXT(SETUP, 2, "softsetp");
F
Frank Blaschka 已提交
847

848
	if ((card->info.type == QETH_CARD_TYPE_OSD) ||
S
Stefan Raspl 已提交
849
	    (card->info.type == QETH_CARD_TYPE_OSX)) {
850 851
		rc = qeth_l2_start_ipassists(card);
		if (rc)
S
Stefan Raspl 已提交
852 853
			goto out_remove;
	}
854

F
Frank Blaschka 已提交
855 856
	rc = qeth_init_qdio_queues(card);
	if (rc) {
857
		QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
858
		rc = -ENODEV;
F
Frank Blaschka 已提交
859 860 861 862 863
		goto out_remove;
	}
	card->state = CARD_STATE_SOFTSETUP;

	qeth_set_allowed_threads(card, 0xffffffff, 0);
864

865 866 867 868 869 870 871 872 873 874 875
	if (!qeth_netdev_is_registered(dev)) {
		rc = qeth_l2_setup_netdev(card, carrier_ok);
		if (rc)
			goto out_remove;
	} else {
		rtnl_lock();
		if (carrier_ok)
			netif_carrier_on(dev);
		else
			netif_carrier_off(dev);

876
		netif_device_attach(dev);
877 878
		qeth_enable_hw_features(dev);

879 880
		if (card->info.open_when_online) {
			card->info.open_when_online = 0;
881
			dev_open(dev, NULL);
F
Frank Blaschka 已提交
882
		}
883
		rtnl_unlock();
F
Frank Blaschka 已提交
884 885 886
	}
	/* let user_space know that device is online */
	kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
887
	mutex_unlock(&card->conf_mutex);
888
	mutex_unlock(&card->discipline_mutex);
F
Frank Blaschka 已提交
889
	return 0;
890

F
Frank Blaschka 已提交
891
out_remove:
892
	qeth_l2_stop_card(card);
F
Frank Blaschka 已提交
893 894 895
	ccw_device_set_offline(CARD_DDEV(card));
	ccw_device_set_offline(CARD_WDEV(card));
	ccw_device_set_offline(CARD_RDEV(card));
896
	qdio_free(CARD_DDEV(card));
897 898
	card->state = CARD_STATE_DOWN;

899
	mutex_unlock(&card->conf_mutex);
900
	mutex_unlock(&card->discipline_mutex);
901
	return rc;
F
Frank Blaschka 已提交
902 903 904 905 906 907 908 909
}

static int __qeth_l2_set_offline(struct ccwgroup_device *cgdev,
					int recovery_mode)
{
	struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
	int rc = 0, rc2 = 0, rc3 = 0;

910
	mutex_lock(&card->discipline_mutex);
911
	mutex_lock(&card->conf_mutex);
912 913
	QETH_DBF_TEXT(SETUP, 3, "setoffl");
	QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
F
Frank Blaschka 已提交
914

915 916 917 918 919
	if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
		qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
		card->info.hwtrap = 1;
	}

920
	rtnl_lock();
921
	card->info.open_when_online = card->dev->flags & IFF_UP;
922
	dev_close(card->dev);
923
	netif_device_detach(card->dev);
924
	netif_carrier_off(card->dev);
925 926
	rtnl_unlock();

927
	qeth_l2_stop_card(card);
F
Frank Blaschka 已提交
928 929 930 931 932 933
	rc  = ccw_device_set_offline(CARD_DDEV(card));
	rc2 = ccw_device_set_offline(CARD_WDEV(card));
	rc3 = ccw_device_set_offline(CARD_RDEV(card));
	if (!rc)
		rc = (rc2) ? rc2 : rc3;
	if (rc)
934
		QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
935
	qdio_free(CARD_DDEV(card));
936

F
Frank Blaschka 已提交
937 938
	/* let user_space know that device is offline */
	kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
939
	mutex_unlock(&card->conf_mutex);
940
	mutex_unlock(&card->discipline_mutex);
F
Frank Blaschka 已提交
941 942 943 944 945 946 947 948 949 950 951 952 953 954
	return 0;
}

static int qeth_l2_set_offline(struct ccwgroup_device *cgdev)
{
	return __qeth_l2_set_offline(cgdev, 0);
}

static int qeth_l2_recover(void *ptr)
{
	struct qeth_card *card;
	int rc = 0;

	card = (struct qeth_card *) ptr;
C
Carsten Otte 已提交
955
	QETH_CARD_TEXT(card, 2, "recover1");
F
Frank Blaschka 已提交
956 957
	if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
		return 0;
C
Carsten Otte 已提交
958
	QETH_CARD_TEXT(card, 2, "recover2");
959 960
	dev_warn(&card->gdev->dev,
		"A recovery process has been started for the device\n");
F
Frank Blaschka 已提交
961
	__qeth_l2_set_offline(card->gdev, 1);
962
	rc = qeth_l2_set_online(card->gdev);
F
Frank Blaschka 已提交
963
	if (!rc)
964 965
		dev_info(&card->gdev->dev,
			"Device successfully recovered!\n");
966
	else {
967
		ccwgroup_set_offline(card->gdev);
S
Stefan Raspl 已提交
968
		dev_warn(&card->gdev->dev, "The qeth device driver "
969
				"failed to recover an error on the device\n");
970
	}
971 972
	qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
	qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
F
Frank Blaschka 已提交
973 974 975 976 977
	return 0;
}

static int __init qeth_l2_init(void)
{
978
	pr_info("register layer 2 discipline\n");
F
Frank Blaschka 已提交
979 980 981 982 983
	return 0;
}

static void __exit qeth_l2_exit(void)
{
984
	pr_info("unregister layer 2 discipline\n");
F
Frank Blaschka 已提交
985 986
}

987 988 989 990 991 992 993 994
static int qeth_l2_pm_suspend(struct ccwgroup_device *gdev)
{
	struct qeth_card *card = dev_get_drvdata(&gdev->dev);

	qeth_set_allowed_threads(card, 0, 1);
	wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
	if (gdev->state == CCWGROUP_OFFLINE)
		return 0;
995 996

	qeth_l2_set_offline(gdev);
997 998 999 1000 1001 1002
	return 0;
}

static int qeth_l2_pm_resume(struct ccwgroup_device *gdev)
{
	struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1003
	int rc;
1004

1005
	rc = qeth_l2_set_online(gdev);
1006

1007 1008 1009 1010 1011 1012 1013
	qeth_set_allowed_threads(card, 0xffffffff, 0);
	if (rc)
		dev_warn(&card->gdev->dev, "The qeth device driver "
			"failed to recover an error on the device\n");
	return rc;
}

1014 1015 1016 1017 1018
/* Returns zero if the command is successfully "consumed" */
static int qeth_l2_control_event(struct qeth_card *card,
					struct qeth_ipa_cmd *cmd)
{
	switch (cmd->hdr.command) {
1019 1020
	case IPA_CMD_SETBRIDGEPORT_OSA:
	case IPA_CMD_SETBRIDGEPORT_IQD:
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
		if (cmd->data.sbp.hdr.command_code ==
				IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
			qeth_bridge_state_change(card, cmd);
			return 0;
		} else
			return 1;
	case IPA_CMD_ADDRESS_CHANGE_NOTIF:
		qeth_bridge_host_event(card, cmd);
		return 0;
	default:
		return 1;
	}
}

1035
struct qeth_discipline qeth_l2_discipline = {
1036
	.devtype = &qeth_l2_devtype,
1037
	.process_rx_buffer = qeth_l2_process_inbound_buffer,
1038 1039
	.recover = qeth_l2_recover,
	.setup = qeth_l2_probe_device,
F
Frank Blaschka 已提交
1040 1041 1042
	.remove = qeth_l2_remove_device,
	.set_online = qeth_l2_set_online,
	.set_offline = qeth_l2_set_offline,
1043 1044 1045
	.freeze = qeth_l2_pm_suspend,
	.thaw = qeth_l2_pm_resume,
	.restore = qeth_l2_pm_resume,
1046
	.do_ioctl = NULL,
1047
	.control_event_handler = qeth_l2_control_event,
F
Frank Blaschka 已提交
1048
};
1049
EXPORT_SYMBOL_GPL(qeth_l2_discipline);
F
Frank Blaschka 已提交
1050 1051 1052 1053

static int qeth_osn_send_control_data(struct qeth_card *card, int len,
			   struct qeth_cmd_buffer *iob)
{
1054
	struct qeth_channel *channel = iob->channel;
F
Frank Blaschka 已提交
1055 1056
	int rc = 0;

C
Carsten Otte 已提交
1057
	QETH_CARD_TEXT(card, 5, "osndctrd");
F
Frank Blaschka 已提交
1058

1059
	wait_event(card->wait_q, qeth_trylock_channel(channel));
1060 1061
	iob->finalize(card, iob, len);
	QETH_DBF_HEX(CTRL, 2, iob->data, min(len, QETH_DBF_CTRL_LEN));
C
Carsten Otte 已提交
1062
	QETH_CARD_TEXT(card, 6, "osnoirqp");
J
Julian Wiedmann 已提交
1063
	spin_lock_irq(get_ccwdev_lock(channel->ccwdev));
1064
	rc = ccw_device_start_timeout(channel->ccwdev, channel->ccw,
1065
				      (addr_t) iob, 0, 0, iob->timeout);
J
Julian Wiedmann 已提交
1066
	spin_unlock_irq(get_ccwdev_lock(channel->ccwdev));
F
Frank Blaschka 已提交
1067
	if (rc) {
1068
		QETH_DBF_MESSAGE(2, "qeth_osn_send_control_data: "
F
Frank Blaschka 已提交
1069
			   "ccw_device_start rc = %i\n", rc);
C
Carsten Otte 已提交
1070
		QETH_CARD_TEXT_(card, 2, " err%d", rc);
1071 1072
		qeth_release_buffer(channel, iob);
		atomic_set(&channel->irq_pending, 0);
F
Frank Blaschka 已提交
1073 1074 1075 1076 1077 1078
		wake_up(&card->wait_q);
	}
	return rc;
}

static int qeth_osn_send_ipa_cmd(struct qeth_card *card,
1079
				 struct qeth_cmd_buffer *iob)
F
Frank Blaschka 已提交
1080
{
1081
	u16 length;
F
Frank Blaschka 已提交
1082

C
Carsten Otte 已提交
1083
	QETH_CARD_TEXT(card, 4, "osndipa");
F
Frank Blaschka 已提交
1084

1085 1086
	memcpy(&length, QETH_IPA_PDU_LEN_TOTAL(iob->data), 2);
	return qeth_osn_send_control_data(card, length, iob);
F
Frank Blaschka 已提交
1087 1088 1089 1090 1091 1092 1093 1094 1095
}

int qeth_osn_assist(struct net_device *dev, void *data, int data_len)
{
	struct qeth_cmd_buffer *iob;
	struct qeth_card *card;

	if (!dev)
		return -ENODEV;
1096
	card = dev->ml_priv;
F
Frank Blaschka 已提交
1097 1098
	if (!card)
		return -ENODEV;
C
Carsten Otte 已提交
1099
	QETH_CARD_TEXT(card, 2, "osnsdmc");
1100
	if (!qeth_card_hw_is_reachable(card))
F
Frank Blaschka 已提交
1101 1102
		return -ENODEV;
	iob = qeth_wait_for_buffer(&card->write);
1103
	qeth_prepare_ipa_cmd(card, iob, (u16) data_len);
1104
	memcpy(__ipa_cmd(iob), data, data_len);
1105
	return qeth_osn_send_ipa_cmd(card, iob);
F
Frank Blaschka 已提交
1106 1107 1108 1109 1110 1111 1112 1113
}
EXPORT_SYMBOL(qeth_osn_assist);

int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev,
		  int (*assist_cb)(struct net_device *, void *),
		  int (*data_cb)(struct sk_buff *))
{
	struct qeth_card *card;
J
Julian Wiedmann 已提交
1114 1115
	char bus_id[16];
	u16 devno;
F
Frank Blaschka 已提交
1116

J
Julian Wiedmann 已提交
1117 1118 1119 1120
	memcpy(&devno, read_dev_no, 2);
	sprintf(bus_id, "0.0.%04x", devno);
	card = qeth_get_card_by_busid(bus_id);
	if (!card || !IS_OSN(card))
F
Frank Blaschka 已提交
1121
		return -ENODEV;
J
Julian Wiedmann 已提交
1122 1123
	*dev = card->dev;

C
Carsten Otte 已提交
1124
	QETH_CARD_TEXT(card, 2, "osnreg");
F
Frank Blaschka 已提交
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138
	if ((assist_cb == NULL) || (data_cb == NULL))
		return -EINVAL;
	card->osn_info.assist_cb = assist_cb;
	card->osn_info.data_cb = data_cb;
	return 0;
}
EXPORT_SYMBOL(qeth_osn_register);

void qeth_osn_deregister(struct net_device *dev)
{
	struct qeth_card *card;

	if (!dev)
		return;
1139
	card = dev->ml_priv;
F
Frank Blaschka 已提交
1140 1141
	if (!card)
		return;
C
Carsten Otte 已提交
1142
	QETH_CARD_TEXT(card, 2, "osndereg");
F
Frank Blaschka 已提交
1143 1144 1145 1146 1147 1148
	card->osn_info.assist_cb = NULL;
	card->osn_info.data_cb = NULL;
	return;
}
EXPORT_SYMBOL(qeth_osn_deregister);

1149 1150
/* SETBRIDGEPORT support, async notifications */

1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset};

/**
 * qeth_bridge_emit_host_event() - bridgeport address change notification
 * @card:  qeth_card structure pointer, for udev events.
 * @evtype:  "normal" register/unregister, or abort, or reset. For abort
 *	      and reset token and addr_lnid are unused and may be NULL.
 * @code:  event bitmask: high order bit 0x80 value 1 means removal of an
 *			  object, 0 - addition of an object.
 *			  0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC.
 * @token: "network token" structure identifying physical address of the port.
 * @addr_lnid: pointer to structure with MAC address and VLAN ID.
 *
 * This function is called when registrations and deregistrations are
 * reported by the hardware, and also when notifications are enabled -
 * for all currently registered addresses.
 */
static void qeth_bridge_emit_host_event(struct qeth_card *card,
	enum qeth_an_event_type evtype,
	u8 code, struct net_if_token *token, struct mac_addr_lnid *addr_lnid)
{
	char str[7][32];
	char *env[8];
	int i = 0;

	switch (evtype) {
	case anev_reg_unreg:
		snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s",
				(code & IPA_ADDR_CHANGE_CODE_REMOVAL)
				? "deregister" : "register");
		env[i] = str[i]; i++;
		if (code & IPA_ADDR_CHANGE_CODE_VLANID) {
			snprintf(str[i], sizeof(str[i]), "VLAN=%d",
				addr_lnid->lnid);
			env[i] = str[i]; i++;
		}
		if (code & IPA_ADDR_CHANGE_CODE_MACADDR) {
1188
			snprintf(str[i], sizeof(str[i]), "MAC=%pM",
1189
				addr_lnid->mac);
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
			env[i] = str[i]; i++;
		}
		snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x",
			token->cssid, token->ssid, token->devnum);
		env[i] = str[i]; i++;
		snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid);
		env[i] = str[i]; i++;
		snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x",
				token->chpid);
		env[i] = str[i]; i++;
		snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid);
		env[i] = str[i]; i++;
		break;
	case anev_abort:
		snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort");
		env[i] = str[i]; i++;
		break;
	case anev_reset:
		snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset");
		env[i] = str[i]; i++;
		break;
	}
	env[i] = NULL;
	kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
}

1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
struct qeth_bridge_state_data {
	struct work_struct worker;
	struct qeth_card *card;
	struct qeth_sbp_state_change qports;
};

static void qeth_bridge_state_change_worker(struct work_struct *work)
{
	struct qeth_bridge_state_data *data =
		container_of(work, struct qeth_bridge_state_data, worker);
	/* We are only interested in the first entry - local port */
	struct qeth_sbp_port_entry *entry = &data->qports.entry[0];
	char env_locrem[32];
	char env_role[32];
	char env_state[32];
	char *env[] = {
		env_locrem,
		env_role,
		env_state,
		NULL
	};

	/* Role should not change by itself, but if it did, */
	/* information from the hardware is authoritative.  */
	mutex_lock(&data->card->conf_mutex);
	data->card->options.sbp.role = entry->role;
	mutex_unlock(&data->card->conf_mutex);

	snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange");
	snprintf(env_role, sizeof(env_role), "ROLE=%s",
		(entry->role == QETH_SBP_ROLE_NONE) ? "none" :
		(entry->role == QETH_SBP_ROLE_PRIMARY) ? "primary" :
		(entry->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" :
		"<INVALID>");
	snprintf(env_state, sizeof(env_state), "STATE=%s",
		(entry->state == QETH_SBP_STATE_INACTIVE) ? "inactive" :
		(entry->state == QETH_SBP_STATE_STANDBY) ? "standby" :
		(entry->state == QETH_SBP_STATE_ACTIVE) ? "active" :
		"<INVALID>");
	kobject_uevent_env(&data->card->gdev->dev.kobj,
				KOBJ_CHANGE, env);
	kfree(data);
}

1260 1261
static void qeth_bridge_state_change(struct qeth_card *card,
					struct qeth_ipa_cmd *cmd)
1262 1263 1264 1265 1266 1267 1268 1269
{
	struct qeth_sbp_state_change *qports =
		 &cmd->data.sbp.data.state_change;
	struct qeth_bridge_state_data *data;
	int extrasize;

	QETH_CARD_TEXT(card, 2, "brstchng");
	if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1270
		QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
		return;
	}
	extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries;
	data = kzalloc(sizeof(struct qeth_bridge_state_data) + extrasize,
		GFP_ATOMIC);
	if (!data) {
		QETH_CARD_TEXT(card, 2, "BPSalloc");
		return;
	}
	INIT_WORK(&data->worker, qeth_bridge_state_change_worker);
	data->card = card;
	memcpy(&data->qports, qports,
			sizeof(struct qeth_sbp_state_change) + extrasize);
1284
	queue_work(card->event_wq, &data->worker);
1285 1286
}

1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
struct qeth_bridge_host_data {
	struct work_struct worker;
	struct qeth_card *card;
	struct qeth_ipacmd_addr_change hostevs;
};

static void qeth_bridge_host_event_worker(struct work_struct *work)
{
	struct qeth_bridge_host_data *data =
		container_of(work, struct qeth_bridge_host_data, worker);
	int i;

	if (data->hostevs.lost_event_mask) {
		dev_info(&data->card->gdev->dev,
1301
"Address notification from the Bridge Port stopped %s (%s)\n",
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
			data->card->dev->name,
			(data->hostevs.lost_event_mask == 0x01)
			? "Overflow"
			: (data->hostevs.lost_event_mask == 0x02)
			? "Bridge port state change"
			: "Unknown reason");
		mutex_lock(&data->card->conf_mutex);
		data->card->options.sbp.hostnotification = 0;
		mutex_unlock(&data->card->conf_mutex);
		qeth_bridge_emit_host_event(data->card, anev_abort,
			0, NULL, NULL);
	} else
		for (i = 0; i < data->hostevs.num_entries; i++) {
			struct qeth_ipacmd_addr_change_entry *entry =
					&data->hostevs.entry[i];
			qeth_bridge_emit_host_event(data->card,
					anev_reg_unreg,
					entry->change_code,
					&entry->token, &entry->addr_lnid);
		}
	kfree(data);
}

1325 1326
static void qeth_bridge_host_event(struct qeth_card *card,
					struct qeth_ipa_cmd *cmd)
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
{
	struct qeth_ipacmd_addr_change *hostevs =
		 &cmd->data.addrchange;
	struct qeth_bridge_host_data *data;
	int extrasize;

	QETH_CARD_TEXT(card, 2, "brhostev");
	if (cmd->hdr.return_code != 0x0000) {
		if (cmd->hdr.return_code == 0x0010) {
			if (hostevs->lost_event_mask == 0x00)
				hostevs->lost_event_mask = 0xff;
		} else {
			QETH_CARD_TEXT_(card, 2, "BPHe%04x",
				cmd->hdr.return_code);
			return;
		}
	}
	extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) *
						hostevs->num_entries;
	data = kzalloc(sizeof(struct qeth_bridge_host_data) + extrasize,
		GFP_ATOMIC);
	if (!data) {
		QETH_CARD_TEXT(card, 2, "BPHalloc");
		return;
	}
	INIT_WORK(&data->worker, qeth_bridge_host_event_worker);
	data->card = card;
	memcpy(&data->hostevs, hostevs,
			sizeof(struct qeth_ipacmd_addr_change) + extrasize);
1356
	queue_work(card->event_wq, &data->worker);
1357 1358
}

1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371
/* SETBRIDGEPORT support; sending commands */

struct _qeth_sbp_cbctl {
	union {
		u32 supported;
		struct {
			enum qeth_sbp_roles *role;
			enum qeth_sbp_states *state;
		} qports;
	} data;
};

static int qeth_bridgeport_makerc(struct qeth_card *card,
1372
				  struct qeth_ipa_cmd *cmd)
1373
{
1374 1375 1376 1377
	struct qeth_ipacmd_setbridgeport *sbp = &cmd->data.sbp;
	enum qeth_ipa_sbp_cmd setcmd = sbp->hdr.command_code;
	u16 ipa_rc = cmd->hdr.return_code;
	u16 sbp_rc = sbp->hdr.return_code;
1378 1379
	int rc;

1380 1381 1382 1383 1384 1385
	if (ipa_rc == IPA_RC_SUCCESS && sbp_rc == IPA_RC_SUCCESS)
		return 0;

	if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) ||
	    (!IS_IQD(card) && ipa_rc == sbp_rc)) {
		switch (sbp_rc) {
1386
		case IPA_RC_SUCCESS:
1387 1388
			rc = 0;
			break;
1389 1390
		case IPA_RC_L2_UNSUPPORTED_CMD:
		case IPA_RC_UNSUPPORTED_COMMAND:
1391
			rc = -EOPNOTSUPP;
1392
			break;
1393 1394
		case IPA_RC_SBP_OSA_NOT_CONFIGURED:
		case IPA_RC_SBP_IQD_NOT_CONFIGURED:
1395 1396
			rc = -ENODEV; /* maybe not the best code here? */
			dev_err(&card->gdev->dev,
1397
	"The device is not configured as a Bridge Port\n");
1398
			break;
1399 1400
		case IPA_RC_SBP_OSA_OS_MISMATCH:
		case IPA_RC_SBP_IQD_OS_MISMATCH:
1401 1402 1403 1404
			rc = -EPERM;
			dev_err(&card->gdev->dev,
	"A Bridge Port is already configured by a different operating system\n");
			break;
1405 1406
		case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY:
		case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY:
1407 1408 1409 1410
			switch (setcmd) {
			case IPA_SBP_SET_PRIMARY_BRIDGE_PORT:
				rc = -EEXIST;
				dev_err(&card->gdev->dev,
1411
	"The LAN already has a primary Bridge Port\n");
1412 1413 1414 1415
				break;
			case IPA_SBP_SET_SECONDARY_BRIDGE_PORT:
				rc = -EBUSY;
				dev_err(&card->gdev->dev,
1416
	"The device is already a primary Bridge Port\n");
1417 1418 1419 1420 1421
				break;
			default:
				rc = -EIO;
			}
			break;
1422 1423
		case IPA_RC_SBP_OSA_CURRENT_SECOND:
		case IPA_RC_SBP_IQD_CURRENT_SECOND:
1424 1425
			rc = -EBUSY;
			dev_err(&card->gdev->dev,
1426
	"The device is already a secondary Bridge Port\n");
1427
			break;
1428 1429
		case IPA_RC_SBP_OSA_LIMIT_SECOND:
		case IPA_RC_SBP_IQD_LIMIT_SECOND:
1430 1431
			rc = -EEXIST;
			dev_err(&card->gdev->dev,
1432
	"The LAN cannot have more secondary Bridge Ports\n");
1433
			break;
1434 1435
		case IPA_RC_SBP_OSA_CURRENT_PRIMARY:
		case IPA_RC_SBP_IQD_CURRENT_PRIMARY:
1436 1437
			rc = -EBUSY;
			dev_err(&card->gdev->dev,
1438
	"The device is already a primary Bridge Port\n");
1439
			break;
1440 1441
		case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN:
		case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN:
1442 1443
			rc = -EACCES;
			dev_err(&card->gdev->dev,
1444
	"The device is not authorized to be a Bridge Port\n");
1445 1446 1447 1448
			break;
		default:
			rc = -EIO;
		}
1449 1450
	} else {
		switch (ipa_rc) {
1451
		case IPA_RC_NOTSUPP:
1452
			rc = -EOPNOTSUPP;
1453 1454
			break;
		case IPA_RC_UNSUPPORTED_COMMAND:
1455
			rc = -EOPNOTSUPP;
1456 1457 1458 1459
			break;
		default:
			rc = -EIO;
		}
1460
	}
1461

1462
	if (rc) {
1463 1464
		QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc);
		QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc);
1465 1466 1467 1468
	}
	return rc;
}

1469 1470 1471
static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
						  enum qeth_ipa_sbp_cmd sbp_cmd,
						  unsigned int cmd_length)
1472
{
1473 1474 1475 1476 1477 1478 1479 1480 1481
	enum qeth_ipa_cmds ipa_cmd = (card->info.type == QETH_CARD_TYPE_IQD) ?
					IPA_CMD_SETBRIDGEPORT_IQD :
					IPA_CMD_SETBRIDGEPORT_OSA;
	struct qeth_cmd_buffer *iob;
	struct qeth_ipa_cmd *cmd;

	iob = qeth_get_ipacmd_buffer(card, ipa_cmd, 0);
	if (!iob)
		return iob;
1482
	cmd = __ipa_cmd(iob);
1483 1484 1485 1486 1487 1488
	cmd->data.sbp.hdr.cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) +
				      cmd_length;
	cmd->data.sbp.hdr.command_code = sbp_cmd;
	cmd->data.sbp.hdr.used_total = 1;
	cmd->data.sbp.hdr.seq_no = 1;
	return iob;
1489 1490
}

1491 1492 1493 1494 1495
static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
	struct qeth_reply *reply, unsigned long data)
{
	struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
	struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1496 1497
	int rc;

1498
	QETH_CARD_TEXT(card, 2, "brqsupcb");
1499 1500 1501 1502 1503 1504
	rc = qeth_bridgeport_makerc(card, cmd);
	if (rc)
		return rc;

	cbctl->data.supported =
		cmd->data.sbp.data.query_cmds_supp.supported_cmds;
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
	return 0;
}

/**
 * qeth_bridgeport_query_support() - store bitmask of supported subfunctions.
 * @card:			     qeth_card structure pointer.
 *
 * Sets bitmask of supported setbridgeport subfunctions in the qeth_card
 * strucutre: card->options.sbp.supported_funcs.
 */
1515
static void qeth_bridgeport_query_support(struct qeth_card *card)
1516 1517 1518 1519 1520
{
	struct qeth_cmd_buffer *iob;
	struct _qeth_sbp_cbctl cbctl;

	QETH_CARD_TEXT(card, 2, "brqsuppo");
1521 1522
	iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
				 sizeof(struct qeth_sbp_query_cmds_supp));
1523 1524
	if (!iob)
		return;
1525

1526
	if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1527
			      &cbctl)) {
1528
		card->options.sbp.role = QETH_SBP_ROLE_NONE;
1529
		card->options.sbp.supported_funcs = 0;
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
		return;
	}
	card->options.sbp.supported_funcs = cbctl.data.supported;
}

static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
	struct qeth_reply *reply, unsigned long data)
{
	struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
	struct qeth_sbp_query_ports *qports = &cmd->data.sbp.data.query_ports;
	struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1541
	int rc;
1542 1543

	QETH_CARD_TEXT(card, 2, "brqprtcb");
1544 1545 1546 1547
	rc = qeth_bridgeport_makerc(card, cmd);
	if (rc)
		return rc;

1548 1549
	if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
		QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1550
		return -EINVAL;
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
	}
	/* first entry contains the state of the local port */
	if (qports->num_entries > 0) {
		if (cbctl->data.qports.role)
			*cbctl->data.qports.role = qports->entry[0].role;
		if (cbctl->data.qports.state)
			*cbctl->data.qports.state = qports->entry[0].state;
	}
	return 0;
}

/**
 * qeth_bridgeport_query_ports() - query local bridgeport status.
 * @card:			   qeth_card structure pointer.
 * @role:   Role of the port: 0-none, 1-primary, 2-secondary.
 * @state:  State of the port: 0-inactive, 1-standby, 2-active.
 *
 * Returns negative errno-compatible error indication or 0 on success.
 *
 * 'role' and 'state' are not updated in case of hardware operation failure.
 */
int qeth_bridgeport_query_ports(struct qeth_card *card,
	enum qeth_sbp_roles *role, enum qeth_sbp_states *state)
{
	struct qeth_cmd_buffer *iob;
	struct _qeth_sbp_cbctl cbctl = {
		.data = {
			.qports = {
				.role = role,
				.state = state,
			},
		},
	};

	QETH_CARD_TEXT(card, 2, "brqports");
	if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
		return -EOPNOTSUPP;
1588
	iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
1589 1590
	if (!iob)
		return -ENOMEM;
1591 1592 1593

	return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
				 &cbctl);
1594 1595 1596 1597 1598 1599
}

static int qeth_bridgeport_set_cb(struct qeth_card *card,
	struct qeth_reply *reply, unsigned long data)
{
	struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data;
1600

1601
	QETH_CARD_TEXT(card, 2, "brsetrcb");
1602
	return qeth_bridgeport_makerc(card, cmd);
1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
}

/**
 * qeth_bridgeport_setrole() - Assign primary role to the port.
 * @card:		       qeth_card structure pointer.
 * @role:		       Role to assign.
 *
 * Returns negative errno-compatible error indication or 0 on success.
 */
int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
{
	int cmdlength;
	struct qeth_cmd_buffer *iob;
	enum qeth_ipa_sbp_cmd setcmd;

	QETH_CARD_TEXT(card, 2, "brsetrol");
	switch (role) {
	case QETH_SBP_ROLE_NONE:
		setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE;
1622
		cmdlength = sizeof(struct qeth_sbp_reset_role);
1623 1624 1625
		break;
	case QETH_SBP_ROLE_PRIMARY:
		setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT;
1626
		cmdlength = sizeof(struct qeth_sbp_set_primary);
1627 1628 1629
		break;
	case QETH_SBP_ROLE_SECONDARY:
		setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT;
1630
		cmdlength = sizeof(struct qeth_sbp_set_secondary);
1631 1632 1633 1634 1635 1636
		break;
	default:
		return -EINVAL;
	}
	if (!(card->options.sbp.supported_funcs & setcmd))
		return -EOPNOTSUPP;
1637
	iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
1638 1639
	if (!iob)
		return -ENOMEM;
1640 1641

	return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL);
1642 1643
}

1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
/**
 * qeth_anset_makerc() - derive "traditional" error from hardware codes.
 * @card:		      qeth_card structure pointer, for debug messages.
 *
 * Returns negative errno-compatible error indication or 0 on success.
 */
static int qeth_anset_makerc(struct qeth_card *card, int pnso_rc, u16 response)
{
	int rc;

	if (pnso_rc == 0)
		switch (response) {
		case 0x0001:
			rc = 0;
			break;
		case 0x0004:
		case 0x0100:
		case 0x0106:
1662
			rc = -EOPNOTSUPP;
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
			dev_err(&card->gdev->dev,
				"Setting address notification failed\n");
			break;
		case 0x0107:
			rc = -EAGAIN;
			break;
		default:
			rc = -EIO;
		}
	else
		rc = -EIO;

	if (rc) {
		QETH_CARD_TEXT_(card, 2, "SBPp%04x", pnso_rc);
		QETH_CARD_TEXT_(card, 2, "SBPr%04x", response);
	}
	return rc;
}

static void qeth_bridgeport_an_set_cb(void *priv,
		enum qdio_brinfo_entry_type type, void *entry)
{
	struct qeth_card *card = (struct qeth_card *)priv;
	struct qdio_brinfo_entry_l2 *l2entry;
	u8 code;

	if (type != l2_addr_lnid) {
		WARN_ON_ONCE(1);
		return;
	}

	l2entry = (struct qdio_brinfo_entry_l2 *)entry;
	code = IPA_ADDR_CHANGE_CODE_MACADDR;
	if (l2entry->addr_lnid.lnid)
		code |= IPA_ADDR_CHANGE_CODE_VLANID;
	qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
		(struct net_if_token *)&l2entry->nit,
		(struct mac_addr_lnid *)&l2entry->addr_lnid);
}

/**
 * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification
 * @card:		      qeth_card structure pointer.
 * @enable:		      0 - disable, non-zero - enable notifications
 *
 * Returns negative errno-compatible error indication or 0 on success.
 *
 * On enable, emits a series of address notifications udev events for all
 * currently registered hosts.
 */
int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
{
	int rc;
	u16 response;
	struct ccw_device *ddev;
	struct subchannel_id schid;

	if (!card)
		return -EINVAL;
	if (!card->options.sbp.supported_funcs)
		return -EOPNOTSUPP;
	ddev = CARD_DDEV(card);
	ccw_device_get_schid(ddev, &schid);

	if (enable) {
		qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
		rc = qdio_pnso_brinfo(schid, 1, &response,
			qeth_bridgeport_an_set_cb, card);
	} else
		rc = qdio_pnso_brinfo(schid, 0, &response, NULL, NULL);
	return qeth_anset_makerc(card, rc, response);
}

1736 1737 1738 1739 1740 1741
static bool qeth_bridgeport_is_in_use(struct qeth_card *card)
{
	return (card->options.sbp.role || card->options.sbp.reflect_promisc ||
		card->options.sbp.hostnotification);
}

H
Hans Wippel 已提交
1742 1743 1744
/* VNIC Characteristics support */

/* handle VNICC IPA command return codes; convert to error codes */
1745
static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc)
H
Hans Wippel 已提交
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
{
	int rc;

	switch (ipa_rc) {
	case IPA_RC_SUCCESS:
		return ipa_rc;
	case IPA_RC_L2_UNSUPPORTED_CMD:
	case IPA_RC_NOTSUPP:
		rc = -EOPNOTSUPP;
		break;
	case IPA_RC_VNICC_OOSEQ:
		rc = -EALREADY;
		break;
	case IPA_RC_VNICC_VNICBP:
		rc = -EBUSY;
		break;
	case IPA_RC_L2_ADDR_TABLE_FULL:
		rc = -ENOSPC;
		break;
	case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
		rc = -EACCES;
		break;
	default:
		rc = -EIO;
	}

	QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
	return rc;
}

/* generic VNICC request call back control */
struct _qeth_l2_vnicc_request_cbctl {
	u32 sub_cmd;
1779 1780
	struct {
		u32 vnic_char;
1781
		u32 timeout;
1782 1783
	} param;
	struct {
1784 1785 1786 1787
		union{
			u32 *sup_cmds;
			u32 *timeout;
		};
1788
	} result;
H
Hans Wippel 已提交
1789 1790 1791 1792 1793 1794 1795
};

/* generic VNICC request call back */
static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
				    struct qeth_reply *reply,
				    unsigned long data)
{
1796 1797
	struct _qeth_l2_vnicc_request_cbctl *cbctl =
		(struct _qeth_l2_vnicc_request_cbctl *) reply->param;
H
Hans Wippel 已提交
1798 1799 1800 1801 1802
	struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
	struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc;

	QETH_CARD_TEXT(card, 2, "vniccrcb");
	if (cmd->hdr.return_code)
1803
		return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code);
H
Hans Wippel 已提交
1804 1805 1806 1807
	/* return results to caller */
	card->options.vnicc.sup_chars = rep->hdr.sup;
	card->options.vnicc.cur_chars = rep->hdr.cur;

1808 1809 1810
	if (cbctl->sub_cmd == IPA_VNICC_QUERY_CMDS)
		*cbctl->result.sup_cmds = rep->query_cmds.sup_cmds;

1811 1812 1813
	if (cbctl->sub_cmd == IPA_VNICC_GET_TIMEOUT)
		*cbctl->result.timeout = rep->getset_timeout.timeout;

H
Hans Wippel 已提交
1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832
	return 0;
}

/* generic VNICC request */
static int qeth_l2_vnicc_request(struct qeth_card *card,
				 struct _qeth_l2_vnicc_request_cbctl *cbctl)
{
	struct qeth_ipacmd_vnicc *req;
	struct qeth_cmd_buffer *iob;
	struct qeth_ipa_cmd *cmd;

	QETH_CARD_TEXT(card, 2, "vniccreq");

	/* get new buffer for request */
	iob = qeth_get_ipacmd_buffer(card, IPA_CMD_VNICC, 0);
	if (!iob)
		return -ENOMEM;

	/* create header for request */
1833
	cmd = __ipa_cmd(iob);
H
Hans Wippel 已提交
1834 1835 1836 1837 1838 1839 1840 1841 1842 1843
	req = &cmd->data.vnicc;

	/* create sub command header for request */
	req->sub_hdr.data_length = sizeof(req->sub_hdr);
	req->sub_hdr.sub_command = cbctl->sub_cmd;

	/* create sub command specific request fields */
	switch (cbctl->sub_cmd) {
	case IPA_VNICC_QUERY_CHARS:
		break;
1844 1845 1846 1847 1848 1849 1850 1851 1852
	case IPA_VNICC_QUERY_CMDS:
		req->sub_hdr.data_length += sizeof(req->query_cmds);
		req->query_cmds.vnic_char = cbctl->param.vnic_char;
		break;
	case IPA_VNICC_ENABLE:
	case IPA_VNICC_DISABLE:
		req->sub_hdr.data_length += sizeof(req->set_char);
		req->set_char.vnic_char = cbctl->param.vnic_char;
		break;
1853 1854 1855 1856 1857 1858 1859
	case IPA_VNICC_SET_TIMEOUT:
		req->getset_timeout.timeout = cbctl->param.timeout;
		/* fallthrough */
	case IPA_VNICC_GET_TIMEOUT:
		req->sub_hdr.data_length += sizeof(req->getset_timeout);
		req->getset_timeout.vnic_char = cbctl->param.vnic_char;
		break;
H
Hans Wippel 已提交
1860 1861 1862 1863 1864 1865
	default:
		qeth_release_buffer(iob->channel, iob);
		return -EOPNOTSUPP;
	}

	/* send request */
1866
	return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, cbctl);
H
Hans Wippel 已提交
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
}

/* VNICC query VNIC characteristics request */
static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
{
	struct _qeth_l2_vnicc_request_cbctl cbctl;

	/* prepare callback control */
	cbctl.sub_cmd = IPA_VNICC_QUERY_CHARS;

	QETH_CARD_TEXT(card, 2, "vniccqch");
	return qeth_l2_vnicc_request(card, &cbctl);
}

1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909
/* VNICC query sub commands request */
static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
				    u32 *sup_cmds)
{
	struct _qeth_l2_vnicc_request_cbctl cbctl;

	/* prepare callback control */
	cbctl.sub_cmd = IPA_VNICC_QUERY_CMDS;
	cbctl.param.vnic_char = vnic_char;
	cbctl.result.sup_cmds = sup_cmds;

	QETH_CARD_TEXT(card, 2, "vniccqcm");
	return qeth_l2_vnicc_request(card, &cbctl);
}

/* VNICC enable/disable characteristic request */
static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
				      u32 cmd)
{
	struct _qeth_l2_vnicc_request_cbctl cbctl;

	/* prepare callback control */
	cbctl.sub_cmd = cmd;
	cbctl.param.vnic_char = vnic_char;

	QETH_CARD_TEXT(card, 2, "vniccedc");
	return qeth_l2_vnicc_request(card, &cbctl);
}

1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
/* VNICC get/set timeout for characteristic request */
static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
					u32 cmd, u32 *timeout)
{
	struct _qeth_l2_vnicc_request_cbctl cbctl;

	/* prepare callback control */
	cbctl.sub_cmd = cmd;
	cbctl.param.vnic_char = vnicc;
	if (cmd == IPA_VNICC_SET_TIMEOUT)
		cbctl.param.timeout = *timeout;
	if (cmd == IPA_VNICC_GET_TIMEOUT)
		cbctl.result.timeout = timeout;

	QETH_CARD_TEXT(card, 2, "vniccgst");
	return qeth_l2_vnicc_request(card, &cbctl);
}

1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970
/* set current VNICC flag state; called from sysfs store function */
int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
{
	int rc = 0;
	u32 cmd;

	QETH_CARD_TEXT(card, 2, "vniccsch");

	/* do not change anything if BridgePort is enabled */
	if (qeth_bridgeport_is_in_use(card))
		return -EBUSY;

	/* check if characteristic and enable/disable are supported */
	if (!(card->options.vnicc.sup_chars & vnicc) ||
	    !(card->options.vnicc.set_char_sup & vnicc))
		return -EOPNOTSUPP;

	/* set enable/disable command and store wanted characteristic */
	if (state) {
		cmd = IPA_VNICC_ENABLE;
		card->options.vnicc.wanted_chars |= vnicc;
	} else {
		cmd = IPA_VNICC_DISABLE;
		card->options.vnicc.wanted_chars &= ~vnicc;
	}

	/* do we need to do anything? */
	if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
		return rc;

	/* if card is not ready, simply stop here */
	if (!qeth_card_hw_is_reachable(card)) {
		if (state)
			card->options.vnicc.cur_chars |= vnicc;
		else
			card->options.vnicc.cur_chars &= ~vnicc;
		return rc;
	}

	rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
	if (rc)
		card->options.vnicc.wanted_chars =
			card->options.vnicc.cur_chars;
1971 1972 1973 1974 1975 1976 1977 1978
	else {
		/* successful online VNICC change; handle special cases */
		if (state && vnicc == QETH_VNICC_RX_BCAST)
			card->options.vnicc.rx_bcast_enabled = true;
		if (!state && vnicc == QETH_VNICC_LEARNING)
			qeth_l2_vnicc_recover_timeout(card, vnicc,
					&card->options.vnicc.learning_timeout);
	}
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005

	return rc;
}

/* get current VNICC flag state; called from sysfs show function */
int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
{
	int rc = 0;

	QETH_CARD_TEXT(card, 2, "vniccgch");

	/* do not get anything if BridgePort is enabled */
	if (qeth_bridgeport_is_in_use(card))
		return -EBUSY;

	/* check if characteristic is supported */
	if (!(card->options.vnicc.sup_chars & vnicc))
		return -EOPNOTSUPP;

	/* if card is ready, query current VNICC state */
	if (qeth_card_hw_is_reachable(card))
		rc = qeth_l2_vnicc_query_chars(card);

	*state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
	return rc;
}

2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
/* set VNICC timeout; called from sysfs store function. Currently, only learning
 * supports timeout
 */
int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
{
	int rc = 0;

	QETH_CARD_TEXT(card, 2, "vniccsto");

	/* do not change anything if BridgePort is enabled */
	if (qeth_bridgeport_is_in_use(card))
		return -EBUSY;

	/* check if characteristic and set_timeout are supported */
	if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
	    !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
		return -EOPNOTSUPP;

	/* do we need to do anything? */
	if (card->options.vnicc.learning_timeout == timeout)
		return rc;

	/* if card is not ready, simply store the value internally and return */
	if (!qeth_card_hw_is_reachable(card)) {
		card->options.vnicc.learning_timeout = timeout;
		return rc;
	}

	/* send timeout value to card; if successful, store value internally */
	rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
					  IPA_VNICC_SET_TIMEOUT, &timeout);
	if (!rc)
		card->options.vnicc.learning_timeout = timeout;

	return rc;
}

/* get current VNICC timeout; called from sysfs show function. Currently, only
 * learning supports timeout
 */
int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
{
	int rc = 0;

	QETH_CARD_TEXT(card, 2, "vniccgto");

	/* do not get anything if BridgePort is enabled */
	if (qeth_bridgeport_is_in_use(card))
		return -EBUSY;

	/* check if characteristic and get_timeout are supported */
	if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
	    !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
		return -EOPNOTSUPP;
	/* if card is ready, get timeout. Otherwise, just return stored value */
	*timeout = card->options.vnicc.learning_timeout;
	if (qeth_card_hw_is_reachable(card))
		rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
						  IPA_VNICC_GET_TIMEOUT,
						  timeout);

	return rc;
}

2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
/* check if VNICC is currently enabled */
bool qeth_l2_vnicc_is_in_use(struct qeth_card *card)
{
	/* if everything is turned off, VNICC is not active */
	if (!card->options.vnicc.cur_chars)
		return false;
	/* default values are only OK if rx_bcast was not enabled by user
	 * or the card is offline.
	 */
	if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
		if (!card->options.vnicc.rx_bcast_enabled ||
		    !qeth_card_hw_is_reachable(card))
			return false;
	}
	return true;
}

2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
/* recover user timeout setting */
static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
					  u32 *timeout)
{
	if (card->options.vnicc.sup_chars & vnicc &&
	    card->options.vnicc.getset_timeout_sup & vnicc &&
	    !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
					  timeout))
		return false;
	*timeout = QETH_VNICC_DEFAULT_TIMEOUT;
	return true;
}

2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
/* recover user characteristic setting */
static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
				       bool enable)
{
	u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE;

	if (card->options.vnicc.sup_chars & vnicc &&
	    card->options.vnicc.set_char_sup & vnicc &&
	    !qeth_l2_vnicc_set_char(card, vnicc, cmd))
		return false;
	card->options.vnicc.wanted_chars &= ~vnicc;
	card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
	return true;
}

H
Hans Wippel 已提交
2115 2116 2117
/* (re-)initialize VNICC */
static void qeth_l2_vnicc_init(struct qeth_card *card)
{
2118
	u32 *timeout = &card->options.vnicc.learning_timeout;
2119 2120 2121 2122 2123
	unsigned int chars_len, i;
	unsigned long chars_tmp;
	u32 sup_cmds, vnicc;
	bool enable, error;

H
Hans Wippel 已提交
2124
	QETH_CARD_TEXT(card, 2, "vniccini");
2125 2126
	/* reset rx_bcast */
	card->options.vnicc.rx_bcast_enabled = 0;
H
Hans Wippel 已提交
2127 2128
	/* initial query and storage of VNIC characteristics */
	if (qeth_l2_vnicc_query_chars(card)) {
2129 2130
		if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
		    *timeout != QETH_VNICC_DEFAULT_TIMEOUT)
2131 2132
			dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
		/* fail quietly if user didn't change the default config */
H
Hans Wippel 已提交
2133 2134
		card->options.vnicc.sup_chars = 0;
		card->options.vnicc.cur_chars = 0;
2135 2136
		card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
		return;
H
Hans Wippel 已提交
2137
	}
2138 2139 2140 2141 2142 2143
	/* get supported commands for each supported characteristic */
	chars_tmp = card->options.vnicc.sup_chars;
	chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
	for_each_set_bit(i, &chars_tmp, chars_len) {
		vnicc = BIT(i);
		qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds);
2144 2145 2146
		if (!(sup_cmds & IPA_VNICC_SET_TIMEOUT) ||
		    !(sup_cmds & IPA_VNICC_GET_TIMEOUT))
			card->options.vnicc.getset_timeout_sup &= ~vnicc;
2147 2148 2149 2150 2151
		if (!(sup_cmds & IPA_VNICC_ENABLE) ||
		    !(sup_cmds & IPA_VNICC_DISABLE))
			card->options.vnicc.set_char_sup &= ~vnicc;
	}
	/* enforce assumed default values and recover settings, if changed  */
2152 2153
	error = qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
					      timeout);
2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171
	chars_tmp = card->options.vnicc.wanted_chars ^ QETH_VNICC_DEFAULT;
	chars_tmp |= QETH_VNICC_BRIDGE_INVISIBLE;
	chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
	for_each_set_bit(i, &chars_tmp, chars_len) {
		vnicc = BIT(i);
		enable = card->options.vnicc.wanted_chars & vnicc;
		error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
	}
	if (error)
		dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
}

/* configure default values of VNIC characteristics */
static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
{
	/* characteristics values */
	card->options.vnicc.sup_chars = QETH_VNICC_ALL;
	card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
2172
	card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
2173 2174
	/* supported commands */
	card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
2175
	card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
2176 2177
	/* settings wanted by users */
	card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
H
Hans Wippel 已提交
2178 2179
}

F
Frank Blaschka 已提交
2180 2181 2182 2183 2184
module_init(qeth_l2_init);
module_exit(qeth_l2_exit);
MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
MODULE_DESCRIPTION("qeth layer 2 discipline");
MODULE_LICENSE("GPL");